@elaraai/east-py-datascience 1.0.3 → 1.0.5

package/dist/src/causal/causal.d.ts

@@ -0,0 +1,1872 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Causal inference for East.
+ *
+ * Provides causal effect estimation (DoWhy backdoor adjustment),
+ * refutation tests, heterogeneous treatment effects (EconML LinearDML),
+ * and accumulated local effects dose-response curves (PyALE).
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, BooleanType, StringType, BlobType, NullType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+export { VectorType, MatrixType } from "../types.js";
+/**
+ * Inverse propensity weighting scheme for the propensity score
+ * weighting estimator.
+ */
+export declare const CausalWeightingSchemeType: VariantType<{
+    /** Raw inverse propensity weights */
+    readonly ips_weight: NullType;
+    /** Stabilized inverse propensity weights (recommended; lower variance) */
+    readonly ips_stabilized_weight: NullType;
+    /** Normalized inverse propensity weights */
+    readonly ips_normalized_weight: NullType;
+}>;
+/**
+ * Backdoor-adjusted effect estimator.
+ */
+export declare const CausalEstimatorType: VariantType<{
+    /** Linear regression of outcome on treatment + common causes */
+    readonly linear_regression: NullType;
+    /** Inverse propensity score weighting (binary treatment only) */
+    readonly propensity_score_weighting: StructType<{
+        /** Weighting scheme (default: ips_stabilized_weight) */
+        readonly weighting_scheme: OptionType<VariantType<{
+            /** Raw inverse propensity weights */
+            readonly ips_weight: NullType;
+            /** Stabilized inverse propensity weights (recommended; lower variance) */
+            readonly ips_stabilized_weight: NullType;
+            /** Normalized inverse propensity weights */
+            readonly ips_normalized_weight: NullType;
+        }>>;
+    }>;
+}>;
+/**
+ * Population the effect is estimated for.
+ */
+export declare const CausalTargetUnitsType: VariantType<{
+    /** Average treatment effect over all units */
+    readonly ate: NullType;
+    /** Average treatment effect on the treated */
+    readonly att: NullType;
+    /** Average treatment effect on the controls */
+    readonly atc: NullType;
+}>;
+/**
+ * Propensity-based sample trimming applied before estimation
+ * (propensity score weighting only).
+ */
+export declare const PropensityTrimType: VariantType<{
+    /** Keep units inside the common-support overlap of treated and control propensities */
+    readonly overlap: NullType;
+    /** Keep units with propensity inside explicit bounds */
+    readonly bounds: StructType<{
+        /** Minimum propensity score to keep */
+        readonly lower: FloatType;
+        /** Maximum propensity score to keep */
+        readonly upper: FloatType;
+    }>;
+}>;
+/**
+ * Bootstrap confidence interval configuration.
+ *
+ * When `cluster_column` is set, whole clusters are resampled with
+ * replacement (the cluster is the exchangeable unit) — use this when rows
+ * are autocorrelated within a group (e.g. days within a batch).
+ */
+export declare const CausalBootstrapConfigType: StructType<{
+    /** Number of bootstrap replicates */
+    readonly reps: IntegerType;
+    /** Column whose values identify clusters to resample (default: resample rows) */
+    readonly cluster_column: OptionType<StringType>;
+    /** Confidence level for the percentile interval (default 0.95) */
+    readonly confidence_level: OptionType<FloatType>;
+}>;
+/**
+ * Configuration for backdoor-adjusted causal effect estimation.
+ *
+ * The data matrix is interpreted via `columns`: every column referenced by
+ * `treatment`, `outcome`, `common_causes`, `categorical` and
+ * `bootstrap.cluster_column` must appear in `columns`. Categorical columns
+ * hold integer-valued category codes and are one-hot encoded internally.
+ */
+export declare const CausalEffectConfigType: StructType<{
+    /** Column names for the data matrix (one per column, in order) */
+    readonly columns: ArrayType<StringType>;
+    /** Treatment column (must be 0/1 for propensity score weighting) */
+    readonly treatment: StringType;
+    /** Outcome column */
+    readonly outcome: StringType;
+    /** Confounder columns to adjust for (the backdoor set) */
+    readonly common_causes: ArrayType<StringType>;
+    /** Columns holding integer category codes, one-hot encoded internally */
+    readonly categorical: OptionType<ArrayType<StringType>>;
+    /** Effect estimator (default: linear_regression) */
+    readonly method: OptionType<VariantType<{
+        /** Linear regression of outcome on treatment + common causes */
+        readonly linear_regression: NullType;
+        /** Inverse propensity score weighting (binary treatment only) */
+        readonly propensity_score_weighting: StructType<{
+            /** Weighting scheme (default: ips_stabilized_weight) */
+            readonly weighting_scheme: OptionType<VariantType<{
+                /** Raw inverse propensity weights */
+                readonly ips_weight: NullType;
+                /** Stabilized inverse propensity weights (recommended; lower variance) */
+                readonly ips_stabilized_weight: NullType;
+                /** Normalized inverse propensity weights */
+                readonly ips_normalized_weight: NullType;
+            }>>;
+        }>;
+    }>>;
+    /** Target population (default: ate) */
+    readonly target_units: OptionType<VariantType<{
+        /** Average treatment effect over all units */
+        readonly ate: NullType;
+        /** Average treatment effect on the treated */
+        readonly att: NullType;
+        /** Average treatment effect on the controls */
+        readonly atc: NullType;
+    }>>;
+    /** Propensity trimming applied before estimation (psw only) */
+    readonly trim: OptionType<VariantType<{
+        /** Keep units inside the common-support overlap of treated and control propensities */
+        readonly overlap: NullType;
+        /** Keep units with propensity inside explicit bounds */
+        readonly bounds: StructType<{
+            /** Minimum propensity score to keep */
+            readonly lower: FloatType;
+            /** Maximum propensity score to keep */
+            readonly upper: FloatType;
+        }>;
+    }>>;
+    /** Bootstrap confidence interval (omit to skip CI computation) */
+    readonly bootstrap: OptionType<StructType<{
+        /** Number of bootstrap replicates */
+        readonly reps: IntegerType;
+        /** Column whose values identify clusters to resample (default: resample rows) */
+        readonly cluster_column: OptionType<StringType>;
+        /** Confidence level for the percentile interval (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+    }>>;
+    /** Random seed for propensity fitting and bootstrap resampling */
+    readonly random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Refutation test for an estimated causal effect.
+ */
+export declare const CausalRefuterType: VariantType<{
+    /** Replace treatment with a permuted placebo - effect should vanish */
+    readonly placebo_treatment: StructType<{
+        /** Number of simulations (default 100) */
+        readonly num_simulations: OptionType<IntegerType>;
+    }>;
+    /** Add an independent random common cause - effect should be unchanged */
+    readonly random_common_cause: StructType<{
+        /** Number of simulations (default 100) */
+        readonly num_simulations: OptionType<IntegerType>;
+    }>;
+    /** Re-estimate on random data subsets - effect should be stable */
+    readonly data_subset: StructType<{
+        /** Fraction of rows kept per simulation (default 0.8) */
+        readonly subset_fraction: OptionType<FloatType>;
+        /** Number of simulations (default 100) */
+        readonly num_simulations: OptionType<IntegerType>;
+    }>;
+    /**
+     * Simulate an unobserved confounder at each given strength - a
+     * sensitivity/tipping curve. Strength acts on both treatment
+     * (flip probability for binary treatment, linear coefficient otherwise)
+     * and outcome (linear coefficient).
+     */
+    readonly unobserved_common_cause: StructType<{
+        /** Confounder effect strengths to simulate, one new effect per entry */
+        readonly effect_strengths: ArrayType<FloatType>;
+    }>;
+}>;
+/**
+ * Nuisance model for DML residualization stages.
+ */
+export declare const CausalNuisanceModelType: VariantType<{
+    /** Random forest (regressor, or classifier for a discrete treatment) */
+    readonly random_forest: StructType<{
+        /** Number of trees (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Minimum samples per leaf (default 5) */
+        readonly min_samples_leaf: OptionType<IntegerType>;
+        /** Maximum tree depth (default unlimited) */
+        readonly max_depth: OptionType<IntegerType>;
+    }>;
+    /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+    readonly gradient_boosting: StructType<{
+        /** Number of boosting stages (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Learning rate (default 0.1) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Maximum tree depth (default 3) */
+        readonly max_depth: OptionType<IntegerType>;
+    }>;
+    /** Linear/logistic regression */
+    readonly linear: NullType;
+}>;
+/**
+ * Configuration for double machine learning (EconML LinearDML).
+ */
+export declare const CausalDMLConfigType: StructType<{
+    /** Nuisance model for the outcome stage (default: random_forest) */
+    readonly model_y: OptionType<VariantType<{
+        /** Random forest (regressor, or classifier for a discrete treatment) */
+        readonly random_forest: StructType<{
+            /** Number of trees (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 5) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+        readonly gradient_boosting: StructType<{
+            /** Number of boosting stages (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.1) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default 3) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Linear/logistic regression */
+        readonly linear: NullType;
+    }>>;
+    /** Nuisance model for the treatment stage (default: random_forest) */
+    readonly model_t: OptionType<VariantType<{
+        /** Random forest (regressor, or classifier for a discrete treatment) */
+        readonly random_forest: StructType<{
+            /** Number of trees (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 5) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+        readonly gradient_boosting: StructType<{
+            /** Number of boosting stages (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.1) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default 3) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Linear/logistic regression */
+        readonly linear: NullType;
+    }>>;
+    /** Treat the treatment as discrete/categorical (default false) */
+    readonly discrete_treatment: OptionType<BooleanType>;
+    /** Cross-fitting folds (default 2) */
+    readonly cv_folds: OptionType<IntegerType>;
+    /** Confidence level for effect/ATE intervals (default 0.95) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Random seed */
+    readonly random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Configuration for an accumulated local effects (ALE) dose-response curve.
+ *
+ * Fits a gradient-boosting emulator of the outcome on all non-outcome
+ * columns, then computes the correlation-robust ALE curve of `feature`.
+ */
+export declare const CausalALEConfigType: StructType<{
+    /** Column names for the data matrix (one per column, in order) */
+    readonly columns: ArrayType<StringType>;
+    /** Outcome column the emulator predicts */
+    readonly outcome: StringType;
+    /** Continuous feature column to compute the ALE curve for */
+    readonly feature: StringType;
+    /** Columns holding integer category codes, one-hot encoded internally */
+    readonly categorical: OptionType<ArrayType<StringType>>;
+    /** Number of grid intervals (default 10) */
+    readonly grid_size: OptionType<IntegerType>;
+    /** Include confidence intervals (default true) */
+    readonly include_ci: OptionType<BooleanType>;
+    /** Confidence level for the CI (default 0.95) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Emulator (HistGradientBoosting) hyperparameters */
+    readonly emulator: OptionType<StructType<{
+        /** Number of boosting iterations (default 300) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Learning rate (default 0.05) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Maximum tree depth (default unlimited) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Minimum samples per leaf (default 20; lower for small datasets) */
+        readonly min_samples_leaf: OptionType<IntegerType>;
+    }>>;
+    /** Random seed for the emulator */
+    readonly random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Model blob for a fitted LinearDML estimator.
+ */
+export declare const CausalDMLModelBlobType: VariantType<{
+    /** Fitted EconML LinearDML estimator */
+    readonly causal_dml: StructType<{
+        /** Serialized estimator (cloudpickle) */
+        readonly data: BlobType;
+        /** Number of effect-modifier (X) features */
+        readonly n_features_x: IntegerType;
+        /** Confidence level used for effect/ATE intervals */
+        readonly confidence_level: FloatType;
+    }>;
+}>;
+/**
+ * Estimated causal effect.
+ */
+export declare const CausalEffectResultType: StructType<{
+    /** Point estimate of the effect (outcome units per treatment unit) */
+    readonly effect: FloatType;
+    /** Bootstrap percentile confidence interval (present when bootstrap configured) */
+    readonly ci: OptionType<StructType<{
+        /** Lower bound */
+        readonly lower: FloatType;
+        /** Upper bound */
+        readonly upper: FloatType;
+    }>>;
+    /** Rows used for estimation (after trimming) */
+    readonly n_samples: IntegerType;
+    /** Treated rows used */
+    readonly n_treated: IntegerType;
+    /** Control rows used */
+    readonly n_control: IntegerType;
+}>;
+/**
+ * Refutation test result.
+ */
+export declare const CausalRefuteResultType: StructType<{
+    /** The original estimated effect being refuted */
+    readonly estimated_effect: FloatType;
+    /**
+     * Effect under the refutation. One entry for placebo/random-common-cause/
+     * data-subset; one entry per strength for unobserved_common_cause.
+     */
+    readonly new_effects: VectorType<FloatType>;
+    /** Refutation p-value where the refuter provides one */
+    readonly p_value: OptionType<FloatType>;
+}>;
+/**
+ * Average treatment effect with confidence interval.
+ */
+export declare const CausalATEResultType: StructType<{
+    /** Average treatment effect over the given X */
+    readonly ate: FloatType;
+    /** Lower bound at the model's confidence level */
+    readonly lower: FloatType;
+    /** Upper bound at the model's confidence level */
+    readonly upper: FloatType;
+}>;
+/**
+ * Accumulated local effects curve.
+ */
+export declare const ALEResultType: StructType<{
+    /** Feature grid values (interval edges) */
+    readonly grid: VectorType<FloatType>;
+    /** Centered ALE effect at each grid value (outcome units) */
+    readonly effect: VectorType<FloatType>;
+    /** Lower CI at each grid value (present when include_ci) */
+    readonly lower: OptionType<VectorType<FloatType>>;
+    /** Upper CI at each grid value (present when include_ci) */
+    readonly upper: OptionType<VectorType<FloatType>>;
+    /** Number of samples in each grid interval */
+    readonly size: VectorType<IntegerType>;
+}>;
+/**
+ * Estimate a backdoor-adjusted causal effect of treatment on outcome.
+ *
+ * Identifies the effect with DoWhy given the common causes, then estimates
+ * it by linear regression or inverse propensity score weighting. Optionally
+ * trims to propensity common support and computes a (cluster) bootstrap
+ * confidence interval.
+ *
+ * @param data - Data matrix (rows = units, columns named by config.columns)
+ * @param config - Estimation configuration
+ * @returns Effect estimate with optional CI and sample counts
+ */
+export declare const causal_effect: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, StructType<{
+    /** Column names for the data matrix (one per column, in order) */
+    readonly columns: ArrayType<StringType>;
+    /** Treatment column (must be 0/1 for propensity score weighting) */
+    readonly treatment: StringType;
+    /** Outcome column */
+    readonly outcome: StringType;
+    /** Confounder columns to adjust for (the backdoor set) */
+    readonly common_causes: ArrayType<StringType>;
+    /** Columns holding integer category codes, one-hot encoded internally */
+    readonly categorical: OptionType<ArrayType<StringType>>;
+    /** Effect estimator (default: linear_regression) */
+    readonly method: OptionType<VariantType<{
+        /** Linear regression of outcome on treatment + common causes */
+        readonly linear_regression: NullType;
+        /** Inverse propensity score weighting (binary treatment only) */
+        readonly propensity_score_weighting: StructType<{
+            /** Weighting scheme (default: ips_stabilized_weight) */
+            readonly weighting_scheme: OptionType<VariantType<{
+                /** Raw inverse propensity weights */
+                readonly ips_weight: NullType;
+                /** Stabilized inverse propensity weights (recommended; lower variance) */
+                readonly ips_stabilized_weight: NullType;
+                /** Normalized inverse propensity weights */
+                readonly ips_normalized_weight: NullType;
+            }>>;
+        }>;
+    }>>;
+    /** Target population (default: ate) */
+    readonly target_units: OptionType<VariantType<{
+        /** Average treatment effect over all units */
+        readonly ate: NullType;
+        /** Average treatment effect on the treated */
+        readonly att: NullType;
+        /** Average treatment effect on the controls */
+        readonly atc: NullType;
+    }>>;
+    /** Propensity trimming applied before estimation (psw only) */
+    readonly trim: OptionType<VariantType<{
+        /** Keep units inside the common-support overlap of treated and control propensities */
+        readonly overlap: NullType;
+        /** Keep units with propensity inside explicit bounds */
+        readonly bounds: StructType<{
+            /** Minimum propensity score to keep */
+            readonly lower: FloatType;
+            /** Maximum propensity score to keep */
+            readonly upper: FloatType;
+        }>;
+    }>>;
+    /** Bootstrap confidence interval (omit to skip CI computation) */
+    readonly bootstrap: OptionType<StructType<{
+        /** Number of bootstrap replicates */
+        readonly reps: IntegerType;
+        /** Column whose values identify clusters to resample (default: resample rows) */
+        readonly cluster_column: OptionType<StringType>;
+        /** Confidence level for the percentile interval (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+    }>>;
+    /** Random seed for propensity fitting and bootstrap resampling */
+    readonly random_state: OptionType<IntegerType>;
+}>], StructType<{
+    /** Point estimate of the effect (outcome units per treatment unit) */
+    readonly effect: FloatType;
+    /** Bootstrap percentile confidence interval (present when bootstrap configured) */
+    readonly ci: OptionType<StructType<{
+        /** Lower bound */
+        readonly lower: FloatType;
+        /** Upper bound */
+        readonly upper: FloatType;
+    }>>;
+    /** Rows used for estimation (after trimming) */
+    readonly n_samples: IntegerType;
+    /** Treated rows used */
+    readonly n_treated: IntegerType;
+    /** Control rows used */
+    readonly n_control: IntegerType;
+}>>;
+/**
+ * Refute an estimated causal effect.
+ *
+ * Re-estimates the effect from `config`, then applies the given refuter
+ * (placebo treatment, random common cause, data subset, or simulated
+ * unobserved confounder sensitivity curve).
+ *
+ * @param data - Data matrix (rows = units, columns named by config.columns)
+ * @param config - Estimation configuration (same as causal_effect)
+ * @param refuter - Refutation test to apply
+ * @returns Original effect, refuted effect(s), and p-value where available
+ */
+export declare const causal_refute: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, StructType<{
+    /** Column names for the data matrix (one per column, in order) */
+    readonly columns: ArrayType<StringType>;
+    /** Treatment column (must be 0/1 for propensity score weighting) */
+    readonly treatment: StringType;
+    /** Outcome column */
+    readonly outcome: StringType;
+    /** Confounder columns to adjust for (the backdoor set) */
+    readonly common_causes: ArrayType<StringType>;
+    /** Columns holding integer category codes, one-hot encoded internally */
+    readonly categorical: OptionType<ArrayType<StringType>>;
+    /** Effect estimator (default: linear_regression) */
+    readonly method: OptionType<VariantType<{
+        /** Linear regression of outcome on treatment + common causes */
+        readonly linear_regression: NullType;
+        /** Inverse propensity score weighting (binary treatment only) */
+        readonly propensity_score_weighting: StructType<{
+            /** Weighting scheme (default: ips_stabilized_weight) */
+            readonly weighting_scheme: OptionType<VariantType<{
+                /** Raw inverse propensity weights */
+                readonly ips_weight: NullType;
+                /** Stabilized inverse propensity weights (recommended; lower variance) */
+                readonly ips_stabilized_weight: NullType;
+                /** Normalized inverse propensity weights */
+                readonly ips_normalized_weight: NullType;
+            }>>;
+        }>;
+    }>>;
+    /** Target population (default: ate) */
+    readonly target_units: OptionType<VariantType<{
+        /** Average treatment effect over all units */
+        readonly ate: NullType;
+        /** Average treatment effect on the treated */
+        readonly att: NullType;
+        /** Average treatment effect on the controls */
+        readonly atc: NullType;
+    }>>;
+    /** Propensity trimming applied before estimation (psw only) */
+    readonly trim: OptionType<VariantType<{
+        /** Keep units inside the common-support overlap of treated and control propensities */
+        readonly overlap: NullType;
+        /** Keep units with propensity inside explicit bounds */
+        readonly bounds: StructType<{
+            /** Minimum propensity score to keep */
+            readonly lower: FloatType;
+            /** Maximum propensity score to keep */
+            readonly upper: FloatType;
+        }>;
+    }>>;
+    /** Bootstrap confidence interval (omit to skip CI computation) */
+    readonly bootstrap: OptionType<StructType<{
+        /** Number of bootstrap replicates */
+        readonly reps: IntegerType;
+        /** Column whose values identify clusters to resample (default: resample rows) */
+        readonly cluster_column: OptionType<StringType>;
+        /** Confidence level for the percentile interval (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+    }>>;
+    /** Random seed for propensity fitting and bootstrap resampling */
+    readonly random_state: OptionType<IntegerType>;
+}>, VariantType<{
+    /** Replace treatment with a permuted placebo - effect should vanish */
+    readonly placebo_treatment: StructType<{
+        /** Number of simulations (default 100) */
+        readonly num_simulations: OptionType<IntegerType>;
+    }>;
+    /** Add an independent random common cause - effect should be unchanged */
+    readonly random_common_cause: StructType<{
+        /** Number of simulations (default 100) */
+        readonly num_simulations: OptionType<IntegerType>;
+    }>;
+    /** Re-estimate on random data subsets - effect should be stable */
+    readonly data_subset: StructType<{
+        /** Fraction of rows kept per simulation (default 0.8) */
+        readonly subset_fraction: OptionType<FloatType>;
+        /** Number of simulations (default 100) */
+        readonly num_simulations: OptionType<IntegerType>;
+    }>;
+    /**
+     * Simulate an unobserved confounder at each given strength - a
+     * sensitivity/tipping curve. Strength acts on both treatment
+     * (flip probability for binary treatment, linear coefficient otherwise)
+     * and outcome (linear coefficient).
+     */
+    readonly unobserved_common_cause: StructType<{
+        /** Confounder effect strengths to simulate, one new effect per entry */
+        readonly effect_strengths: ArrayType<FloatType>;
+    }>;
+}>], StructType<{
+    /** The original estimated effect being refuted */
+    readonly estimated_effect: FloatType;
+    /**
+     * Effect under the refutation. One entry for placebo/random-common-cause/
+     * data-subset; one entry per strength for unobserved_common_cause.
+     */
+    readonly new_effects: VectorType<FloatType>;
+    /** Refutation p-value where the refuter provides one */
+    readonly p_value: OptionType<FloatType>;
+}>>;
+/**
+ * Fit an EconML LinearDML estimator for heterogeneous treatment effects.
+ *
+ * Cross-fits nuisance models for outcome and treatment, then fits a linear
+ * CATE model on the residuals.
+ *
+ * @param Y - Outcome vector
+ * @param T - Treatment vector
+ * @param X - Effect modifier matrix (CATE varies with these)
+ * @param W - Additional confounders adjusted for but not modifying the effect
+ * @param config - DML configuration
+ * @returns Model blob for use with dmlEffect / dmlAte
+ */
+export declare const causal_dml_train: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>, MatrixType<FloatType>, OptionType<MatrixType<FloatType>>, StructType<{
+    /** Nuisance model for the outcome stage (default: random_forest) */
+    readonly model_y: OptionType<VariantType<{
+        /** Random forest (regressor, or classifier for a discrete treatment) */
+        readonly random_forest: StructType<{
+            /** Number of trees (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 5) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+        readonly gradient_boosting: StructType<{
+            /** Number of boosting stages (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.1) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default 3) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Linear/logistic regression */
+        readonly linear: NullType;
+    }>>;
+    /** Nuisance model for the treatment stage (default: random_forest) */
+    readonly model_t: OptionType<VariantType<{
+        /** Random forest (regressor, or classifier for a discrete treatment) */
+        readonly random_forest: StructType<{
+            /** Number of trees (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 5) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+        readonly gradient_boosting: StructType<{
+            /** Number of boosting stages (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.1) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default 3) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Linear/logistic regression */
+        readonly linear: NullType;
+    }>>;
+    /** Treat the treatment as discrete/categorical (default false) */
+    readonly discrete_treatment: OptionType<BooleanType>;
+    /** Cross-fitting folds (default 2) */
+    readonly cv_folds: OptionType<IntegerType>;
+    /** Confidence level for effect/ATE intervals (default 0.95) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Random seed */
+    readonly random_state: OptionType<IntegerType>;
+}>], VariantType<{
+    /** Fitted EconML LinearDML estimator */
+    readonly causal_dml: StructType<{
+        /** Serialized estimator (cloudpickle) */
+        readonly data: BlobType;
+        /** Number of effect-modifier (X) features */
+        readonly n_features_x: IntegerType;
+        /** Confidence level used for effect/ATE intervals */
+        readonly confidence_level: FloatType;
+    }>;
+}>>;
+/**
+ * Per-row conditional average treatment effects (CATE) from a fitted DML model.
+ *
+ * @param model - Fitted DML model blob
+ * @param X - Effect modifier matrix
+ * @returns CATE per row (outcome units per treatment unit)
+ */
+export declare const causal_dml_effect: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Fitted EconML LinearDML estimator */
+    readonly causal_dml: StructType<{
+        /** Serialized estimator (cloudpickle) */
+        readonly data: BlobType;
+        /** Number of effect-modifier (X) features */
+        readonly n_features_x: IntegerType;
+        /** Confidence level used for effect/ATE intervals */
+        readonly confidence_level: FloatType;
+    }>;
+}>, MatrixType<FloatType>], VectorType<FloatType>>;
+/**
+ * Average treatment effect with confidence interval from a fitted DML model.
+ *
+ * @param model - Fitted DML model blob
+ * @param X - Effect modifier matrix to average over
+ * @returns ATE with interval at the confidence level configured at training
+ */
+export declare const causal_dml_ate: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Fitted EconML LinearDML estimator */
+    readonly causal_dml: StructType<{
+        /** Serialized estimator (cloudpickle) */
+        readonly data: BlobType;
+        /** Number of effect-modifier (X) features */
+        readonly n_features_x: IntegerType;
+        /** Confidence level used for effect/ATE intervals */
+        readonly confidence_level: FloatType;
+    }>;
+}>, MatrixType<FloatType>], StructType<{
+    /** Average treatment effect over the given X */
+    readonly ate: FloatType;
+    /** Lower bound at the model's confidence level */
+    readonly lower: FloatType;
+    /** Upper bound at the model's confidence level */
+    readonly upper: FloatType;
+}>>;
+/**
+ * Accumulated local effects dose-response curve of a feature on an outcome.
+ *
+ * Fits a gradient boosting emulator on all non-outcome columns, then
+ * computes the ALE curve of the feature - robust to correlated features,
+ * unlike partial dependence.
+ *
+ * @param data - Data matrix (rows = units, columns named by config.columns)
+ * @param config - ALE configuration
+ * @returns ALE curve with grid, centered effect, optional CI, and bin sizes
+ */
+export declare const causal_ale: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, StructType<{
+    /** Column names for the data matrix (one per column, in order) */
+    readonly columns: ArrayType<StringType>;
+    /** Outcome column the emulator predicts */
+    readonly outcome: StringType;
+    /** Continuous feature column to compute the ALE curve for */
+    readonly feature: StringType;
+    /** Columns holding integer category codes, one-hot encoded internally */
+    readonly categorical: OptionType<ArrayType<StringType>>;
+    /** Number of grid intervals (default 10) */
+    readonly grid_size: OptionType<IntegerType>;
+    /** Include confidence intervals (default true) */
+    readonly include_ci: OptionType<BooleanType>;
+    /** Confidence level for the CI (default 0.95) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Emulator (HistGradientBoosting) hyperparameters */
+    readonly emulator: OptionType<StructType<{
+        /** Number of boosting iterations (default 300) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Learning rate (default 0.05) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Maximum tree depth (default unlimited) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Minimum samples per leaf (default 20; lower for small datasets) */
+        readonly min_samples_leaf: OptionType<IntegerType>;
+    }>>;
+    /** Random seed for the emulator */
+    readonly random_state: OptionType<IntegerType>;
+}>], StructType<{
+    /** Feature grid values (interval edges) */
+    readonly grid: VectorType<FloatType>;
+    /** Centered ALE effect at each grid value (outcome units) */
+    readonly effect: VectorType<FloatType>;
+    /** Lower CI at each grid value (present when include_ci) */
+    readonly lower: OptionType<VectorType<FloatType>>;
+    /** Upper CI at each grid value (present when include_ci) */
+    readonly upper: OptionType<VectorType<FloatType>>;
+    /** Number of samples in each grid interval */
+    readonly size: VectorType<IntegerType>;
+}>>;
+/**
+ * Type definitions for causal inference functions.
+ */
+export declare const CausalTypes: {
+    readonly CausalWeightingSchemeType: VariantType<{
+        /** Raw inverse propensity weights */
+        readonly ips_weight: NullType;
+        /** Stabilized inverse propensity weights (recommended; lower variance) */
+        readonly ips_stabilized_weight: NullType;
+        /** Normalized inverse propensity weights */
+        readonly ips_normalized_weight: NullType;
+    }>;
+    readonly CausalEstimatorType: VariantType<{
+        /** Linear regression of outcome on treatment + common causes */
+        readonly linear_regression: NullType;
+        /** Inverse propensity score weighting (binary treatment only) */
+        readonly propensity_score_weighting: StructType<{
+            /** Weighting scheme (default: ips_stabilized_weight) */
+            readonly weighting_scheme: OptionType<VariantType<{
+                /** Raw inverse propensity weights */
+                readonly ips_weight: NullType;
+                /** Stabilized inverse propensity weights (recommended; lower variance) */
+                readonly ips_stabilized_weight: NullType;
+                /** Normalized inverse propensity weights */
+                readonly ips_normalized_weight: NullType;
+            }>>;
+        }>;
+    }>;
+    readonly CausalTargetUnitsType: VariantType<{
+        /** Average treatment effect over all units */
+        readonly ate: NullType;
+        /** Average treatment effect on the treated */
+        readonly att: NullType;
+        /** Average treatment effect on the controls */
+        readonly atc: NullType;
+    }>;
+    readonly PropensityTrimType: VariantType<{
+        /** Keep units inside the common-support overlap of treated and control propensities */
+        readonly overlap: NullType;
+        /** Keep units with propensity inside explicit bounds */
+        readonly bounds: StructType<{
+            /** Minimum propensity score to keep */
+            readonly lower: FloatType;
+            /** Maximum propensity score to keep */
+            readonly upper: FloatType;
+        }>;
+    }>;
+    readonly CausalBootstrapConfigType: StructType<{
+        /** Number of bootstrap replicates */
+        readonly reps: IntegerType;
+        /** Column whose values identify clusters to resample (default: resample rows) */
+        readonly cluster_column: OptionType<StringType>;
+        /** Confidence level for the percentile interval (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+    }>;
+    readonly CausalEffectConfigType: StructType<{
+        /** Column names for the data matrix (one per column, in order) */
+        readonly columns: ArrayType<StringType>;
+        /** Treatment column (must be 0/1 for propensity score weighting) */
+        readonly treatment: StringType;
+        /** Outcome column */
+        readonly outcome: StringType;
+        /** Confounder columns to adjust for (the backdoor set) */
+        readonly common_causes: ArrayType<StringType>;
+        /** Columns holding integer category codes, one-hot encoded internally */
+        readonly categorical: OptionType<ArrayType<StringType>>;
+        /** Effect estimator (default: linear_regression) */
+        readonly method: OptionType<VariantType<{
+            /** Linear regression of outcome on treatment + common causes */
+            readonly linear_regression: NullType;
+            /** Inverse propensity score weighting (binary treatment only) */
+            readonly propensity_score_weighting: StructType<{
+                /** Weighting scheme (default: ips_stabilized_weight) */
+                readonly weighting_scheme: OptionType<VariantType<{
+                    /** Raw inverse propensity weights */
+                    readonly ips_weight: NullType;
+                    /** Stabilized inverse propensity weights (recommended; lower variance) */
+                    readonly ips_stabilized_weight: NullType;
+                    /** Normalized inverse propensity weights */
+                    readonly ips_normalized_weight: NullType;
+                }>>;
+            }>;
+        }>>;
+        /** Target population (default: ate) */
+        readonly target_units: OptionType<VariantType<{
+            /** Average treatment effect over all units */
+            readonly ate: NullType;
+            /** Average treatment effect on the treated */
+            readonly att: NullType;
+            /** Average treatment effect on the controls */
+            readonly atc: NullType;
+        }>>;
+        /** Propensity trimming applied before estimation (psw only) */
+        readonly trim: OptionType<VariantType<{
+            /** Keep units inside the common-support overlap of treated and control propensities */
+            readonly overlap: NullType;
+            /** Keep units with propensity inside explicit bounds */
+            readonly bounds: StructType<{
+                /** Minimum propensity score to keep */
+                readonly lower: FloatType;
+                /** Maximum propensity score to keep */
+                readonly upper: FloatType;
+            }>;
+        }>>;
+        /** Bootstrap confidence interval (omit to skip CI computation) */
+        readonly bootstrap: OptionType<StructType<{
+            /** Number of bootstrap replicates */
+            readonly reps: IntegerType;
+            /** Column whose values identify clusters to resample (default: resample rows) */
+            readonly cluster_column: OptionType<StringType>;
+            /** Confidence level for the percentile interval (default 0.95) */
+            readonly confidence_level: OptionType<FloatType>;
+        }>>;
+        /** Random seed for propensity fitting and bootstrap resampling */
+        readonly random_state: OptionType<IntegerType>;
+    }>;
+    readonly CausalRefuterType: VariantType<{
+        /** Replace treatment with a permuted placebo - effect should vanish */
+        readonly placebo_treatment: StructType<{
+            /** Number of simulations (default 100) */
+            readonly num_simulations: OptionType<IntegerType>;
+        }>;
+        /** Add an independent random common cause - effect should be unchanged */
+        readonly random_common_cause: StructType<{
+            /** Number of simulations (default 100) */
+            readonly num_simulations: OptionType<IntegerType>;
+        }>;
+        /** Re-estimate on random data subsets - effect should be stable */
+        readonly data_subset: StructType<{
+            /** Fraction of rows kept per simulation (default 0.8) */
+            readonly subset_fraction: OptionType<FloatType>;
+            /** Number of simulations (default 100) */
+            readonly num_simulations: OptionType<IntegerType>;
+        }>;
+        /**
+         * Simulate an unobserved confounder at each given strength - a
+         * sensitivity/tipping curve. Strength acts on both treatment
+         * (flip probability for binary treatment, linear coefficient otherwise)
+         * and outcome (linear coefficient).
+         */
+        readonly unobserved_common_cause: StructType<{
+            /** Confounder effect strengths to simulate, one new effect per entry */
+            readonly effect_strengths: ArrayType<FloatType>;
+        }>;
+    }>;
+    readonly CausalNuisanceModelType: VariantType<{
+        /** Random forest (regressor, or classifier for a discrete treatment) */
+        readonly random_forest: StructType<{
+            /** Number of trees (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 5) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+        readonly gradient_boosting: StructType<{
+            /** Number of boosting stages (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.1) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default 3) */
+            readonly max_depth: OptionType<IntegerType>;
+        }>;
+        /** Linear/logistic regression */
+        readonly linear: NullType;
+    }>;
+    readonly CausalDMLConfigType: StructType<{
+        /** Nuisance model for the outcome stage (default: random_forest) */
+        readonly model_y: OptionType<VariantType<{
+            /** Random forest (regressor, or classifier for a discrete treatment) */
+            readonly random_forest: StructType<{
+                /** Number of trees (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Minimum samples per leaf (default 5) */
+                readonly min_samples_leaf: OptionType<IntegerType>;
+                /** Maximum tree depth (default unlimited) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+            readonly gradient_boosting: StructType<{
+                /** Number of boosting stages (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Learning rate (default 0.1) */
+                readonly learning_rate: OptionType<FloatType>;
+                /** Maximum tree depth (default 3) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Linear/logistic regression */
+            readonly linear: NullType;
+        }>>;
+        /** Nuisance model for the treatment stage (default: random_forest) */
+        readonly model_t: OptionType<VariantType<{
+            /** Random forest (regressor, or classifier for a discrete treatment) */
+            readonly random_forest: StructType<{
+                /** Number of trees (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Minimum samples per leaf (default 5) */
+                readonly min_samples_leaf: OptionType<IntegerType>;
+                /** Maximum tree depth (default unlimited) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+            readonly gradient_boosting: StructType<{
+                /** Number of boosting stages (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Learning rate (default 0.1) */
+                readonly learning_rate: OptionType<FloatType>;
+                /** Maximum tree depth (default 3) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Linear/logistic regression */
+            readonly linear: NullType;
+        }>>;
+        /** Treat the treatment as discrete/categorical (default false) */
+        readonly discrete_treatment: OptionType<BooleanType>;
+        /** Cross-fitting folds (default 2) */
+        readonly cv_folds: OptionType<IntegerType>;
+        /** Confidence level for effect/ATE intervals (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Random seed */
+        readonly random_state: OptionType<IntegerType>;
+    }>;
+    readonly CausalALEConfigType: StructType<{
+        /** Column names for the data matrix (one per column, in order) */
+        readonly columns: ArrayType<StringType>;
+        /** Outcome column the emulator predicts */
+        readonly outcome: StringType;
+        /** Continuous feature column to compute the ALE curve for */
+        readonly feature: StringType;
+        /** Columns holding integer category codes, one-hot encoded internally */
+        readonly categorical: OptionType<ArrayType<StringType>>;
+        /** Number of grid intervals (default 10) */
+        readonly grid_size: OptionType<IntegerType>;
+        /** Include confidence intervals (default true) */
+        readonly include_ci: OptionType<BooleanType>;
+        /** Confidence level for the CI (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Emulator (HistGradientBoosting) hyperparameters */
+        readonly emulator: OptionType<StructType<{
+            /** Number of boosting iterations (default 300) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.05) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 20; lower for small datasets) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+        }>>;
+        /** Random seed for the emulator */
+        readonly random_state: OptionType<IntegerType>;
+    }>;
+    readonly CausalDMLModelBlobType: VariantType<{
+        /** Fitted EconML LinearDML estimator */
+        readonly causal_dml: StructType<{
+            /** Serialized estimator (cloudpickle) */
+            readonly data: BlobType;
+            /** Number of effect-modifier (X) features */
+            readonly n_features_x: IntegerType;
+            /** Confidence level used for effect/ATE intervals */
+            readonly confidence_level: FloatType;
+        }>;
+    }>;
+    readonly CausalEffectResultType: StructType<{
+        /** Point estimate of the effect (outcome units per treatment unit) */
+        readonly effect: FloatType;
+        /** Bootstrap percentile confidence interval (present when bootstrap configured) */
+        readonly ci: OptionType<StructType<{
+            /** Lower bound */
+            readonly lower: FloatType;
+            /** Upper bound */
+            readonly upper: FloatType;
+        }>>;
+        /** Rows used for estimation (after trimming) */
+        readonly n_samples: IntegerType;
+        /** Treated rows used */
+        readonly n_treated: IntegerType;
+        /** Control rows used */
+        readonly n_control: IntegerType;
+    }>;
+    readonly CausalRefuteResultType: StructType<{
+        /** The original estimated effect being refuted */
+        readonly estimated_effect: FloatType;
+        /**
+         * Effect under the refutation. One entry for placebo/random-common-cause/
+         * data-subset; one entry per strength for unobserved_common_cause.
+         */
+        readonly new_effects: VectorType<FloatType>;
+        /** Refutation p-value where the refuter provides one */
+        readonly p_value: OptionType<FloatType>;
+    }>;
+    readonly CausalATEResultType: StructType<{
+        /** Average treatment effect over the given X */
+        readonly ate: FloatType;
+        /** Lower bound at the model's confidence level */
+        readonly lower: FloatType;
+        /** Upper bound at the model's confidence level */
+        readonly upper: FloatType;
+    }>;
+    readonly ALEResultType: StructType<{
+        /** Feature grid values (interval edges) */
+        readonly grid: VectorType<FloatType>;
+        /** Centered ALE effect at each grid value (outcome units) */
+        readonly effect: VectorType<FloatType>;
+        /** Lower CI at each grid value (present when include_ci) */
+        readonly lower: OptionType<VectorType<FloatType>>;
+        /** Upper CI at each grid value (present when include_ci) */
+        readonly upper: OptionType<VectorType<FloatType>>;
+        /** Number of samples in each grid interval */
+        readonly size: VectorType<IntegerType>;
+    }>;
+};
+/**
+ * Causal inference.
+ *
+ * Backdoor-adjusted effect estimation and refutation (DoWhy),
+ * heterogeneous treatment effects via double machine learning
+ * (EconML LinearDML), and accumulated local effects dose-response
+ * curves (PyALE).
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { Causal, MatrixType } from "@elaraai/east-py-datascience";
+ *
+ * const estimate = East.function(
+ *     [MatrixType(FloatType)],
+ *     Causal.Types.CausalEffectResultType,
+ *     ($, data) => {
+ *         const config = $.let({
+ *             columns: ["treated", "outcome", "confounder"],
+ *             treatment: "treated",
+ *             outcome: "outcome",
+ *             common_causes: ["confounder"],
+ *             categorical: variant('none', null),
+ *             method: variant('some', variant('linear_regression', null)),
+ *             target_units: variant('some', variant('ate', null)),
+ *             trim: variant('none', null),
+ *             bootstrap: variant('none', null),
+ *             random_state: variant('some', 42n),
+ *         }, Causal.Types.CausalEffectConfigType);
+ *         return $.return(Causal.effect(data, config));
+ *     }
+ * );
+ * ```
+ */
+export declare const Causal: {
+    /**
+     * Estimate a backdoor-adjusted causal effect of treatment on outcome.
+     *
+     * Linear regression or inverse propensity score weighting (with
+     * optional propensity trimming), plus optional cluster bootstrap CI.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Causal, CausalEffectConfigType, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const attEstimate = East.function(
+     *     [MatrixType(FloatType)],
+     *     Causal.Types.CausalEffectResultType,
+     *     ($, data) => {
+     *         const config = $.let({
+     *             columns: ["treated", "outcome", "z1", "z2", "batch"],
+     *             treatment: "treated",
+     *             outcome: "outcome",
+     *             common_causes: ["z1", "z2"],
+     *             categorical: variant('none', null),
+     *             method: variant('some', variant('propensity_score_weighting', {
+     *                 weighting_scheme: variant('some', variant('ips_stabilized_weight', null)),
+     *             })),
+     *             target_units: variant('some', variant('att', null)),
+     *             trim: variant('some', variant('overlap', null)),
+     *             bootstrap: variant('some', {
+     *                 reps: 200n,
+     *                 cluster_column: variant('some', "batch"),
+     *                 confidence_level: variant('some', 0.95),
+     *             }),
+     *             random_state: variant('some', 42n),
+     *         }, CausalEffectConfigType);
+     *         return $.return(Causal.effect(data, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly effect: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, StructType<{
+        /** Column names for the data matrix (one per column, in order) */
+        readonly columns: ArrayType<StringType>;
+        /** Treatment column (must be 0/1 for propensity score weighting) */
+        readonly treatment: StringType;
+        /** Outcome column */
+        readonly outcome: StringType;
+        /** Confounder columns to adjust for (the backdoor set) */
+        readonly common_causes: ArrayType<StringType>;
+        /** Columns holding integer category codes, one-hot encoded internally */
+        readonly categorical: OptionType<ArrayType<StringType>>;
+        /** Effect estimator (default: linear_regression) */
+        readonly method: OptionType<VariantType<{
+            /** Linear regression of outcome on treatment + common causes */
+            readonly linear_regression: NullType;
+            /** Inverse propensity score weighting (binary treatment only) */
+            readonly propensity_score_weighting: StructType<{
+                /** Weighting scheme (default: ips_stabilized_weight) */
+                readonly weighting_scheme: OptionType<VariantType<{
+                    /** Raw inverse propensity weights */
+                    readonly ips_weight: NullType;
+                    /** Stabilized inverse propensity weights (recommended; lower variance) */
+                    readonly ips_stabilized_weight: NullType;
+                    /** Normalized inverse propensity weights */
+                    readonly ips_normalized_weight: NullType;
+                }>>;
+            }>;
+        }>>;
+        /** Target population (default: ate) */
+        readonly target_units: OptionType<VariantType<{
+            /** Average treatment effect over all units */
+            readonly ate: NullType;
+            /** Average treatment effect on the treated */
+            readonly att: NullType;
+            /** Average treatment effect on the controls */
+            readonly atc: NullType;
+        }>>;
+        /** Propensity trimming applied before estimation (psw only) */
+        readonly trim: OptionType<VariantType<{
+            /** Keep units inside the common-support overlap of treated and control propensities */
+            readonly overlap: NullType;
+            /** Keep units with propensity inside explicit bounds */
+            readonly bounds: StructType<{
+                /** Minimum propensity score to keep */
+                readonly lower: FloatType;
+                /** Maximum propensity score to keep */
+                readonly upper: FloatType;
+            }>;
+        }>>;
+        /** Bootstrap confidence interval (omit to skip CI computation) */
+        readonly bootstrap: OptionType<StructType<{
+            /** Number of bootstrap replicates */
+            readonly reps: IntegerType;
+            /** Column whose values identify clusters to resample (default: resample rows) */
+            readonly cluster_column: OptionType<StringType>;
+            /** Confidence level for the percentile interval (default 0.95) */
+            readonly confidence_level: OptionType<FloatType>;
+        }>>;
+        /** Random seed for propensity fitting and bootstrap resampling */
+        readonly random_state: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Point estimate of the effect (outcome units per treatment unit) */
+        readonly effect: FloatType;
+        /** Bootstrap percentile confidence interval (present when bootstrap configured) */
+        readonly ci: OptionType<StructType<{
+            /** Lower bound */
+            readonly lower: FloatType;
+            /** Upper bound */
+            readonly upper: FloatType;
+        }>>;
+        /** Rows used for estimation (after trimming) */
+        readonly n_samples: IntegerType;
+        /** Treated rows used */
+        readonly n_treated: IntegerType;
+        /** Control rows used */
+        readonly n_control: IntegerType;
+    }>>;
+    /**
+     * Refute an estimated causal effect with placebo, random common cause,
+     * data subset, or unobserved-confounder sensitivity tests.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Causal, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const placebo = East.function(
+     *     [MatrixType(FloatType), Causal.Types.CausalEffectConfigType],
+     *     Causal.Types.CausalRefuteResultType,
+     *     ($, data, config) => {
+     *         const refuter = $.let(variant('placebo_treatment', {
+     *             num_simulations: variant('some', 50n),
+     *         }), Causal.Types.CausalRefuterType);
+     *         // new_effects should be near zero if the estimate is causal
+     *         return $.return(Causal.refute(data, config, refuter));
+     *     }
+     * );
+     * ```
+     */
+    readonly refute: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, StructType<{
+        /** Column names for the data matrix (one per column, in order) */
+        readonly columns: ArrayType<StringType>;
+        /** Treatment column (must be 0/1 for propensity score weighting) */
+        readonly treatment: StringType;
+        /** Outcome column */
+        readonly outcome: StringType;
+        /** Confounder columns to adjust for (the backdoor set) */
+        readonly common_causes: ArrayType<StringType>;
+        /** Columns holding integer category codes, one-hot encoded internally */
+        readonly categorical: OptionType<ArrayType<StringType>>;
+        /** Effect estimator (default: linear_regression) */
+        readonly method: OptionType<VariantType<{
+            /** Linear regression of outcome on treatment + common causes */
+            readonly linear_regression: NullType;
+            /** Inverse propensity score weighting (binary treatment only) */
+            readonly propensity_score_weighting: StructType<{
+                /** Weighting scheme (default: ips_stabilized_weight) */
+                readonly weighting_scheme: OptionType<VariantType<{
+                    /** Raw inverse propensity weights */
+                    readonly ips_weight: NullType;
+                    /** Stabilized inverse propensity weights (recommended; lower variance) */
+                    readonly ips_stabilized_weight: NullType;
+                    /** Normalized inverse propensity weights */
+                    readonly ips_normalized_weight: NullType;
+                }>>;
+            }>;
+        }>>;
+        /** Target population (default: ate) */
+        readonly target_units: OptionType<VariantType<{
+            /** Average treatment effect over all units */
+            readonly ate: NullType;
+            /** Average treatment effect on the treated */
+            readonly att: NullType;
+            /** Average treatment effect on the controls */
+            readonly atc: NullType;
+        }>>;
+        /** Propensity trimming applied before estimation (psw only) */
+        readonly trim: OptionType<VariantType<{
+            /** Keep units inside the common-support overlap of treated and control propensities */
+            readonly overlap: NullType;
+            /** Keep units with propensity inside explicit bounds */
+            readonly bounds: StructType<{
+                /** Minimum propensity score to keep */
+                readonly lower: FloatType;
+                /** Maximum propensity score to keep */
+                readonly upper: FloatType;
+            }>;
+        }>>;
+        /** Bootstrap confidence interval (omit to skip CI computation) */
+        readonly bootstrap: OptionType<StructType<{
+            /** Number of bootstrap replicates */
+            readonly reps: IntegerType;
+            /** Column whose values identify clusters to resample (default: resample rows) */
+            readonly cluster_column: OptionType<StringType>;
+            /** Confidence level for the percentile interval (default 0.95) */
+            readonly confidence_level: OptionType<FloatType>;
+        }>>;
+        /** Random seed for propensity fitting and bootstrap resampling */
+        readonly random_state: OptionType<IntegerType>;
+    }>, VariantType<{
+        /** Replace treatment with a permuted placebo - effect should vanish */
+        readonly placebo_treatment: StructType<{
+            /** Number of simulations (default 100) */
+            readonly num_simulations: OptionType<IntegerType>;
+        }>;
+        /** Add an independent random common cause - effect should be unchanged */
+        readonly random_common_cause: StructType<{
+            /** Number of simulations (default 100) */
+            readonly num_simulations: OptionType<IntegerType>;
+        }>;
+        /** Re-estimate on random data subsets - effect should be stable */
+        readonly data_subset: StructType<{
+            /** Fraction of rows kept per simulation (default 0.8) */
+            readonly subset_fraction: OptionType<FloatType>;
+            /** Number of simulations (default 100) */
+            readonly num_simulations: OptionType<IntegerType>;
+        }>;
+        /**
+         * Simulate an unobserved confounder at each given strength - a
+         * sensitivity/tipping curve. Strength acts on both treatment
+         * (flip probability for binary treatment, linear coefficient otherwise)
+         * and outcome (linear coefficient).
+         */
+        readonly unobserved_common_cause: StructType<{
+            /** Confounder effect strengths to simulate, one new effect per entry */
+            readonly effect_strengths: ArrayType<FloatType>;
+        }>;
+    }>], StructType<{
+        /** The original estimated effect being refuted */
+        readonly estimated_effect: FloatType;
+        /**
+         * Effect under the refutation. One entry for placebo/random-common-cause/
+         * data-subset; one entry per strength for unobserved_common_cause.
+         */
+        readonly new_effects: VectorType<FloatType>;
+        /** Refutation p-value where the refuter provides one */
+        readonly p_value: OptionType<FloatType>;
+    }>>;
+    /**
+     * Fit an EconML LinearDML estimator for heterogeneous treatment effects.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Causal, CausalDMLConfigType, MatrixType, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [VectorType(FloatType), VectorType(FloatType), MatrixType(FloatType), MatrixType(FloatType)],
+     *     Causal.Types.CausalDMLModelBlobType,
+     *     ($, Y, T, X, W) => {
+     *         const config = $.let({
+     *             model_y: variant('some', variant('random_forest', {
+     *                 n_estimators: variant('some', 100n),
+     *                 min_samples_leaf: variant('some', 5n),
+     *                 max_depth: variant('none', null),
+     *             })),
+     *             model_t: variant('none', null),
+     *             discrete_treatment: variant('none', null),
+     *             cv_folds: variant('some', 2n),
+     *             confidence_level: variant('some', 0.95),
+     *             random_state: variant('some', 42n),
+     *         }, CausalDMLConfigType);
+     *         return $.return(Causal.dmlTrain(Y, T, X, variant('some', W), config));
+     *     }
+     * );
+     * ```
+     */
+    readonly dmlTrain: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>, MatrixType<FloatType>, OptionType<MatrixType<FloatType>>, StructType<{
+        /** Nuisance model for the outcome stage (default: random_forest) */
+        readonly model_y: OptionType<VariantType<{
+            /** Random forest (regressor, or classifier for a discrete treatment) */
+            readonly random_forest: StructType<{
+                /** Number of trees (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Minimum samples per leaf (default 5) */
+                readonly min_samples_leaf: OptionType<IntegerType>;
+                /** Maximum tree depth (default unlimited) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+            readonly gradient_boosting: StructType<{
+                /** Number of boosting stages (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Learning rate (default 0.1) */
+                readonly learning_rate: OptionType<FloatType>;
+                /** Maximum tree depth (default 3) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Linear/logistic regression */
+            readonly linear: NullType;
+        }>>;
+        /** Nuisance model for the treatment stage (default: random_forest) */
+        readonly model_t: OptionType<VariantType<{
+            /** Random forest (regressor, or classifier for a discrete treatment) */
+            readonly random_forest: StructType<{
+                /** Number of trees (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Minimum samples per leaf (default 5) */
+                readonly min_samples_leaf: OptionType<IntegerType>;
+                /** Maximum tree depth (default unlimited) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+            readonly gradient_boosting: StructType<{
+                /** Number of boosting stages (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Learning rate (default 0.1) */
+                readonly learning_rate: OptionType<FloatType>;
+                /** Maximum tree depth (default 3) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Linear/logistic regression */
+            readonly linear: NullType;
+        }>>;
+        /** Treat the treatment as discrete/categorical (default false) */
+        readonly discrete_treatment: OptionType<BooleanType>;
+        /** Cross-fitting folds (default 2) */
+        readonly cv_folds: OptionType<IntegerType>;
+        /** Confidence level for effect/ATE intervals (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Random seed */
+        readonly random_state: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** Fitted EconML LinearDML estimator */
+        readonly causal_dml: StructType<{
+            /** Serialized estimator (cloudpickle) */
+            readonly data: BlobType;
+            /** Number of effect-modifier (X) features */
+            readonly n_features_x: IntegerType;
+            /** Confidence level used for effect/ATE intervals */
+            readonly confidence_level: FloatType;
+        }>;
+    }>>;
+    /**
+     * Per-row conditional average treatment effects from a fitted DML model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Causal, MatrixType, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const cate = East.function(
+     *     [Causal.Types.CausalDMLModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => $.return(Causal.dmlEffect(model, X))
+     * );
+     * ```
+     */
+    readonly dmlEffect: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Fitted EconML LinearDML estimator */
+        readonly causal_dml: StructType<{
+            /** Serialized estimator (cloudpickle) */
+            readonly data: BlobType;
+            /** Number of effect-modifier (X) features */
+            readonly n_features_x: IntegerType;
+            /** Confidence level used for effect/ATE intervals */
+            readonly confidence_level: FloatType;
+        }>;
+    }>, MatrixType<FloatType>], VectorType<FloatType>>;
+    /**
+     * Average treatment effect with confidence interval from a fitted DML model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Causal, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const ate = East.function(
+     *     [Causal.Types.CausalDMLModelBlobType, MatrixType(FloatType)],
+     *     Causal.Types.CausalATEResultType,
+     *     ($, model, X) => $.return(Causal.dmlAte(model, X))
+     * );
+     * ```
+     */
+    readonly dmlAte: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Fitted EconML LinearDML estimator */
+        readonly causal_dml: StructType<{
+            /** Serialized estimator (cloudpickle) */
+            readonly data: BlobType;
+            /** Number of effect-modifier (X) features */
+            readonly n_features_x: IntegerType;
+            /** Confidence level used for effect/ATE intervals */
+            readonly confidence_level: FloatType;
+        }>;
+    }>, MatrixType<FloatType>], StructType<{
+        /** Average treatment effect over the given X */
+        readonly ate: FloatType;
+        /** Lower bound at the model's confidence level */
+        readonly lower: FloatType;
+        /** Upper bound at the model's confidence level */
+        readonly upper: FloatType;
+    }>>;
+    /**
+     * Accumulated local effects dose-response curve of a feature on an outcome.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Causal, CausalALEConfigType, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const doseResponse = East.function(
+     *     [MatrixType(FloatType)],
+     *     Causal.Types.ALEResultType,
+     *     ($, data) => {
+     *         const config = $.let({
+     *             columns: ["dose", "z", "response"],
+     *             outcome: "response",
+     *             feature: "dose",
+     *             categorical: variant('none', null),
+     *             grid_size: variant('some', 10n),
+     *             include_ci: variant('some', true),
+     *             confidence_level: variant('some', 0.95),
+     *             emulator: variant('none', null),
+     *             random_state: variant('some', 42n),
+     *         }, CausalALEConfigType);
+     *         return $.return(Causal.ale(data, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly ale: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, StructType<{
+        /** Column names for the data matrix (one per column, in order) */
+        readonly columns: ArrayType<StringType>;
+        /** Outcome column the emulator predicts */
+        readonly outcome: StringType;
+        /** Continuous feature column to compute the ALE curve for */
+        readonly feature: StringType;
+        /** Columns holding integer category codes, one-hot encoded internally */
+        readonly categorical: OptionType<ArrayType<StringType>>;
+        /** Number of grid intervals (default 10) */
+        readonly grid_size: OptionType<IntegerType>;
+        /** Include confidence intervals (default true) */
+        readonly include_ci: OptionType<BooleanType>;
+        /** Confidence level for the CI (default 0.95) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Emulator (HistGradientBoosting) hyperparameters */
+        readonly emulator: OptionType<StructType<{
+            /** Number of boosting iterations (default 300) */
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Learning rate (default 0.05) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Maximum tree depth (default unlimited) */
+            readonly max_depth: OptionType<IntegerType>;
+            /** Minimum samples per leaf (default 20; lower for small datasets) */
+            readonly min_samples_leaf: OptionType<IntegerType>;
+        }>>;
+        /** Random seed for the emulator */
+        readonly random_state: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Feature grid values (interval edges) */
+        readonly grid: VectorType<FloatType>;
+        /** Centered ALE effect at each grid value (outcome units) */
+        readonly effect: VectorType<FloatType>;
+        /** Lower CI at each grid value (present when include_ci) */
+        readonly lower: OptionType<VectorType<FloatType>>;
+        /** Upper CI at each grid value (present when include_ci) */
+        readonly upper: OptionType<VectorType<FloatType>>;
+        /** Number of samples in each grid interval */
+        readonly size: VectorType<IntegerType>;
+    }>>;
+    /** Type definitions */
+    readonly Types: {
+        readonly CausalWeightingSchemeType: VariantType<{
+            /** Raw inverse propensity weights */
+            readonly ips_weight: NullType;
+            /** Stabilized inverse propensity weights (recommended; lower variance) */
+            readonly ips_stabilized_weight: NullType;
+            /** Normalized inverse propensity weights */
+            readonly ips_normalized_weight: NullType;
+        }>;
+        readonly CausalEstimatorType: VariantType<{
+            /** Linear regression of outcome on treatment + common causes */
+            readonly linear_regression: NullType;
+            /** Inverse propensity score weighting (binary treatment only) */
+            readonly propensity_score_weighting: StructType<{
+                /** Weighting scheme (default: ips_stabilized_weight) */
+                readonly weighting_scheme: OptionType<VariantType<{
+                    /** Raw inverse propensity weights */
+                    readonly ips_weight: NullType;
+                    /** Stabilized inverse propensity weights (recommended; lower variance) */
+                    readonly ips_stabilized_weight: NullType;
+                    /** Normalized inverse propensity weights */
+                    readonly ips_normalized_weight: NullType;
+                }>>;
+            }>;
+        }>;
+        readonly CausalTargetUnitsType: VariantType<{
+            /** Average treatment effect over all units */
+            readonly ate: NullType;
+            /** Average treatment effect on the treated */
+            readonly att: NullType;
+            /** Average treatment effect on the controls */
+            readonly atc: NullType;
+        }>;
+        readonly PropensityTrimType: VariantType<{
+            /** Keep units inside the common-support overlap of treated and control propensities */
+            readonly overlap: NullType;
+            /** Keep units with propensity inside explicit bounds */
+            readonly bounds: StructType<{
+                /** Minimum propensity score to keep */
+                readonly lower: FloatType;
+                /** Maximum propensity score to keep */
+                readonly upper: FloatType;
+            }>;
+        }>;
+        readonly CausalBootstrapConfigType: StructType<{
+            /** Number of bootstrap replicates */
+            readonly reps: IntegerType;
+            /** Column whose values identify clusters to resample (default: resample rows) */
+            readonly cluster_column: OptionType<StringType>;
+            /** Confidence level for the percentile interval (default 0.95) */
+            readonly confidence_level: OptionType<FloatType>;
+        }>;
+        readonly CausalEffectConfigType: StructType<{
+            /** Column names for the data matrix (one per column, in order) */
+            readonly columns: ArrayType<StringType>;
+            /** Treatment column (must be 0/1 for propensity score weighting) */
+            readonly treatment: StringType;
+            /** Outcome column */
+            readonly outcome: StringType;
+            /** Confounder columns to adjust for (the backdoor set) */
+            readonly common_causes: ArrayType<StringType>;
+            /** Columns holding integer category codes, one-hot encoded internally */
+            readonly categorical: OptionType<ArrayType<StringType>>;
+            /** Effect estimator (default: linear_regression) */
+            readonly method: OptionType<VariantType<{
+                /** Linear regression of outcome on treatment + common causes */
+                readonly linear_regression: NullType;
+                /** Inverse propensity score weighting (binary treatment only) */
+                readonly propensity_score_weighting: StructType<{
+                    /** Weighting scheme (default: ips_stabilized_weight) */
+                    readonly weighting_scheme: OptionType<VariantType<{
+                        /** Raw inverse propensity weights */
+                        readonly ips_weight: NullType;
+                        /** Stabilized inverse propensity weights (recommended; lower variance) */
+                        readonly ips_stabilized_weight: NullType;
+                        /** Normalized inverse propensity weights */
+                        readonly ips_normalized_weight: NullType;
+                    }>>;
+                }>;
+            }>>;
+            /** Target population (default: ate) */
+            readonly target_units: OptionType<VariantType<{
+                /** Average treatment effect over all units */
+                readonly ate: NullType;
+                /** Average treatment effect on the treated */
+                readonly att: NullType;
+                /** Average treatment effect on the controls */
+                readonly atc: NullType;
+            }>>;
+            /** Propensity trimming applied before estimation (psw only) */
+            readonly trim: OptionType<VariantType<{
+                /** Keep units inside the common-support overlap of treated and control propensities */
+                readonly overlap: NullType;
+                /** Keep units with propensity inside explicit bounds */
+                readonly bounds: StructType<{
+                    /** Minimum propensity score to keep */
+                    readonly lower: FloatType;
+                    /** Maximum propensity score to keep */
+                    readonly upper: FloatType;
+                }>;
+            }>>;
+            /** Bootstrap confidence interval (omit to skip CI computation) */
+            readonly bootstrap: OptionType<StructType<{
+                /** Number of bootstrap replicates */
+                readonly reps: IntegerType;
+                /** Column whose values identify clusters to resample (default: resample rows) */
+                readonly cluster_column: OptionType<StringType>;
+                /** Confidence level for the percentile interval (default 0.95) */
+                readonly confidence_level: OptionType<FloatType>;
+            }>>;
+            /** Random seed for propensity fitting and bootstrap resampling */
+            readonly random_state: OptionType<IntegerType>;
+        }>;
+        readonly CausalRefuterType: VariantType<{
+            /** Replace treatment with a permuted placebo - effect should vanish */
+            readonly placebo_treatment: StructType<{
+                /** Number of simulations (default 100) */
+                readonly num_simulations: OptionType<IntegerType>;
+            }>;
+            /** Add an independent random common cause - effect should be unchanged */
+            readonly random_common_cause: StructType<{
+                /** Number of simulations (default 100) */
+                readonly num_simulations: OptionType<IntegerType>;
+            }>;
+            /** Re-estimate on random data subsets - effect should be stable */
+            readonly data_subset: StructType<{
+                /** Fraction of rows kept per simulation (default 0.8) */
+                readonly subset_fraction: OptionType<FloatType>;
+                /** Number of simulations (default 100) */
+                readonly num_simulations: OptionType<IntegerType>;
+            }>;
+            /**
+             * Simulate an unobserved confounder at each given strength - a
+             * sensitivity/tipping curve. Strength acts on both treatment
+             * (flip probability for binary treatment, linear coefficient otherwise)
+             * and outcome (linear coefficient).
+             */
+            readonly unobserved_common_cause: StructType<{
+                /** Confounder effect strengths to simulate, one new effect per entry */
+                readonly effect_strengths: ArrayType<FloatType>;
+            }>;
+        }>;
+        readonly CausalNuisanceModelType: VariantType<{
+            /** Random forest (regressor, or classifier for a discrete treatment) */
+            readonly random_forest: StructType<{
+                /** Number of trees (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Minimum samples per leaf (default 5) */
+                readonly min_samples_leaf: OptionType<IntegerType>;
+                /** Maximum tree depth (default unlimited) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+            readonly gradient_boosting: StructType<{
+                /** Number of boosting stages (default 100) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Learning rate (default 0.1) */
+                readonly learning_rate: OptionType<FloatType>;
+                /** Maximum tree depth (default 3) */
+                readonly max_depth: OptionType<IntegerType>;
+            }>;
+            /** Linear/logistic regression */
+            readonly linear: NullType;
+        }>;
+        readonly CausalDMLConfigType: StructType<{
+            /** Nuisance model for the outcome stage (default: random_forest) */
+            readonly model_y: OptionType<VariantType<{
+                /** Random forest (regressor, or classifier for a discrete treatment) */
+                readonly random_forest: StructType<{
+                    /** Number of trees (default 100) */
+                    readonly n_estimators: OptionType<IntegerType>;
+                    /** Minimum samples per leaf (default 5) */
+                    readonly min_samples_leaf: OptionType<IntegerType>;
+                    /** Maximum tree depth (default unlimited) */
+                    readonly max_depth: OptionType<IntegerType>;
+                }>;
+                /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+                readonly gradient_boosting: StructType<{
+                    /** Number of boosting stages (default 100) */
+                    readonly n_estimators: OptionType<IntegerType>;
+                    /** Learning rate (default 0.1) */
+                    readonly learning_rate: OptionType<FloatType>;
+                    /** Maximum tree depth (default 3) */
+                    readonly max_depth: OptionType<IntegerType>;
+                }>;
+                /** Linear/logistic regression */
+                readonly linear: NullType;
+            }>>;
+            /** Nuisance model for the treatment stage (default: random_forest) */
+            readonly model_t: OptionType<VariantType<{
+                /** Random forest (regressor, or classifier for a discrete treatment) */
+                readonly random_forest: StructType<{
+                    /** Number of trees (default 100) */
+                    readonly n_estimators: OptionType<IntegerType>;
+                    /** Minimum samples per leaf (default 5) */
+                    readonly min_samples_leaf: OptionType<IntegerType>;
+                    /** Maximum tree depth (default unlimited) */
+                    readonly max_depth: OptionType<IntegerType>;
+                }>;
+                /** Gradient boosting (regressor, or classifier for a discrete treatment) */
+                readonly gradient_boosting: StructType<{
+                    /** Number of boosting stages (default 100) */
+                    readonly n_estimators: OptionType<IntegerType>;
+                    /** Learning rate (default 0.1) */
+                    readonly learning_rate: OptionType<FloatType>;
+                    /** Maximum tree depth (default 3) */
+                    readonly max_depth: OptionType<IntegerType>;
+                }>;
+                /** Linear/logistic regression */
+                readonly linear: NullType;
+            }>>;
+            /** Treat the treatment as discrete/categorical (default false) */
+            readonly discrete_treatment: OptionType<BooleanType>;
+            /** Cross-fitting folds (default 2) */
+            readonly cv_folds: OptionType<IntegerType>;
+            /** Confidence level for effect/ATE intervals (default 0.95) */
+            readonly confidence_level: OptionType<FloatType>;
+            /** Random seed */
+            readonly random_state: OptionType<IntegerType>;
+        }>;
+        readonly CausalALEConfigType: StructType<{
+            /** Column names for the data matrix (one per column, in order) */
+            readonly columns: ArrayType<StringType>;
+            /** Outcome column the emulator predicts */
+            readonly outcome: StringType;
+            /** Continuous feature column to compute the ALE curve for */
+            readonly feature: StringType;
+            /** Columns holding integer category codes, one-hot encoded internally */
+            readonly categorical: OptionType<ArrayType<StringType>>;
+            /** Number of grid intervals (default 10) */
+            readonly grid_size: OptionType<IntegerType>;
+            /** Include confidence intervals (default true) */
+            readonly include_ci: OptionType<BooleanType>;
+            /** Confidence level for the CI (default 0.95) */
+            readonly confidence_level: OptionType<FloatType>;
+            /** Emulator (HistGradientBoosting) hyperparameters */
+            readonly emulator: OptionType<StructType<{
+                /** Number of boosting iterations (default 300) */
+                readonly n_estimators: OptionType<IntegerType>;
+                /** Learning rate (default 0.05) */
+                readonly learning_rate: OptionType<FloatType>;
+                /** Maximum tree depth (default unlimited) */
+                readonly max_depth: OptionType<IntegerType>;
+                /** Minimum samples per leaf (default 20; lower for small datasets) */
+                readonly min_samples_leaf: OptionType<IntegerType>;
+            }>>;
+            /** Random seed for the emulator */
+            readonly random_state: OptionType<IntegerType>;
+        }>;
+        readonly CausalDMLModelBlobType: VariantType<{
+            /** Fitted EconML LinearDML estimator */
+            readonly causal_dml: StructType<{
+                /** Serialized estimator (cloudpickle) */
+                readonly data: BlobType;
+                /** Number of effect-modifier (X) features */
+                readonly n_features_x: IntegerType;
+                /** Confidence level used for effect/ATE intervals */
+                readonly confidence_level: FloatType;
+            }>;
+        }>;
+        readonly CausalEffectResultType: StructType<{
+            /** Point estimate of the effect (outcome units per treatment unit) */
+            readonly effect: FloatType;
+            /** Bootstrap percentile confidence interval (present when bootstrap configured) */
+            readonly ci: OptionType<StructType<{
+                /** Lower bound */
+                readonly lower: FloatType;
+                /** Upper bound */
+                readonly upper: FloatType;
+            }>>;
+            /** Rows used for estimation (after trimming) */
+            readonly n_samples: IntegerType;
+            /** Treated rows used */
+            readonly n_treated: IntegerType;
+            /** Control rows used */
+            readonly n_control: IntegerType;
+        }>;
+        readonly CausalRefuteResultType: StructType<{
+            /** The original estimated effect being refuted */
+            readonly estimated_effect: FloatType;
+            /**
+             * Effect under the refutation. One entry for placebo/random-common-cause/
+             * data-subset; one entry per strength for unobserved_common_cause.
+             */
+            readonly new_effects: VectorType<FloatType>;
+            /** Refutation p-value where the refuter provides one */
+            readonly p_value: OptionType<FloatType>;
+        }>;
+        readonly CausalATEResultType: StructType<{
+            /** Average treatment effect over the given X */
+            readonly ate: FloatType;
+            /** Lower bound at the model's confidence level */
+            readonly lower: FloatType;
+            /** Upper bound at the model's confidence level */
+            readonly upper: FloatType;
+        }>;
+        readonly ALEResultType: StructType<{
+            /** Feature grid values (interval edges) */
+            readonly grid: VectorType<FloatType>;
+            /** Centered ALE effect at each grid value (outcome units) */
+            readonly effect: VectorType<FloatType>;
+            /** Lower CI at each grid value (present when include_ci) */
+            readonly lower: OptionType<VectorType<FloatType>>;
+            /** Upper CI at each grid value (present when include_ci) */
+            readonly upper: OptionType<VectorType<FloatType>>;
+            /** Number of samples in each grid interval */
+            readonly size: VectorType<IntegerType>;
+        }>;
+    };
+};
+//# sourceMappingURL=causal.d.ts.map