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

package/dist/src/pymc/pymc.d.ts

@@ -0,0 +1,2932 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * PyMC Bayesian inference platform functions for East.
+ *
+ * Provides Bayesian linear regression, hierarchical models, and multi-layer
+ * joint estimation with full posterior analysis using PyMC.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, BooleanType, BlobType, StringType, NullType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+export { VectorType, MatrixType } from "../types.js";
+/**
+ * Prior distribution type for PyMC parameters.
+ */
+export declare const PyMCPriorDistributionType: VariantType<{
+    /** Half-normal distribution (positive only) */
+    readonly halfnormal: NullType;
+    /** Log-normal distribution */
+    readonly lognormal: NullType;
+    /** Normal (Gaussian) distribution */
+    readonly normal: NullType;
+    /** Half-Cauchy distribution (heavy tails, positive only) */
+    readonly halfcauchy: NullType;
+    /** Exponential distribution */
+    readonly exponential: NullType;
+    /** Uniform distribution */
+    readonly uniform: NullType;
+    /** Horseshoe prior (sparsity-inducing) */
+    readonly horseshoe: NullType;
+}>;
+/**
+ * Likelihood function type.
+ */
+export declare const PyMCLikelihoodType: VariantType<{
+    /** Normal (Gaussian) likelihood */
+    readonly normal: NullType;
+    /** Student-t likelihood (robust to outliers) */
+    readonly studentt: NullType;
+    /** Poisson likelihood (count data) */
+    readonly poisson: NullType;
+}>;
+/**
+ * Pooling type for hierarchical models.
+ */
+export declare const PyMCPoolingType: VariantType<{
+    /** No pooling (independent per group) */
+    readonly none: NullType;
+    /** Partial pooling (shared hyperpriors) */
+    readonly partial: NullType;
+    /** Full pooling (all groups share same parameters) */
+    readonly full: NullType;
+}>;
+/**
+ * Prior distribution parameters.
+ */
+export declare const PyMCPriorParamsType: StructType<{
+    /** Mean (for normal/lognormal) */
+    readonly mu: OptionType<MatrixType<FloatType>>;
+    /** Standard deviation */
+    readonly sigma: OptionType<MatrixType<FloatType>>;
+    /** Precision (for exponential rate) */
+    readonly tau: OptionType<FloatType>;
+    /** Lower bound (for uniform) */
+    readonly lower: OptionType<FloatType>;
+    /** Upper bound (for uniform) */
+    readonly upper: OptionType<FloatType>;
+}>;
+/**
+ * Prior specification combining distribution and parameters.
+ */
+export declare const PyMCPriorSpecType: StructType<{
+    /** Distribution type */
+    readonly distribution: VariantType<{
+        /** Half-normal distribution (positive only) */
+        readonly halfnormal: NullType;
+        /** Log-normal distribution */
+        readonly lognormal: NullType;
+        /** Normal (Gaussian) distribution */
+        readonly normal: NullType;
+        /** Half-Cauchy distribution (heavy tails, positive only) */
+        readonly halfcauchy: NullType;
+        /** Exponential distribution */
+        readonly exponential: NullType;
+        /** Uniform distribution */
+        readonly uniform: NullType;
+        /** Horseshoe prior (sparsity-inducing) */
+        readonly horseshoe: NullType;
+    }>;
+    /** Distribution parameters */
+    readonly params: StructType<{
+        /** Mean (for normal/lognormal) */
+        readonly mu: OptionType<MatrixType<FloatType>>;
+        /** Standard deviation */
+        readonly sigma: OptionType<MatrixType<FloatType>>;
+        /** Precision (for exponential rate) */
+        readonly tau: OptionType<FloatType>;
+        /** Lower bound (for uniform) */
+        readonly lower: OptionType<FloatType>;
+        /** Upper bound (for uniform) */
+        readonly upper: OptionType<FloatType>;
+    }>;
+}>;
+/**
+ * Configuration for Bayesian linear regression.
+ */
+export declare const PyMCRegressionConfigType: StructType<{
+    /** Prior specification for coefficients */
+    readonly prior: OptionType<StructType<{
+        /** Distribution type */
+        readonly distribution: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Distribution parameters */
+        readonly params: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Likelihood function */
+    readonly likelihood: OptionType<VariantType<{
+        /** Normal (Gaussian) likelihood */
+        readonly normal: NullType;
+        /** Student-t likelihood (robust to outliers) */
+        readonly studentt: NullType;
+        /** Poisson likelihood (count data) */
+        readonly poisson: NullType;
+    }>>;
+    /** Whether to include intercept term (default true) */
+    readonly include_intercept: OptionType<BooleanType>;
+    /** Number of posterior samples (default 1000) */
+    readonly samples: OptionType<IntegerType>;
+    /** Number of tuning steps (default 1000) */
+    readonly tune: OptionType<IntegerType>;
+    /** Number of MCMC chains (default 2) */
+    readonly chains: OptionType<IntegerType>;
+    /** Target acceptance rate (default 0.8) */
+    readonly target_accept: OptionType<FloatType>;
+}>;
+/**
+ * Configuration for hierarchical models.
+ */
+export declare const PyMCHierarchicalConfigType: StructType<{
+    /** Prior specification for coefficients */
+    readonly prior: OptionType<StructType<{
+        /** Distribution type */
+        readonly distribution: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Distribution parameters */
+        readonly params: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Likelihood function */
+    readonly likelihood: OptionType<VariantType<{
+        /** Normal (Gaussian) likelihood */
+        readonly normal: NullType;
+        /** Student-t likelihood (robust to outliers) */
+        readonly studentt: NullType;
+        /** Poisson likelihood (count data) */
+        readonly poisson: NullType;
+    }>>;
+    /** Pooling type (default partial) */
+    readonly pooling: OptionType<VariantType<{
+        /** No pooling (independent per group) */
+        readonly none: NullType;
+        /** Partial pooling (shared hyperpriors) */
+        readonly partial: NullType;
+        /** Full pooling (all groups share same parameters) */
+        readonly full: NullType;
+    }>>;
+    /** Number of posterior samples (default 1000) */
+    readonly samples: OptionType<IntegerType>;
+    /** Number of tuning steps (default 1000) */
+    readonly tune: OptionType<IntegerType>;
+    /** Number of MCMC chains (default 2) */
+    readonly chains: OptionType<IntegerType>;
+    /** Target acceptance rate (default 0.8) */
+    readonly target_accept: OptionType<FloatType>;
+}>;
+/**
+ * Layer specification for multi-layer models.
+ */
+export declare const PyMCLayerSpecType: StructType<{
+    /** Layer name */
+    readonly name: StringType;
+    /** Input data name */
+    readonly input: StringType;
+    /** Output data name */
+    readonly output: StringType;
+    /** Parameter name for coefficients */
+    readonly parameter: StringType;
+    /** Likelihood function */
+    readonly likelihood: OptionType<VariantType<{
+        /** Normal (Gaussian) likelihood */
+        readonly normal: NullType;
+        /** Student-t likelihood (robust to outliers) */
+        readonly studentt: NullType;
+        /** Poisson likelihood (count data) */
+        readonly poisson: NullType;
+    }>>;
+}>;
+/**
+ * Named prior specification.
+ */
+export declare const PyMCNamedPriorType: StructType<{
+    /** Parameter name this prior applies to */
+    readonly name: StringType;
+    /** Prior specification */
+    readonly prior: StructType<{
+        /** Distribution type */
+        readonly distribution: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Distribution parameters */
+        readonly params: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+    }>;
+}>;
+/**
+ * Named boolean mask.
+ */
+export declare const PyMCNamedMaskType: StructType<{
+    /** Parameter name this mask applies to */
+    readonly name: StringType;
+    /** Boolean mask matrix (true = estimate, false = fix to zero) */
+    readonly mask: MatrixType<BooleanType>;
+}>;
+/**
+ * Configuration for multi-layer joint estimation.
+ */
+export declare const PyMCMultiLayerConfigType: StructType<{
+    /** Layer specifications */
+    readonly layers: ArrayType<StructType<{
+        /** Layer name */
+        readonly name: StringType;
+        /** Input data name */
+        readonly input: StringType;
+        /** Output data name */
+        readonly output: StringType;
+        /** Parameter name for coefficients */
+        readonly parameter: StringType;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+    }>>;
+    /** Named priors for parameters */
+    readonly priors: OptionType<ArrayType<StructType<{
+        /** Parameter name this prior applies to */
+        readonly name: StringType;
+        /** Prior specification */
+        readonly prior: StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>;
+    }>>>;
+    /** Named masks for parameter sparsity */
+    readonly masks: OptionType<ArrayType<StructType<{
+        /** Parameter name this mask applies to */
+        readonly name: StringType;
+        /** Boolean mask matrix (true = estimate, false = fix to zero) */
+        readonly mask: MatrixType<BooleanType>;
+    }>>>;
+    /** Number of posterior samples (default 1000) */
+    readonly samples: OptionType<IntegerType>;
+    /** Number of tuning steps (default 1000) */
+    readonly tune: OptionType<IntegerType>;
+    /** Number of MCMC chains (default 2) */
+    readonly chains: OptionType<IntegerType>;
+    /** Target acceptance rate (default 0.8) */
+    readonly target_accept: OptionType<FloatType>;
+    /** Force full MCMC even for large models (default false) */
+    readonly force_full_mcmc: OptionType<BooleanType>;
+    /** L1 regularization alpha for fallback (default 0.01) */
+    readonly fallback_l1_alpha: OptionType<FloatType>;
+}>;
+/**
+ * Named data for multi-layer models.
+ */
+export declare const PyMCNamedDataType: StructType<{
+    /** Data name */
+    readonly name: StringType;
+    /** Data matrix */
+    readonly data: MatrixType<FloatType>;
+}>;
+/**
+ * Prediction configuration.
+ */
+export declare const PyMCPredictConfigType: StructType<{
+    /** Layer name to predict from (for multi-layer models) */
+    readonly layer: OptionType<StringType>;
+    /** Number of posterior samples to use for prediction (default 100) */
+    readonly n_samples: OptionType<IntegerType>;
+}>;
+/**
+ * Individual parameter estimate with diagnostics.
+ */
+export declare const PyMCParameterEstimateType: StructType<{
+    /** Row index in parameter matrix */
+    readonly index_row: IntegerType;
+    /** Column index in parameter matrix */
+    readonly index_col: IntegerType;
+    /** Posterior mean */
+    readonly mean: FloatType;
+    /** Posterior median */
+    readonly median: FloatType;
+    /** Posterior standard deviation */
+    readonly sd: FloatType;
+    /** Lower 95% credible interval */
+    readonly ci_lower: FloatType;
+    /** Upper 95% credible interval */
+    readonly ci_upper: FloatType;
+    /** R-hat convergence diagnostic */
+    readonly rhat: FloatType;
+    /** Effective sample size */
+    readonly ess: FloatType;
+}>;
+/**
+ * Summary for one named parameter.
+ */
+export declare const PyMCParameterSummaryType: StructType<{
+    /** Parameter name */
+    readonly parameter: StringType;
+    /** Number of rows */
+    readonly shape_rows: IntegerType;
+    /** Number of columns */
+    readonly shape_cols: IntegerType;
+    /** Per-element estimates */
+    readonly estimates: ArrayType<StructType<{
+        /** Row index in parameter matrix */
+        readonly index_row: IntegerType;
+        /** Column index in parameter matrix */
+        readonly index_col: IntegerType;
+        /** Posterior mean */
+        readonly mean: FloatType;
+        /** Posterior median */
+        readonly median: FloatType;
+        /** Posterior standard deviation */
+        readonly sd: FloatType;
+        /** Lower 95% credible interval */
+        readonly ci_lower: FloatType;
+        /** Upper 95% credible interval */
+        readonly ci_upper: FloatType;
+        /** R-hat convergence diagnostic */
+        readonly rhat: FloatType;
+        /** Effective sample size */
+        readonly ess: FloatType;
+    }>>;
+}>;
+/**
+ * Diagnostics for one parameter.
+ */
+export declare const PyMCParameterDiagType: StructType<{
+    /** Parameter name */
+    readonly parameter: StringType;
+    /** Maximum R-hat across elements */
+    readonly rhat_max: FloatType;
+    /** Minimum ESS across elements */
+    readonly ess_min: FloatType;
+    /** Number of divergent transitions */
+    readonly n_divergent: IntegerType;
+}>;
+/**
+ * Overall diagnostics result.
+ */
+export declare const PyMCDiagnosticsResultType: StructType<{
+    /** Whether all diagnostics indicate convergence */
+    readonly converged: BooleanType;
+    /** Total number of divergent transitions */
+    readonly n_divergences: IntegerType;
+    /** Per-parameter diagnostics */
+    readonly parameters: ArrayType<StructType<{
+        /** Parameter name */
+        readonly parameter: StringType;
+        /** Maximum R-hat across elements */
+        readonly rhat_max: FloatType;
+        /** Minimum ESS across elements */
+        readonly ess_min: FloatType;
+        /** Number of divergent transitions */
+        readonly n_divergent: IntegerType;
+    }>>;
+    /** Warning messages */
+    readonly warnings: ArrayType<StringType>;
+}>;
+/**
+ * Observed fit metrics for posterior predictive checks.
+ */
+export declare const PyMCObservedFitType: StructType<{
+    /** Target column name or index */
+    readonly name: StringType;
+    /** Mean absolute error */
+    readonly mae: FloatType;
+    /** Pearson correlation */
+    readonly correlation: FloatType;
+    /** 95% credible interval coverage */
+    readonly coverage_95: FloatType;
+}>;
+/**
+ * Model blob type for serialized PyMC models.
+ */
+export declare const PyMCModelBlobType: VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>;
+/**
+ * Train a Bayesian linear regression model.
+ *
+ * @param X - Feature matrix (n_samples x n_features)
+ * @param Y - Target matrix (n_samples x n_targets)
+ * @param config - Regression configuration
+ * @returns Trained PyMC model blob
+ */
+export declare const pymc_train_regression: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, MatrixType<FloatType>, StructType<{
+    /** Prior specification for coefficients */
+    readonly prior: OptionType<StructType<{
+        /** Distribution type */
+        readonly distribution: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Distribution parameters */
+        readonly params: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Likelihood function */
+    readonly likelihood: OptionType<VariantType<{
+        /** Normal (Gaussian) likelihood */
+        readonly normal: NullType;
+        /** Student-t likelihood (robust to outliers) */
+        readonly studentt: NullType;
+        /** Poisson likelihood (count data) */
+        readonly poisson: NullType;
+    }>>;
+    /** Whether to include intercept term (default true) */
+    readonly include_intercept: OptionType<BooleanType>;
+    /** Number of posterior samples (default 1000) */
+    readonly samples: OptionType<IntegerType>;
+    /** Number of tuning steps (default 1000) */
+    readonly tune: OptionType<IntegerType>;
+    /** Number of MCMC chains (default 2) */
+    readonly chains: OptionType<IntegerType>;
+    /** Target acceptance rate (default 0.8) */
+    readonly target_accept: OptionType<FloatType>;
+}>], VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>>;
+/**
+ * Train a hierarchical Bayesian model.
+ *
+ * @param X - Feature matrix (n_samples x n_features)
+ * @param Y - Target matrix (n_samples x n_targets)
+ * @param groups - Group assignments per sample
+ * @param config - Hierarchical configuration
+ * @returns Trained PyMC model blob
+ */
+export declare const pymc_train_hierarchical: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, MatrixType<FloatType>, VectorType<IntegerType>, StructType<{
+    /** Prior specification for coefficients */
+    readonly prior: OptionType<StructType<{
+        /** Distribution type */
+        readonly distribution: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Distribution parameters */
+        readonly params: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Likelihood function */
+    readonly likelihood: OptionType<VariantType<{
+        /** Normal (Gaussian) likelihood */
+        readonly normal: NullType;
+        /** Student-t likelihood (robust to outliers) */
+        readonly studentt: NullType;
+        /** Poisson likelihood (count data) */
+        readonly poisson: NullType;
+    }>>;
+    /** Pooling type (default partial) */
+    readonly pooling: OptionType<VariantType<{
+        /** No pooling (independent per group) */
+        readonly none: NullType;
+        /** Partial pooling (shared hyperpriors) */
+        readonly partial: NullType;
+        /** Full pooling (all groups share same parameters) */
+        readonly full: NullType;
+    }>>;
+    /** Number of posterior samples (default 1000) */
+    readonly samples: OptionType<IntegerType>;
+    /** Number of tuning steps (default 1000) */
+    readonly tune: OptionType<IntegerType>;
+    /** Number of MCMC chains (default 2) */
+    readonly chains: OptionType<IntegerType>;
+    /** Target acceptance rate (default 0.8) */
+    readonly target_accept: OptionType<FloatType>;
+}>], VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>>;
+/**
+ * Train a multi-layer joint estimation model.
+ *
+ * @param data - Array of named data matrices
+ * @param config - Multi-layer configuration
+ * @returns Trained PyMC model blob
+ */
+export declare const pymc_train_multi_layer: import("@elaraai/east").PlatformDefinition<[ArrayType<StructType<{
+    /** Data name */
+    readonly name: StringType;
+    /** Data matrix */
+    readonly data: MatrixType<FloatType>;
+}>>, StructType<{
+    /** Layer specifications */
+    readonly layers: ArrayType<StructType<{
+        /** Layer name */
+        readonly name: StringType;
+        /** Input data name */
+        readonly input: StringType;
+        /** Output data name */
+        readonly output: StringType;
+        /** Parameter name for coefficients */
+        readonly parameter: StringType;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+    }>>;
+    /** Named priors for parameters */
+    readonly priors: OptionType<ArrayType<StructType<{
+        /** Parameter name this prior applies to */
+        readonly name: StringType;
+        /** Prior specification */
+        readonly prior: StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>;
+    }>>>;
+    /** Named masks for parameter sparsity */
+    readonly masks: OptionType<ArrayType<StructType<{
+        /** Parameter name this mask applies to */
+        readonly name: StringType;
+        /** Boolean mask matrix (true = estimate, false = fix to zero) */
+        readonly mask: MatrixType<BooleanType>;
+    }>>>;
+    /** Number of posterior samples (default 1000) */
+    readonly samples: OptionType<IntegerType>;
+    /** Number of tuning steps (default 1000) */
+    readonly tune: OptionType<IntegerType>;
+    /** Number of MCMC chains (default 2) */
+    readonly chains: OptionType<IntegerType>;
+    /** Target acceptance rate (default 0.8) */
+    readonly target_accept: OptionType<FloatType>;
+    /** Force full MCMC even for large models (default false) */
+    readonly force_full_mcmc: OptionType<BooleanType>;
+    /** L1 regularization alpha for fallback (default 0.01) */
+    readonly fallback_l1_alpha: OptionType<FloatType>;
+}>], VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>>;
+/**
+ * Make point predictions (posterior mean).
+ *
+ * @param model - Trained PyMC model blob
+ * @param X - Feature matrix
+ * @param config - Prediction configuration
+ * @returns Predicted values matrix
+ */
+export declare const pymc_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>, MatrixType<FloatType>, StructType<{
+    /** Layer name to predict from (for multi-layer models) */
+    readonly layer: OptionType<StringType>;
+    /** Number of posterior samples to use for prediction (default 100) */
+    readonly n_samples: OptionType<IntegerType>;
+}>], MatrixType<FloatType>>;
+/**
+ * Make predictions returning full posterior distribution.
+ *
+ * Returns matrix where each row is a posterior sample prediction.
+ *
+ * @param model - Trained PyMC model blob
+ * @param X - Feature matrix
+ * @param config - Prediction configuration
+ * @returns Posterior predictive samples matrix
+ */
+export declare const pymc_predict_distribution: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>, MatrixType<FloatType>, StructType<{
+    /** Layer name to predict from (for multi-layer models) */
+    readonly layer: OptionType<StringType>;
+    /** Number of posterior samples to use for prediction (default 100) */
+    readonly n_samples: OptionType<IntegerType>;
+}>], MatrixType<FloatType>>;
+/**
+ * Get posterior parameter summaries.
+ *
+ * @param model - Trained PyMC model blob
+ * @returns Array of parameter summaries
+ */
+export declare const pymc_posterior_summary: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>], ArrayType<StructType<{
+    /** Parameter name */
+    readonly parameter: StringType;
+    /** Number of rows */
+    readonly shape_rows: IntegerType;
+    /** Number of columns */
+    readonly shape_cols: IntegerType;
+    /** Per-element estimates */
+    readonly estimates: ArrayType<StructType<{
+        /** Row index in parameter matrix */
+        readonly index_row: IntegerType;
+        /** Column index in parameter matrix */
+        readonly index_col: IntegerType;
+        /** Posterior mean */
+        readonly mean: FloatType;
+        /** Posterior median */
+        readonly median: FloatType;
+        /** Posterior standard deviation */
+        readonly sd: FloatType;
+        /** Lower 95% credible interval */
+        readonly ci_lower: FloatType;
+        /** Upper 95% credible interval */
+        readonly ci_upper: FloatType;
+        /** R-hat convergence diagnostic */
+        readonly rhat: FloatType;
+        /** Effective sample size */
+        readonly ess: FloatType;
+    }>>;
+}>>>;
+/**
+ * Extract raw posterior samples for a named parameter.
+ *
+ * @param model - Trained PyMC model blob
+ * @param param_name - Parameter name
+ * @param n_samples - Number of samples to return
+ * @returns Matrix of posterior samples
+ */
+export declare const pymc_posterior_samples: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>, StringType, IntegerType], MatrixType<FloatType>>;
+/**
+ * Run convergence diagnostics on a trained model.
+ *
+ * @param model - Trained PyMC model blob
+ * @returns Diagnostics result
+ */
+export declare const pymc_diagnostics: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>], StructType<{
+    /** Whether all diagnostics indicate convergence */
+    readonly converged: BooleanType;
+    /** Total number of divergent transitions */
+    readonly n_divergences: IntegerType;
+    /** Per-parameter diagnostics */
+    readonly parameters: ArrayType<StructType<{
+        /** Parameter name */
+        readonly parameter: StringType;
+        /** Maximum R-hat across elements */
+        readonly rhat_max: FloatType;
+        /** Minimum ESS across elements */
+        readonly ess_min: FloatType;
+        /** Number of divergent transitions */
+        readonly n_divergent: IntegerType;
+    }>>;
+    /** Warning messages */
+    readonly warnings: ArrayType<StringType>;
+}>>;
+/**
+ * Posterior predictive check against observed data.
+ *
+ * @param model - Trained PyMC model blob
+ * @param X - Feature matrix
+ * @param Y_observed - Observed target matrix
+ * @returns Array of fit metrics per target
+ */
+export declare const pymc_posterior_predictive_check: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Bayesian linear regression model */
+    readonly pymc_regression: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Whether intercept is included */
+        readonly include_intercept: BooleanType;
+    }>;
+    /** Hierarchical Bayesian model */
+    readonly pymc_hierarchical: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of target columns */
+        readonly n_targets: IntegerType;
+        /** Number of groups */
+        readonly n_groups: IntegerType;
+    }>;
+    /** Multi-layer joint estimation model */
+    readonly pymc_multi_layer: StructType<{
+        /** Cloudpickle serialized model data */
+        readonly data: BlobType;
+        /** Layer names */
+        readonly layer_names: ArrayType<StringType>;
+        /** Parameter names */
+        readonly parameter_names: ArrayType<StringType>;
+    }>;
+}>, MatrixType<FloatType>, MatrixType<FloatType>], ArrayType<StructType<{
+    /** Target column name or index */
+    readonly name: StringType;
+    /** Mean absolute error */
+    readonly mae: FloatType;
+    /** Pearson correlation */
+    readonly correlation: FloatType;
+    /** 95% credible interval coverage */
+    readonly coverage_95: FloatType;
+}>>>;
+/**
+ * Type definitions for PyMC functions.
+ */
+export declare const PyMCTypes: {
+    /** Prior distribution type */
+    readonly PyMCPriorDistributionType: VariantType<{
+        /** Half-normal distribution (positive only) */
+        readonly halfnormal: NullType;
+        /** Log-normal distribution */
+        readonly lognormal: NullType;
+        /** Normal (Gaussian) distribution */
+        readonly normal: NullType;
+        /** Half-Cauchy distribution (heavy tails, positive only) */
+        readonly halfcauchy: NullType;
+        /** Exponential distribution */
+        readonly exponential: NullType;
+        /** Uniform distribution */
+        readonly uniform: NullType;
+        /** Horseshoe prior (sparsity-inducing) */
+        readonly horseshoe: NullType;
+    }>;
+    /** Likelihood type */
+    readonly PyMCLikelihoodType: VariantType<{
+        /** Normal (Gaussian) likelihood */
+        readonly normal: NullType;
+        /** Student-t likelihood (robust to outliers) */
+        readonly studentt: NullType;
+        /** Poisson likelihood (count data) */
+        readonly poisson: NullType;
+    }>;
+    /** Pooling type */
+    readonly PyMCPoolingType: VariantType<{
+        /** No pooling (independent per group) */
+        readonly none: NullType;
+        /** Partial pooling (shared hyperpriors) */
+        readonly partial: NullType;
+        /** Full pooling (all groups share same parameters) */
+        readonly full: NullType;
+    }>;
+    /** Prior parameters */
+    readonly PyMCPriorParamsType: StructType<{
+        /** Mean (for normal/lognormal) */
+        readonly mu: OptionType<MatrixType<FloatType>>;
+        /** Standard deviation */
+        readonly sigma: OptionType<MatrixType<FloatType>>;
+        /** Precision (for exponential rate) */
+        readonly tau: OptionType<FloatType>;
+        /** Lower bound (for uniform) */
+        readonly lower: OptionType<FloatType>;
+        /** Upper bound (for uniform) */
+        readonly upper: OptionType<FloatType>;
+    }>;
+    /** Prior specification */
+    readonly PyMCPriorSpecType: StructType<{
+        /** Distribution type */
+        readonly distribution: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Distribution parameters */
+        readonly params: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+    }>;
+    /** Regression configuration */
+    readonly PyMCRegressionConfigType: StructType<{
+        /** Prior specification for coefficients */
+        readonly prior: OptionType<StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+        /** Whether to include intercept term (default true) */
+        readonly include_intercept: OptionType<BooleanType>;
+        /** Number of posterior samples (default 1000) */
+        readonly samples: OptionType<IntegerType>;
+        /** Number of tuning steps (default 1000) */
+        readonly tune: OptionType<IntegerType>;
+        /** Number of MCMC chains (default 2) */
+        readonly chains: OptionType<IntegerType>;
+        /** Target acceptance rate (default 0.8) */
+        readonly target_accept: OptionType<FloatType>;
+    }>;
+    /** Hierarchical configuration */
+    readonly PyMCHierarchicalConfigType: StructType<{
+        /** Prior specification for coefficients */
+        readonly prior: OptionType<StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+        /** Pooling type (default partial) */
+        readonly pooling: OptionType<VariantType<{
+            /** No pooling (independent per group) */
+            readonly none: NullType;
+            /** Partial pooling (shared hyperpriors) */
+            readonly partial: NullType;
+            /** Full pooling (all groups share same parameters) */
+            readonly full: NullType;
+        }>>;
+        /** Number of posterior samples (default 1000) */
+        readonly samples: OptionType<IntegerType>;
+        /** Number of tuning steps (default 1000) */
+        readonly tune: OptionType<IntegerType>;
+        /** Number of MCMC chains (default 2) */
+        readonly chains: OptionType<IntegerType>;
+        /** Target acceptance rate (default 0.8) */
+        readonly target_accept: OptionType<FloatType>;
+    }>;
+    /** Layer specification */
+    readonly PyMCLayerSpecType: StructType<{
+        /** Layer name */
+        readonly name: StringType;
+        /** Input data name */
+        readonly input: StringType;
+        /** Output data name */
+        readonly output: StringType;
+        /** Parameter name for coefficients */
+        readonly parameter: StringType;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+    }>;
+    /** Named prior */
+    readonly PyMCNamedPriorType: StructType<{
+        /** Parameter name this prior applies to */
+        readonly name: StringType;
+        /** Prior specification */
+        readonly prior: StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>;
+    }>;
+    /** Named mask */
+    readonly PyMCNamedMaskType: StructType<{
+        /** Parameter name this mask applies to */
+        readonly name: StringType;
+        /** Boolean mask matrix (true = estimate, false = fix to zero) */
+        readonly mask: MatrixType<BooleanType>;
+    }>;
+    /** Multi-layer configuration */
+    readonly PyMCMultiLayerConfigType: StructType<{
+        /** Layer specifications */
+        readonly layers: ArrayType<StructType<{
+            /** Layer name */
+            readonly name: StringType;
+            /** Input data name */
+            readonly input: StringType;
+            /** Output data name */
+            readonly output: StringType;
+            /** Parameter name for coefficients */
+            readonly parameter: StringType;
+            /** Likelihood function */
+            readonly likelihood: OptionType<VariantType<{
+                /** Normal (Gaussian) likelihood */
+                readonly normal: NullType;
+                /** Student-t likelihood (robust to outliers) */
+                readonly studentt: NullType;
+                /** Poisson likelihood (count data) */
+                readonly poisson: NullType;
+            }>>;
+        }>>;
+        /** Named priors for parameters */
+        readonly priors: OptionType<ArrayType<StructType<{
+            /** Parameter name this prior applies to */
+            readonly name: StringType;
+            /** Prior specification */
+            readonly prior: StructType<{
+                /** Distribution type */
+                readonly distribution: VariantType<{
+                    /** Half-normal distribution (positive only) */
+                    readonly halfnormal: NullType;
+                    /** Log-normal distribution */
+                    readonly lognormal: NullType;
+                    /** Normal (Gaussian) distribution */
+                    readonly normal: NullType;
+                    /** Half-Cauchy distribution (heavy tails, positive only) */
+                    readonly halfcauchy: NullType;
+                    /** Exponential distribution */
+                    readonly exponential: NullType;
+                    /** Uniform distribution */
+                    readonly uniform: NullType;
+                    /** Horseshoe prior (sparsity-inducing) */
+                    readonly horseshoe: NullType;
+                }>;
+                /** Distribution parameters */
+                readonly params: StructType<{
+                    /** Mean (for normal/lognormal) */
+                    readonly mu: OptionType<MatrixType<FloatType>>;
+                    /** Standard deviation */
+                    readonly sigma: OptionType<MatrixType<FloatType>>;
+                    /** Precision (for exponential rate) */
+                    readonly tau: OptionType<FloatType>;
+                    /** Lower bound (for uniform) */
+                    readonly lower: OptionType<FloatType>;
+                    /** Upper bound (for uniform) */
+                    readonly upper: OptionType<FloatType>;
+                }>;
+            }>;
+        }>>>;
+        /** Named masks for parameter sparsity */
+        readonly masks: OptionType<ArrayType<StructType<{
+            /** Parameter name this mask applies to */
+            readonly name: StringType;
+            /** Boolean mask matrix (true = estimate, false = fix to zero) */
+            readonly mask: MatrixType<BooleanType>;
+        }>>>;
+        /** Number of posterior samples (default 1000) */
+        readonly samples: OptionType<IntegerType>;
+        /** Number of tuning steps (default 1000) */
+        readonly tune: OptionType<IntegerType>;
+        /** Number of MCMC chains (default 2) */
+        readonly chains: OptionType<IntegerType>;
+        /** Target acceptance rate (default 0.8) */
+        readonly target_accept: OptionType<FloatType>;
+        /** Force full MCMC even for large models (default false) */
+        readonly force_full_mcmc: OptionType<BooleanType>;
+        /** L1 regularization alpha for fallback (default 0.01) */
+        readonly fallback_l1_alpha: OptionType<FloatType>;
+    }>;
+    /** Named data */
+    readonly PyMCNamedDataType: StructType<{
+        /** Data name */
+        readonly name: StringType;
+        /** Data matrix */
+        readonly data: MatrixType<FloatType>;
+    }>;
+    /** Prediction configuration */
+    readonly PyMCPredictConfigType: StructType<{
+        /** Layer name to predict from (for multi-layer models) */
+        readonly layer: OptionType<StringType>;
+        /** Number of posterior samples to use for prediction (default 100) */
+        readonly n_samples: OptionType<IntegerType>;
+    }>;
+    /** Parameter estimate */
+    readonly PyMCParameterEstimateType: StructType<{
+        /** Row index in parameter matrix */
+        readonly index_row: IntegerType;
+        /** Column index in parameter matrix */
+        readonly index_col: IntegerType;
+        /** Posterior mean */
+        readonly mean: FloatType;
+        /** Posterior median */
+        readonly median: FloatType;
+        /** Posterior standard deviation */
+        readonly sd: FloatType;
+        /** Lower 95% credible interval */
+        readonly ci_lower: FloatType;
+        /** Upper 95% credible interval */
+        readonly ci_upper: FloatType;
+        /** R-hat convergence diagnostic */
+        readonly rhat: FloatType;
+        /** Effective sample size */
+        readonly ess: FloatType;
+    }>;
+    /** Parameter summary */
+    readonly PyMCParameterSummaryType: StructType<{
+        /** Parameter name */
+        readonly parameter: StringType;
+        /** Number of rows */
+        readonly shape_rows: IntegerType;
+        /** Number of columns */
+        readonly shape_cols: IntegerType;
+        /** Per-element estimates */
+        readonly estimates: ArrayType<StructType<{
+            /** Row index in parameter matrix */
+            readonly index_row: IntegerType;
+            /** Column index in parameter matrix */
+            readonly index_col: IntegerType;
+            /** Posterior mean */
+            readonly mean: FloatType;
+            /** Posterior median */
+            readonly median: FloatType;
+            /** Posterior standard deviation */
+            readonly sd: FloatType;
+            /** Lower 95% credible interval */
+            readonly ci_lower: FloatType;
+            /** Upper 95% credible interval */
+            readonly ci_upper: FloatType;
+            /** R-hat convergence diagnostic */
+            readonly rhat: FloatType;
+            /** Effective sample size */
+            readonly ess: FloatType;
+        }>>;
+    }>;
+    /** Parameter diagnostics */
+    readonly PyMCParameterDiagType: StructType<{
+        /** Parameter name */
+        readonly parameter: StringType;
+        /** Maximum R-hat across elements */
+        readonly rhat_max: FloatType;
+        /** Minimum ESS across elements */
+        readonly ess_min: FloatType;
+        /** Number of divergent transitions */
+        readonly n_divergent: IntegerType;
+    }>;
+    /** Diagnostics result */
+    readonly PyMCDiagnosticsResultType: StructType<{
+        /** Whether all diagnostics indicate convergence */
+        readonly converged: BooleanType;
+        /** Total number of divergent transitions */
+        readonly n_divergences: IntegerType;
+        /** Per-parameter diagnostics */
+        readonly parameters: ArrayType<StructType<{
+            /** Parameter name */
+            readonly parameter: StringType;
+            /** Maximum R-hat across elements */
+            readonly rhat_max: FloatType;
+            /** Minimum ESS across elements */
+            readonly ess_min: FloatType;
+            /** Number of divergent transitions */
+            readonly n_divergent: IntegerType;
+        }>>;
+        /** Warning messages */
+        readonly warnings: ArrayType<StringType>;
+    }>;
+    /** Observed fit metrics */
+    readonly PyMCObservedFitType: StructType<{
+        /** Target column name or index */
+        readonly name: StringType;
+        /** Mean absolute error */
+        readonly mae: FloatType;
+        /** Pearson correlation */
+        readonly correlation: FloatType;
+        /** 95% credible interval coverage */
+        readonly coverage_95: FloatType;
+    }>;
+    /** Model blob type */
+    readonly ModelBlobType: VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>;
+};
+/**
+ * PyMC Bayesian inference.
+ *
+ * Provides Bayesian linear regression, hierarchical models, and multi-layer
+ * joint estimation with full posterior analysis.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { PyMC } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], PyMC.Types.ModelBlobType, $ => {
+ *     const X = $.let([[1.0], [2.0], [3.0], [4.0]]);
+ *     const Y = $.let([[2.0], [4.0], [6.0], [8.0]]);
+ *     const config = $.let({
+ *         prior: variant('none', null),
+ *         likelihood: variant('none', null),
+ *         include_intercept: variant('some', true),
+ *         samples: variant('some', 100n),
+ *         tune: variant('some', 50n),
+ *         chains: variant('some', 1n),
+ *         target_accept: variant('none', null),
+ *     });
+ *     return $.return(PyMC.trainRegression(X, Y, config));
+ * });
+ * ```
+ */
+export declare const PyMC: {
+    /**
+     * Train a Bayesian linear regression model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { PyMC, PyMCRegressionConfigType, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [MatrixType(FloatType), MatrixType(FloatType)],
+     *     PyMC.Types.ModelBlobType,
+     *     ($, X, Y) => {
+     *         const config = $.let({
+     *             prior: variant("none", null),
+     *             likelihood: variant("none", null),
+     *             include_intercept: variant("some", true),
+     *             samples: variant("some", 1000n),
+     *             tune: variant("some", 1000n),
+     *             chains: variant("some", 2n),
+     *             target_accept: variant("none", null),
+     *         }, PyMCRegressionConfigType);
+     *         return $.return(PyMC.trainRegression(X, Y, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly trainRegression: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, MatrixType<FloatType>, StructType<{
+        /** Prior specification for coefficients */
+        readonly prior: OptionType<StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+        /** Whether to include intercept term (default true) */
+        readonly include_intercept: OptionType<BooleanType>;
+        /** Number of posterior samples (default 1000) */
+        readonly samples: OptionType<IntegerType>;
+        /** Number of tuning steps (default 1000) */
+        readonly tune: OptionType<IntegerType>;
+        /** Number of MCMC chains (default 2) */
+        readonly chains: OptionType<IntegerType>;
+        /** Target acceptance rate (default 0.8) */
+        readonly target_accept: OptionType<FloatType>;
+    }>], VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>>;
+    /**
+     * Train a hierarchical Bayesian model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, IntegerType, variant } from "@elaraai/east";
+     * import { PyMC, PyMCHierarchicalConfigType, MatrixType, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [MatrixType(FloatType), MatrixType(FloatType), VectorType(IntegerType)],
+     *     PyMC.Types.ModelBlobType,
+     *     ($, X, Y, groups) => {
+     *         const config = $.let({
+     *             prior: variant("none", null),
+     *             likelihood: variant("none", null),
+     *             pooling: variant("some", variant("partial", null)),
+     *             samples: variant("some", 1000n),
+     *             tune: variant("some", 1000n),
+     *             chains: variant("some", 2n),
+     *             target_accept: variant("none", null),
+     *         }, PyMCHierarchicalConfigType);
+     *         return $.return(PyMC.trainHierarchical(X, Y, groups, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly trainHierarchical: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, MatrixType<FloatType>, VectorType<IntegerType>, StructType<{
+        /** Prior specification for coefficients */
+        readonly prior: OptionType<StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Likelihood function */
+        readonly likelihood: OptionType<VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>>;
+        /** Pooling type (default partial) */
+        readonly pooling: OptionType<VariantType<{
+            /** No pooling (independent per group) */
+            readonly none: NullType;
+            /** Partial pooling (shared hyperpriors) */
+            readonly partial: NullType;
+            /** Full pooling (all groups share same parameters) */
+            readonly full: NullType;
+        }>>;
+        /** Number of posterior samples (default 1000) */
+        readonly samples: OptionType<IntegerType>;
+        /** Number of tuning steps (default 1000) */
+        readonly tune: OptionType<IntegerType>;
+        /** Number of MCMC chains (default 2) */
+        readonly chains: OptionType<IntegerType>;
+        /** Target acceptance rate (default 0.8) */
+        readonly target_accept: OptionType<FloatType>;
+    }>], VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>>;
+    /**
+     * Train a multi-layer joint estimation model.
+     *
+     * @example
+     * ```ts
+     * import { East, ArrayType, variant } from "@elaraai/east";
+     * import { PyMC, PyMCMultiLayerConfigType, PyMCNamedDataType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [ArrayType(PyMCNamedDataType)],
+     *     PyMC.Types.ModelBlobType,
+     *     ($, data) => {
+     *         const config = $.let({
+     *             layers: [{
+     *                 name: "layer1",
+     *                 input: "X",
+     *                 output: "Y",
+     *                 parameter: "beta",
+     *                 likelihood: variant("none", null),
+     *             }],
+     *             priors: variant("none", null),
+     *             masks: variant("none", null),
+     *             samples: variant("some", 1000n),
+     *             tune: variant("some", 1000n),
+     *             chains: variant("some", 2n),
+     *             target_accept: variant("none", null),
+     *             force_full_mcmc: variant("none", null),
+     *             fallback_l1_alpha: variant("none", null),
+     *         }, PyMCMultiLayerConfigType);
+     *         return $.return(PyMC.trainMultiLayer(data, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly trainMultiLayer: import("@elaraai/east").PlatformDefinition<[ArrayType<StructType<{
+        /** Data name */
+        readonly name: StringType;
+        /** Data matrix */
+        readonly data: MatrixType<FloatType>;
+    }>>, StructType<{
+        /** Layer specifications */
+        readonly layers: ArrayType<StructType<{
+            /** Layer name */
+            readonly name: StringType;
+            /** Input data name */
+            readonly input: StringType;
+            /** Output data name */
+            readonly output: StringType;
+            /** Parameter name for coefficients */
+            readonly parameter: StringType;
+            /** Likelihood function */
+            readonly likelihood: OptionType<VariantType<{
+                /** Normal (Gaussian) likelihood */
+                readonly normal: NullType;
+                /** Student-t likelihood (robust to outliers) */
+                readonly studentt: NullType;
+                /** Poisson likelihood (count data) */
+                readonly poisson: NullType;
+            }>>;
+        }>>;
+        /** Named priors for parameters */
+        readonly priors: OptionType<ArrayType<StructType<{
+            /** Parameter name this prior applies to */
+            readonly name: StringType;
+            /** Prior specification */
+            readonly prior: StructType<{
+                /** Distribution type */
+                readonly distribution: VariantType<{
+                    /** Half-normal distribution (positive only) */
+                    readonly halfnormal: NullType;
+                    /** Log-normal distribution */
+                    readonly lognormal: NullType;
+                    /** Normal (Gaussian) distribution */
+                    readonly normal: NullType;
+                    /** Half-Cauchy distribution (heavy tails, positive only) */
+                    readonly halfcauchy: NullType;
+                    /** Exponential distribution */
+                    readonly exponential: NullType;
+                    /** Uniform distribution */
+                    readonly uniform: NullType;
+                    /** Horseshoe prior (sparsity-inducing) */
+                    readonly horseshoe: NullType;
+                }>;
+                /** Distribution parameters */
+                readonly params: StructType<{
+                    /** Mean (for normal/lognormal) */
+                    readonly mu: OptionType<MatrixType<FloatType>>;
+                    /** Standard deviation */
+                    readonly sigma: OptionType<MatrixType<FloatType>>;
+                    /** Precision (for exponential rate) */
+                    readonly tau: OptionType<FloatType>;
+                    /** Lower bound (for uniform) */
+                    readonly lower: OptionType<FloatType>;
+                    /** Upper bound (for uniform) */
+                    readonly upper: OptionType<FloatType>;
+                }>;
+            }>;
+        }>>>;
+        /** Named masks for parameter sparsity */
+        readonly masks: OptionType<ArrayType<StructType<{
+            /** Parameter name this mask applies to */
+            readonly name: StringType;
+            /** Boolean mask matrix (true = estimate, false = fix to zero) */
+            readonly mask: MatrixType<BooleanType>;
+        }>>>;
+        /** Number of posterior samples (default 1000) */
+        readonly samples: OptionType<IntegerType>;
+        /** Number of tuning steps (default 1000) */
+        readonly tune: OptionType<IntegerType>;
+        /** Number of MCMC chains (default 2) */
+        readonly chains: OptionType<IntegerType>;
+        /** Target acceptance rate (default 0.8) */
+        readonly target_accept: OptionType<FloatType>;
+        /** Force full MCMC even for large models (default false) */
+        readonly force_full_mcmc: OptionType<BooleanType>;
+        /** L1 regularization alpha for fallback (default 0.01) */
+        readonly fallback_l1_alpha: OptionType<FloatType>;
+    }>], VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>>;
+    /**
+     * Make point predictions (posterior mean).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { PyMC, PyMCPredictConfigType, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const predict = East.function(
+     *     [PyMC.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, X) => {
+     *         const config = $.let({
+     *             layer: variant("none", null),
+     *             n_samples: variant("some", 100n),
+     *         }, PyMCPredictConfigType);
+     *         return $.return(PyMC.predict(model, X, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>, MatrixType<FloatType>, StructType<{
+        /** Layer name to predict from (for multi-layer models) */
+        readonly layer: OptionType<StringType>;
+        /** Number of posterior samples to use for prediction (default 100) */
+        readonly n_samples: OptionType<IntegerType>;
+    }>], MatrixType<FloatType>>;
+    /**
+     * Make predictions returning full posterior distribution.
+     *
+     * Returns matrix where each row is a posterior sample prediction.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { PyMC, PyMCPredictConfigType, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const predictDist = East.function(
+     *     [PyMC.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, X) => {
+     *         const config = $.let({
+     *             layer: variant("none", null),
+     *             n_samples: variant("some", 200n),
+     *         }, PyMCPredictConfigType);
+     *         return $.return(PyMC.predictDistribution(model, X, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly predictDistribution: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>, MatrixType<FloatType>, StructType<{
+        /** Layer name to predict from (for multi-layer models) */
+        readonly layer: OptionType<StringType>;
+        /** Number of posterior samples to use for prediction (default 100) */
+        readonly n_samples: OptionType<IntegerType>;
+    }>], MatrixType<FloatType>>;
+    /**
+     * Get posterior parameter summaries.
+     *
+     * @example
+     * ```ts
+     * import { East, ArrayType } from "@elaraai/east";
+     * import { PyMC } from "@elaraai/east-py-datascience";
+     *
+     * const getSummary = East.function(
+     *     [PyMC.Types.ModelBlobType],
+     *     ArrayType(PyMC.Types.PyMCParameterSummaryType),
+     *     ($, model) => {
+     *         return $.return(PyMC.posteriorSummary(model));
+     *     }
+     * );
+     * ```
+     */
+    readonly posteriorSummary: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>], ArrayType<StructType<{
+        /** Parameter name */
+        readonly parameter: StringType;
+        /** Number of rows */
+        readonly shape_rows: IntegerType;
+        /** Number of columns */
+        readonly shape_cols: IntegerType;
+        /** Per-element estimates */
+        readonly estimates: ArrayType<StructType<{
+            /** Row index in parameter matrix */
+            readonly index_row: IntegerType;
+            /** Column index in parameter matrix */
+            readonly index_col: IntegerType;
+            /** Posterior mean */
+            readonly mean: FloatType;
+            /** Posterior median */
+            readonly median: FloatType;
+            /** Posterior standard deviation */
+            readonly sd: FloatType;
+            /** Lower 95% credible interval */
+            readonly ci_lower: FloatType;
+            /** Upper 95% credible interval */
+            readonly ci_upper: FloatType;
+            /** R-hat convergence diagnostic */
+            readonly rhat: FloatType;
+            /** Effective sample size */
+            readonly ess: FloatType;
+        }>>;
+    }>>>;
+    /**
+     * Extract raw posterior samples for a named parameter.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, IntegerType, StringType } from "@elaraai/east";
+     * import { PyMC, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const getSamples = East.function(
+     *     [PyMC.Types.ModelBlobType, StringType, IntegerType],
+     *     MatrixType(FloatType),
+     *     ($, model, paramName, nSamples) => {
+     *         return $.return(PyMC.posteriorSamples(model, paramName, nSamples));
+     *     }
+     * );
+     * ```
+     */
+    readonly posteriorSamples: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>, StringType, IntegerType], MatrixType<FloatType>>;
+    /**
+     * Run convergence diagnostics on a trained model.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { PyMC } from "@elaraai/east-py-datascience";
+     *
+     * const diagnose = East.function(
+     *     [PyMC.Types.ModelBlobType],
+     *     PyMC.Types.PyMCDiagnosticsResultType,
+     *     ($, model) => {
+     *         const result = $.let(PyMC.diagnostics(model));
+     *         // result.converged, result.n_divergences, result.warnings
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly diagnostics: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>], StructType<{
+        /** Whether all diagnostics indicate convergence */
+        readonly converged: BooleanType;
+        /** Total number of divergent transitions */
+        readonly n_divergences: IntegerType;
+        /** Per-parameter diagnostics */
+        readonly parameters: ArrayType<StructType<{
+            /** Parameter name */
+            readonly parameter: StringType;
+            /** Maximum R-hat across elements */
+            readonly rhat_max: FloatType;
+            /** Minimum ESS across elements */
+            readonly ess_min: FloatType;
+            /** Number of divergent transitions */
+            readonly n_divergent: IntegerType;
+        }>>;
+        /** Warning messages */
+        readonly warnings: ArrayType<StringType>;
+    }>>;
+    /**
+     * Posterior predictive check against observed data.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, ArrayType } from "@elaraai/east";
+     * import { PyMC, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const check = East.function(
+     *     [PyMC.Types.ModelBlobType, MatrixType(FloatType), MatrixType(FloatType)],
+     *     ArrayType(PyMC.Types.PyMCObservedFitType),
+     *     ($, model, X, Y_observed) => {
+     *         const result = $.let(PyMC.posteriorPredictiveCheck(model, X, Y_observed));
+     *         // Each element has: name, mae, correlation, coverage_95
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly posteriorPredictiveCheck: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Bayesian linear regression model */
+        readonly pymc_regression: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Whether intercept is included */
+            readonly include_intercept: BooleanType;
+        }>;
+        /** Hierarchical Bayesian model */
+        readonly pymc_hierarchical: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of target columns */
+            readonly n_targets: IntegerType;
+            /** Number of groups */
+            readonly n_groups: IntegerType;
+        }>;
+        /** Multi-layer joint estimation model */
+        readonly pymc_multi_layer: StructType<{
+            /** Cloudpickle serialized model data */
+            readonly data: BlobType;
+            /** Layer names */
+            readonly layer_names: ArrayType<StringType>;
+            /** Parameter names */
+            readonly parameter_names: ArrayType<StringType>;
+        }>;
+    }>, MatrixType<FloatType>, MatrixType<FloatType>], ArrayType<StructType<{
+        /** Target column name or index */
+        readonly name: StringType;
+        /** Mean absolute error */
+        readonly mae: FloatType;
+        /** Pearson correlation */
+        readonly correlation: FloatType;
+        /** 95% credible interval coverage */
+        readonly coverage_95: FloatType;
+    }>>>;
+    /** Type definitions */
+    readonly Types: {
+        /** Prior distribution type */
+        readonly PyMCPriorDistributionType: VariantType<{
+            /** Half-normal distribution (positive only) */
+            readonly halfnormal: NullType;
+            /** Log-normal distribution */
+            readonly lognormal: NullType;
+            /** Normal (Gaussian) distribution */
+            readonly normal: NullType;
+            /** Half-Cauchy distribution (heavy tails, positive only) */
+            readonly halfcauchy: NullType;
+            /** Exponential distribution */
+            readonly exponential: NullType;
+            /** Uniform distribution */
+            readonly uniform: NullType;
+            /** Horseshoe prior (sparsity-inducing) */
+            readonly horseshoe: NullType;
+        }>;
+        /** Likelihood type */
+        readonly PyMCLikelihoodType: VariantType<{
+            /** Normal (Gaussian) likelihood */
+            readonly normal: NullType;
+            /** Student-t likelihood (robust to outliers) */
+            readonly studentt: NullType;
+            /** Poisson likelihood (count data) */
+            readonly poisson: NullType;
+        }>;
+        /** Pooling type */
+        readonly PyMCPoolingType: VariantType<{
+            /** No pooling (independent per group) */
+            readonly none: NullType;
+            /** Partial pooling (shared hyperpriors) */
+            readonly partial: NullType;
+            /** Full pooling (all groups share same parameters) */
+            readonly full: NullType;
+        }>;
+        /** Prior parameters */
+        readonly PyMCPriorParamsType: StructType<{
+            /** Mean (for normal/lognormal) */
+            readonly mu: OptionType<MatrixType<FloatType>>;
+            /** Standard deviation */
+            readonly sigma: OptionType<MatrixType<FloatType>>;
+            /** Precision (for exponential rate) */
+            readonly tau: OptionType<FloatType>;
+            /** Lower bound (for uniform) */
+            readonly lower: OptionType<FloatType>;
+            /** Upper bound (for uniform) */
+            readonly upper: OptionType<FloatType>;
+        }>;
+        /** Prior specification */
+        readonly PyMCPriorSpecType: StructType<{
+            /** Distribution type */
+            readonly distribution: VariantType<{
+                /** Half-normal distribution (positive only) */
+                readonly halfnormal: NullType;
+                /** Log-normal distribution */
+                readonly lognormal: NullType;
+                /** Normal (Gaussian) distribution */
+                readonly normal: NullType;
+                /** Half-Cauchy distribution (heavy tails, positive only) */
+                readonly halfcauchy: NullType;
+                /** Exponential distribution */
+                readonly exponential: NullType;
+                /** Uniform distribution */
+                readonly uniform: NullType;
+                /** Horseshoe prior (sparsity-inducing) */
+                readonly horseshoe: NullType;
+            }>;
+            /** Distribution parameters */
+            readonly params: StructType<{
+                /** Mean (for normal/lognormal) */
+                readonly mu: OptionType<MatrixType<FloatType>>;
+                /** Standard deviation */
+                readonly sigma: OptionType<MatrixType<FloatType>>;
+                /** Precision (for exponential rate) */
+                readonly tau: OptionType<FloatType>;
+                /** Lower bound (for uniform) */
+                readonly lower: OptionType<FloatType>;
+                /** Upper bound (for uniform) */
+                readonly upper: OptionType<FloatType>;
+            }>;
+        }>;
+        /** Regression configuration */
+        readonly PyMCRegressionConfigType: StructType<{
+            /** Prior specification for coefficients */
+            readonly prior: OptionType<StructType<{
+                /** Distribution type */
+                readonly distribution: VariantType<{
+                    /** Half-normal distribution (positive only) */
+                    readonly halfnormal: NullType;
+                    /** Log-normal distribution */
+                    readonly lognormal: NullType;
+                    /** Normal (Gaussian) distribution */
+                    readonly normal: NullType;
+                    /** Half-Cauchy distribution (heavy tails, positive only) */
+                    readonly halfcauchy: NullType;
+                    /** Exponential distribution */
+                    readonly exponential: NullType;
+                    /** Uniform distribution */
+                    readonly uniform: NullType;
+                    /** Horseshoe prior (sparsity-inducing) */
+                    readonly horseshoe: NullType;
+                }>;
+                /** Distribution parameters */
+                readonly params: StructType<{
+                    /** Mean (for normal/lognormal) */
+                    readonly mu: OptionType<MatrixType<FloatType>>;
+                    /** Standard deviation */
+                    readonly sigma: OptionType<MatrixType<FloatType>>;
+                    /** Precision (for exponential rate) */
+                    readonly tau: OptionType<FloatType>;
+                    /** Lower bound (for uniform) */
+                    readonly lower: OptionType<FloatType>;
+                    /** Upper bound (for uniform) */
+                    readonly upper: OptionType<FloatType>;
+                }>;
+            }>>;
+            /** Likelihood function */
+            readonly likelihood: OptionType<VariantType<{
+                /** Normal (Gaussian) likelihood */
+                readonly normal: NullType;
+                /** Student-t likelihood (robust to outliers) */
+                readonly studentt: NullType;
+                /** Poisson likelihood (count data) */
+                readonly poisson: NullType;
+            }>>;
+            /** Whether to include intercept term (default true) */
+            readonly include_intercept: OptionType<BooleanType>;
+            /** Number of posterior samples (default 1000) */
+            readonly samples: OptionType<IntegerType>;
+            /** Number of tuning steps (default 1000) */
+            readonly tune: OptionType<IntegerType>;
+            /** Number of MCMC chains (default 2) */
+            readonly chains: OptionType<IntegerType>;
+            /** Target acceptance rate (default 0.8) */
+            readonly target_accept: OptionType<FloatType>;
+        }>;
+        /** Hierarchical configuration */
+        readonly PyMCHierarchicalConfigType: StructType<{
+            /** Prior specification for coefficients */
+            readonly prior: OptionType<StructType<{
+                /** Distribution type */
+                readonly distribution: VariantType<{
+                    /** Half-normal distribution (positive only) */
+                    readonly halfnormal: NullType;
+                    /** Log-normal distribution */
+                    readonly lognormal: NullType;
+                    /** Normal (Gaussian) distribution */
+                    readonly normal: NullType;
+                    /** Half-Cauchy distribution (heavy tails, positive only) */
+                    readonly halfcauchy: NullType;
+                    /** Exponential distribution */
+                    readonly exponential: NullType;
+                    /** Uniform distribution */
+                    readonly uniform: NullType;
+                    /** Horseshoe prior (sparsity-inducing) */
+                    readonly horseshoe: NullType;
+                }>;
+                /** Distribution parameters */
+                readonly params: StructType<{
+                    /** Mean (for normal/lognormal) */
+                    readonly mu: OptionType<MatrixType<FloatType>>;
+                    /** Standard deviation */
+                    readonly sigma: OptionType<MatrixType<FloatType>>;
+                    /** Precision (for exponential rate) */
+                    readonly tau: OptionType<FloatType>;
+                    /** Lower bound (for uniform) */
+                    readonly lower: OptionType<FloatType>;
+                    /** Upper bound (for uniform) */
+                    readonly upper: OptionType<FloatType>;
+                }>;
+            }>>;
+            /** Likelihood function */
+            readonly likelihood: OptionType<VariantType<{
+                /** Normal (Gaussian) likelihood */
+                readonly normal: NullType;
+                /** Student-t likelihood (robust to outliers) */
+                readonly studentt: NullType;
+                /** Poisson likelihood (count data) */
+                readonly poisson: NullType;
+            }>>;
+            /** Pooling type (default partial) */
+            readonly pooling: OptionType<VariantType<{
+                /** No pooling (independent per group) */
+                readonly none: NullType;
+                /** Partial pooling (shared hyperpriors) */
+                readonly partial: NullType;
+                /** Full pooling (all groups share same parameters) */
+                readonly full: NullType;
+            }>>;
+            /** Number of posterior samples (default 1000) */
+            readonly samples: OptionType<IntegerType>;
+            /** Number of tuning steps (default 1000) */
+            readonly tune: OptionType<IntegerType>;
+            /** Number of MCMC chains (default 2) */
+            readonly chains: OptionType<IntegerType>;
+            /** Target acceptance rate (default 0.8) */
+            readonly target_accept: OptionType<FloatType>;
+        }>;
+        /** Layer specification */
+        readonly PyMCLayerSpecType: StructType<{
+            /** Layer name */
+            readonly name: StringType;
+            /** Input data name */
+            readonly input: StringType;
+            /** Output data name */
+            readonly output: StringType;
+            /** Parameter name for coefficients */
+            readonly parameter: StringType;
+            /** Likelihood function */
+            readonly likelihood: OptionType<VariantType<{
+                /** Normal (Gaussian) likelihood */
+                readonly normal: NullType;
+                /** Student-t likelihood (robust to outliers) */
+                readonly studentt: NullType;
+                /** Poisson likelihood (count data) */
+                readonly poisson: NullType;
+            }>>;
+        }>;
+        /** Named prior */
+        readonly PyMCNamedPriorType: StructType<{
+            /** Parameter name this prior applies to */
+            readonly name: StringType;
+            /** Prior specification */
+            readonly prior: StructType<{
+                /** Distribution type */
+                readonly distribution: VariantType<{
+                    /** Half-normal distribution (positive only) */
+                    readonly halfnormal: NullType;
+                    /** Log-normal distribution */
+                    readonly lognormal: NullType;
+                    /** Normal (Gaussian) distribution */
+                    readonly normal: NullType;
+                    /** Half-Cauchy distribution (heavy tails, positive only) */
+                    readonly halfcauchy: NullType;
+                    /** Exponential distribution */
+                    readonly exponential: NullType;
+                    /** Uniform distribution */
+                    readonly uniform: NullType;
+                    /** Horseshoe prior (sparsity-inducing) */
+                    readonly horseshoe: NullType;
+                }>;
+                /** Distribution parameters */
+                readonly params: StructType<{
+                    /** Mean (for normal/lognormal) */
+                    readonly mu: OptionType<MatrixType<FloatType>>;
+                    /** Standard deviation */
+                    readonly sigma: OptionType<MatrixType<FloatType>>;
+                    /** Precision (for exponential rate) */
+                    readonly tau: OptionType<FloatType>;
+                    /** Lower bound (for uniform) */
+                    readonly lower: OptionType<FloatType>;
+                    /** Upper bound (for uniform) */
+                    readonly upper: OptionType<FloatType>;
+                }>;
+            }>;
+        }>;
+        /** Named mask */
+        readonly PyMCNamedMaskType: StructType<{
+            /** Parameter name this mask applies to */
+            readonly name: StringType;
+            /** Boolean mask matrix (true = estimate, false = fix to zero) */
+            readonly mask: MatrixType<BooleanType>;
+        }>;
+        /** Multi-layer configuration */
+        readonly PyMCMultiLayerConfigType: StructType<{
+            /** Layer specifications */
+            readonly layers: ArrayType<StructType<{
+                /** Layer name */
+                readonly name: StringType;
+                /** Input data name */
+                readonly input: StringType;
+                /** Output data name */
+                readonly output: StringType;
+                /** Parameter name for coefficients */
+                readonly parameter: StringType;
+                /** Likelihood function */
+                readonly likelihood: OptionType<VariantType<{
+                    /** Normal (Gaussian) likelihood */
+                    readonly normal: NullType;
+                    /** Student-t likelihood (robust to outliers) */
+                    readonly studentt: NullType;
+                    /** Poisson likelihood (count data) */
+                    readonly poisson: NullType;
+                }>>;
+            }>>;
+            /** Named priors for parameters */
+            readonly priors: OptionType<ArrayType<StructType<{
+                /** Parameter name this prior applies to */
+                readonly name: StringType;
+                /** Prior specification */
+                readonly prior: StructType<{
+                    /** Distribution type */
+                    readonly distribution: VariantType<{
+                        /** Half-normal distribution (positive only) */
+                        readonly halfnormal: NullType;
+                        /** Log-normal distribution */
+                        readonly lognormal: NullType;
+                        /** Normal (Gaussian) distribution */
+                        readonly normal: NullType;
+                        /** Half-Cauchy distribution (heavy tails, positive only) */
+                        readonly halfcauchy: NullType;
+                        /** Exponential distribution */
+                        readonly exponential: NullType;
+                        /** Uniform distribution */
+                        readonly uniform: NullType;
+                        /** Horseshoe prior (sparsity-inducing) */
+                        readonly horseshoe: NullType;
+                    }>;
+                    /** Distribution parameters */
+                    readonly params: StructType<{
+                        /** Mean (for normal/lognormal) */
+                        readonly mu: OptionType<MatrixType<FloatType>>;
+                        /** Standard deviation */
+                        readonly sigma: OptionType<MatrixType<FloatType>>;
+                        /** Precision (for exponential rate) */
+                        readonly tau: OptionType<FloatType>;
+                        /** Lower bound (for uniform) */
+                        readonly lower: OptionType<FloatType>;
+                        /** Upper bound (for uniform) */
+                        readonly upper: OptionType<FloatType>;
+                    }>;
+                }>;
+            }>>>;
+            /** Named masks for parameter sparsity */
+            readonly masks: OptionType<ArrayType<StructType<{
+                /** Parameter name this mask applies to */
+                readonly name: StringType;
+                /** Boolean mask matrix (true = estimate, false = fix to zero) */
+                readonly mask: MatrixType<BooleanType>;
+            }>>>;
+            /** Number of posterior samples (default 1000) */
+            readonly samples: OptionType<IntegerType>;
+            /** Number of tuning steps (default 1000) */
+            readonly tune: OptionType<IntegerType>;
+            /** Number of MCMC chains (default 2) */
+            readonly chains: OptionType<IntegerType>;
+            /** Target acceptance rate (default 0.8) */
+            readonly target_accept: OptionType<FloatType>;
+            /** Force full MCMC even for large models (default false) */
+            readonly force_full_mcmc: OptionType<BooleanType>;
+            /** L1 regularization alpha for fallback (default 0.01) */
+            readonly fallback_l1_alpha: OptionType<FloatType>;
+        }>;
+        /** Named data */
+        readonly PyMCNamedDataType: StructType<{
+            /** Data name */
+            readonly name: StringType;
+            /** Data matrix */
+            readonly data: MatrixType<FloatType>;
+        }>;
+        /** Prediction configuration */
+        readonly PyMCPredictConfigType: StructType<{
+            /** Layer name to predict from (for multi-layer models) */
+            readonly layer: OptionType<StringType>;
+            /** Number of posterior samples to use for prediction (default 100) */
+            readonly n_samples: OptionType<IntegerType>;
+        }>;
+        /** Parameter estimate */
+        readonly PyMCParameterEstimateType: StructType<{
+            /** Row index in parameter matrix */
+            readonly index_row: IntegerType;
+            /** Column index in parameter matrix */
+            readonly index_col: IntegerType;
+            /** Posterior mean */
+            readonly mean: FloatType;
+            /** Posterior median */
+            readonly median: FloatType;
+            /** Posterior standard deviation */
+            readonly sd: FloatType;
+            /** Lower 95% credible interval */
+            readonly ci_lower: FloatType;
+            /** Upper 95% credible interval */
+            readonly ci_upper: FloatType;
+            /** R-hat convergence diagnostic */
+            readonly rhat: FloatType;
+            /** Effective sample size */
+            readonly ess: FloatType;
+        }>;
+        /** Parameter summary */
+        readonly PyMCParameterSummaryType: StructType<{
+            /** Parameter name */
+            readonly parameter: StringType;
+            /** Number of rows */
+            readonly shape_rows: IntegerType;
+            /** Number of columns */
+            readonly shape_cols: IntegerType;
+            /** Per-element estimates */
+            readonly estimates: ArrayType<StructType<{
+                /** Row index in parameter matrix */
+                readonly index_row: IntegerType;
+                /** Column index in parameter matrix */
+                readonly index_col: IntegerType;
+                /** Posterior mean */
+                readonly mean: FloatType;
+                /** Posterior median */
+                readonly median: FloatType;
+                /** Posterior standard deviation */
+                readonly sd: FloatType;
+                /** Lower 95% credible interval */
+                readonly ci_lower: FloatType;
+                /** Upper 95% credible interval */
+                readonly ci_upper: FloatType;
+                /** R-hat convergence diagnostic */
+                readonly rhat: FloatType;
+                /** Effective sample size */
+                readonly ess: FloatType;
+            }>>;
+        }>;
+        /** Parameter diagnostics */
+        readonly PyMCParameterDiagType: StructType<{
+            /** Parameter name */
+            readonly parameter: StringType;
+            /** Maximum R-hat across elements */
+            readonly rhat_max: FloatType;
+            /** Minimum ESS across elements */
+            readonly ess_min: FloatType;
+            /** Number of divergent transitions */
+            readonly n_divergent: IntegerType;
+        }>;
+        /** Diagnostics result */
+        readonly PyMCDiagnosticsResultType: StructType<{
+            /** Whether all diagnostics indicate convergence */
+            readonly converged: BooleanType;
+            /** Total number of divergent transitions */
+            readonly n_divergences: IntegerType;
+            /** Per-parameter diagnostics */
+            readonly parameters: ArrayType<StructType<{
+                /** Parameter name */
+                readonly parameter: StringType;
+                /** Maximum R-hat across elements */
+                readonly rhat_max: FloatType;
+                /** Minimum ESS across elements */
+                readonly ess_min: FloatType;
+                /** Number of divergent transitions */
+                readonly n_divergent: IntegerType;
+            }>>;
+            /** Warning messages */
+            readonly warnings: ArrayType<StringType>;
+        }>;
+        /** Observed fit metrics */
+        readonly PyMCObservedFitType: StructType<{
+            /** Target column name or index */
+            readonly name: StringType;
+            /** Mean absolute error */
+            readonly mae: FloatType;
+            /** Pearson correlation */
+            readonly correlation: FloatType;
+            /** 95% credible interval coverage */
+            readonly coverage_95: FloatType;
+        }>;
+        /** Model blob type */
+        readonly ModelBlobType: VariantType<{
+            /** Bayesian linear regression model */
+            readonly pymc_regression: StructType<{
+                /** Cloudpickle serialized model data */
+                readonly data: BlobType;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Number of target columns */
+                readonly n_targets: IntegerType;
+                /** Whether intercept is included */
+                readonly include_intercept: BooleanType;
+            }>;
+            /** Hierarchical Bayesian model */
+            readonly pymc_hierarchical: StructType<{
+                /** Cloudpickle serialized model data */
+                readonly data: BlobType;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Number of target columns */
+                readonly n_targets: IntegerType;
+                /** Number of groups */
+                readonly n_groups: IntegerType;
+            }>;
+            /** Multi-layer joint estimation model */
+            readonly pymc_multi_layer: StructType<{
+                /** Cloudpickle serialized model data */
+                readonly data: BlobType;
+                /** Layer names */
+                readonly layer_names: ArrayType<StringType>;
+                /** Parameter names */
+                readonly parameter_names: ArrayType<StringType>;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=pymc.d.ts.map