@elaraai/e3-ui 1.0.102 → 1.0.104

package/dist/src/experiment/types.d.ts

@@ -1,1093 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/**
- * The `Experiment` render contract.
- *
- * These types are **replicated verbatim (snake_case)** from
- * `east-py-datascience`'s `Causal.Types.*`, so the engine's `Causal.experiment`
- * result unifies **structurally** with the component's binding — replicate, don't
- * share (East type equality is structural; `e3-ui` never imports
- * `east-py-datascience`). Keep these byte-identical to the datascience
- * definitions — they are kept in sync by hand.
- *
- * The user edits an {@link ExperimentConfigType} (the staged "question + method")
- * and **Apply** runs the one bound `experiment` function, which returns an
- * {@link ExperimentResultType} — the naive vs adjusted effect, confounder
- * balance, propensity overlap, a robustness summary, and an honesty
- * {@link ExperimentVerdictType}. `adjusted` is `none` when the engine refuses.
- *
- * @packageDocumentation
- */
-import { StructType, VariantType, OptionType, ArrayType, DictType, FloatType, IntegerType, BooleanType, StringType, NullType, DateTimeType, VectorType } from '@elaraai/east';
-/** A confidence interval. */
-export declare const CiType: StructType<{
-    readonly lower: FloatType;
-    readonly upper: FloatType;
-}>;
-/** Type alias for {@link CiType}. */
-export type CiType = typeof CiType;
-/** Inverse-propensity weighting scheme. */
-export declare const WeightingSchemeType: VariantType<{
-    readonly ips_weight: NullType;
-    readonly ips_stabilized_weight: NullType;
-    readonly ips_normalized_weight: NullType;
-}>;
-/** Type alias for {@link WeightingSchemeType}. */
-export type WeightingSchemeType = typeof WeightingSchemeType;
-/** Backdoor-adjusted effect estimator. */
-export declare const EstimatorType: VariantType<{
-    readonly linear_regression: NullType;
-    readonly propensity_score_weighting: StructType<{
-        readonly weighting_scheme: OptionType<VariantType<{
-            readonly ips_weight: NullType;
-            readonly ips_stabilized_weight: NullType;
-            readonly ips_normalized_weight: NullType;
-        }>>;
-    }>;
-}>;
-/** Type alias for {@link EstimatorType}. */
-export type EstimatorType = typeof EstimatorType;
-/** Population the effect is reported for. */
-export declare const TargetUnitsType: VariantType<{
-    readonly ate: NullType;
-    readonly att: NullType;
-    readonly atc: NullType;
-}>;
-/** Type alias for {@link TargetUnitsType}. */
-export type TargetUnitsType = typeof TargetUnitsType;
-/**
- * A directional prior on the effect — the sign a domain expert expects. Drives the
- * `expected_sign` guard.
- * twin: east-py-datascience causal.ts `CausalSignType`
- */
-export declare const SignType: VariantType<{
-    readonly positive: NullType;
-    readonly negative: NullType;
-}>;
-/** Type alias for {@link SignType}. */
-export type SignType = typeof SignType;
-/** Bootstrap confidence-interval configuration. */
-export declare const BootstrapConfigType: StructType<{
-    readonly reps: IntegerType;
-    readonly cluster_column: OptionType<StringType>;
-    readonly confidence_level: OptionType<FloatType>;
-}>;
-/** Type alias for {@link BootstrapConfigType}. */
-export type BootstrapConfigType = typeof BootstrapConfigType;
-/** Which robustness checks to run. */
-export declare const RefuteSpecType: StructType<{
-    /** Permuted-treatment negative control — a real effect should vanish. */
-    readonly placebo: BooleanType;
-    /** Inject an independent random common cause — the effect should hold. */
-    readonly random_common_cause: BooleanType;
-    /** Re-estimate on random subsamples — the effect should be stable. */
-    readonly data_subset: BooleanType;
-    /** Unobserved-confounder strengths to simulate → the sensitivity / tipping curve. */
-    readonly sensitivity: OptionType<ArrayType<FloatType>>;
-}>;
-/** Type alias for {@link RefuteSpecType}. */
-export type RefuteSpecType = typeof RefuteSpecType;
-/**
- * The experiment the user framed — the staged value the pickers write and
- * **Apply** feeds to the bound `experiment` function.
- *
- * `treatment` / `outcome` / `common_causes` / `categorical` are **column names**
- * introspected from the bound dataset's row struct (the `Table` pattern). The
- * `method` / `estimand` advanced choices and the `min_*` guard thresholds are
- * optional developer-defaulted, user-adjustable knobs.
- */
-export declare const ExperimentConfigType: StructType<{
-    readonly treatment: StringType;
-    readonly outcome: StringType;
-    readonly common_causes: ArrayType<StringType>;
-    readonly categorical: OptionType<ArrayType<StringType>>;
-    readonly method: OptionType<VariantType<{
-        readonly linear_regression: NullType;
-        readonly propensity_score_weighting: StructType<{
-            readonly weighting_scheme: OptionType<VariantType<{
-                readonly ips_weight: NullType;
-                readonly ips_stabilized_weight: NullType;
-                readonly ips_normalized_weight: NullType;
-            }>>;
-        }>;
-    }>>;
-    readonly estimand: OptionType<VariantType<{
-        readonly ate: NullType;
-        readonly att: NullType;
-        readonly atc: NullType;
-    }>>;
-    readonly refute: OptionType<StructType<{
-        /** Permuted-treatment negative control — a real effect should vanish. */
-        readonly placebo: BooleanType;
-        /** Inject an independent random common cause — the effect should hold. */
-        readonly random_common_cause: BooleanType;
-        /** Re-estimate on random subsamples — the effect should be stable. */
-        readonly data_subset: BooleanType;
-        /** Unobserved-confounder strengths to simulate → the sensitivity / tipping curve. */
-        readonly sensitivity: OptionType<ArrayType<FloatType>>;
-    }>>;
-    /** Continuous column for the ALE dose-response curve (the "How much?" view). */
-    readonly dose_feature: OptionType<StringType>;
-    readonly min_overlap: OptionType<FloatType>;
-    readonly min_treatment_variation: OptionType<FloatType>;
-    readonly bootstrap: OptionType<StructType<{
-        readonly reps: IntegerType;
-        readonly cluster_column: OptionType<StringType>;
-        readonly confidence_level: OptionType<FloatType>;
-    }>>;
-    readonly random_state: OptionType<IntegerType>;
-    /** Graded-overlap threshold — common support below this keeps `causal` from the
-     *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
-    readonly strong_overlap: OptionType<FloatType>;
-    /** Robustness floor — a `causal` verdict whose E-value is below this is downgraded to
-     *  `modest`. Off by default. (E-value is a monotone transform of the standardized effect.) */
-    readonly evalue_floor: OptionType<FloatType>;
-    /** Directional prior — a material, CI-clear effect of the opposite sign is flagged
-     *  (`expected_sign_ok = some(false)`, verdict `adjustment_insufficient`). Off by default. */
-    readonly expected_sign: OptionType<VariantType<{
-        readonly positive: NullType;
-        readonly negative: NullType;
-    }>>;
-}>;
-/** Type alias for {@link ExperimentConfigType}. */
-export type ExperimentConfigType = typeof ExperimentConfigType;
-/** One confounder's before-adjustment imbalance (categoricals → one row per level). */
-export declare const BalanceRowType: StructType<{
-    readonly column: StringType;
-    /** The original confounder this row belongs to — equals `column` for a numeric
-     *  confounder; the base confounder for a one-hot categorical level. */
-    readonly base_column: StringType;
-    readonly treated_mean: FloatType;
-    readonly control_mean: FloatType;
-    readonly std_diff: FloatType;
-    /** Post-adjustment SMD (weighted means, same pooled-sd denominator) — proof the
-     *  adjustment closed the gap. `some` only for the propensity estimator with
-     *  computable scores.
-     *  twin: east-py-datascience BalanceRowType.std_diff_adjusted */
-    readonly std_diff_adjusted: OptionType<FloatType>;
-}>;
-/** Type alias for {@link BalanceRowType}. */
-export type BalanceRowType = typeof BalanceRowType;
-/** One observed confounder placed on the sensitivity strengths axis — the simulated
- *  strength whose effect-shift equals the shift from omitting that confounder, so
- *  "tips at 0.9" reads as "a hidden cause as strong as `column`".
- *  twin: east-py-datascience `SensitivityBenchmarkType` */
-export declare const SensitivityBenchmarkType: StructType<{
-    readonly column: StringType;
-    readonly strength: FloatType;
-}>;
-/** Type alias for {@link SensitivityBenchmarkType}. */
-export type SensitivityBenchmarkType = typeof SensitivityBenchmarkType;
-/**
- * Graded common-support tier — `refused` (below `min_overlap`), `thin` (clears the
- * refuse gate but below `strong_overlap`), `strong` (≥ `strong_overlap`). Vacuously
- * `strong` with no confounders.
- * twin: east-py-datascience causal.ts `SupportStrengthType`
- */
-export declare const SupportStrengthType: VariantType<{
-    readonly refused: NullType;
-    readonly thin: NullType;
-    readonly strong: NullType;
-}>;
-/** Type alias for {@link SupportStrengthType}. */
-export type SupportStrengthType = typeof SupportStrengthType;
-/** Positivity / common-support diagnostic (binary treatment). */
-export declare const OverlapDiagnosticType: StructType<{
-    readonly treated_propensity: VectorType<FloatType>;
-    readonly control_propensity: VectorType<FloatType>;
-    readonly common_support_frac: FloatType;
-    /** Clears the **refuse** gate `min_overlap` — NOT a quality signal (true at the
-     *  default 0.10 gate still means barely-overlapping). Read `support_strength`. */
-    readonly positivity_ok: BooleanType;
-    /** Graded common-support tier (`refused` / `thin` / `strong`).
-     *  twin: datascience OverlapDiagnosticType.support_strength */
-    readonly support_strength: VariantType<{
-        readonly refused: NullType;
-        readonly thin: NullType;
-        readonly strong: NullType;
-    }>;
-}>;
-/** Type alias for {@link OverlapDiagnosticType}. */
-export type OverlapDiagnosticType = typeof OverlapDiagnosticType;
-/** The unobserved-confounder sensitivity (tipping) curve — effect at each simulated strength. */
-export declare const SensitivityCurveType: StructType<{
-    readonly strengths: VectorType<FloatType>;
-    readonly effects: VectorType<FloatType>;
-    /** Observed-confounder benchmarks on the SAME strengths axis (empty when none is
-     *  computable) — lets the surface say "survives a hidden cause as strong as
-     *  `incoming_grade`". Clamped to the last simulated strength. */
-    readonly benchmarks: ArrayType<StructType<{
-        readonly column: StringType;
-        readonly strength: FloatType;
-    }>>;
-}>;
-/** Type alias for {@link SensitivityCurveType}. */
-export type SensitivityCurveType = typeof SensitivityCurveType;
-/** The robustness summary the verdict + trust tab consume. */
-export declare const RefutationType: StructType<{
-    /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
-    readonly placebo_effect: OptionType<FloatType>;
-    /** Whether the placebo effect vanished. */
-    readonly placebo_passes: OptionType<BooleanType>;
-    /** Whether a decoy random common cause left the estimate inside its CI. */
-    readonly random_cc_within_ci: OptionType<BooleanType>;
-    /** Mean effect across data subsamples (stability). */
-    readonly data_subset_effect: OptionType<FloatType>;
-    /** Std of the effect across data subsamples. */
-    readonly data_subset_std: OptionType<FloatType>;
-    /** Closed-form E-value (risk-ratio scale) — confounder strength needed to explain the
-     *  effect away. A monotone transform of the standardized effect (not independent of it). */
-    readonly robustness_value: OptionType<FloatType>;
-    /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
-    readonly sensitivity: OptionType<StructType<{
-        readonly strengths: VectorType<FloatType>;
-        readonly effects: VectorType<FloatType>;
-        /** Observed-confounder benchmarks on the SAME strengths axis (empty when none is
-         *  computable) — lets the surface say "survives a hidden cause as strong as
-         *  `incoming_grade`". Clamped to the last simulated strength. */
-        readonly benchmarks: ArrayType<StructType<{
-            readonly column: StringType;
-            readonly strength: FloatType;
-        }>>;
-    }>>;
-    /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a material
-     *  effect matches the expected direction, `some(false)` if it points the other way,
-     *  `none` when no prior or the effect is near-zero.
-     *  twin: datascience RefutationType.expected_sign_ok */
-    readonly expected_sign_ok: OptionType<BooleanType>;
-}>;
-/** Type alias for {@link RefutationType}. */
-export type RefutationType = typeof RefutationType;
-/** A dose-response (ALE) curve of a continuous feature on the outcome. */
-export declare const DoseResponseType: StructType<{
-    readonly feature: StringType;
-    readonly grid: VectorType<FloatType>;
-    readonly effect: VectorType<FloatType>;
-    readonly lower: OptionType<VectorType<FloatType>>;
-    readonly upper: OptionType<VectorType<FloatType>>;
-    /** Rows per dose bin — drives the surface's "you are here" (busiest bin) marker. */
-    readonly size: VectorType<IntegerType>;
-}>;
-/** Type alias for {@link DoseResponseType}. */
-export type DoseResponseType = typeof DoseResponseType;
-/**
- * The honesty verdict — a thin tag; the numbers live top-level on the result.
- * Only `not_estimable` carries a human-readable reason.
- */
-export declare const ExperimentVerdictType: VariantType<{
-    readonly causal: NullType;
-    readonly modest: NullType;
-    readonly adjustment_insufficient: NullType;
-    readonly non_identifiable_positivity: NullType;
-    readonly not_estimable: StringType;
-}>;
-/** Type alias for {@link ExperimentVerdictType}. */
-export type ExperimentVerdictType = typeof ExperimentVerdictType;
-/**
- * Machine-readable reason a verdict fell short of `causal` — every FAILING gate
- * (the verdict tag is chosen by severity precedence, but explaining "why modest?"
- * needs all of them). Empty for `causal` and for the two refusal verdicts.
- * twin: east-py-datascience `VerdictReasonType`
- */
-export declare const VerdictReasonType: VariantType<{
-    /** The placebo (shuffle) refuter didn't collapse to ~0. */
-    readonly placebo_failed: NullType;
-    /** |effect| below the materiality band (0.10 × outcome_sd). */
-    readonly not_material: NullType;
-    /** The adjusted CI straddles zero. */
-    readonly ci_spans_zero: NullType;
-    /** Material + CI-clear but pointing against `config.expected_sign`. */
-    readonly wrong_sign: NullType;
-    /** Common support cleared the refuse gate but is below `strong_overlap`. */
-    readonly thin_support: NullType;
-    /** E-value below the (opt-in) `evalue_floor`. */
-    readonly low_robustness: NullType;
-}>;
-/** Type alias for {@link VerdictReasonType}. */
-export type VerdictReasonType = typeof VerdictReasonType;
-/** The adjusted (like-for-like) effect + its CI — `none` on the result when the engine refuses. */
-export declare const AdjustedEffectType: StructType<{
-    readonly effect: FloatType;
-    readonly ci: OptionType<StructType<{
-        readonly lower: FloatType;
-        readonly upper: FloatType;
-    }>>;
-}>;
-/** Type alias for {@link AdjustedEffectType}. */
-export type AdjustedEffectType = typeof AdjustedEffectType;
-/**
- * The complete, honest result. `adjusted` is `none` when the engine refuses
- * (positivity / no-variation); the `verdict` tag carries the headline; every
- * word/colour on the surface is derived from these numbers.
- */
-export declare const ExperimentResultType: StructType<{
-    readonly naive: FloatType;
-    readonly naive_ci: OptionType<StructType<{
-        readonly lower: FloatType;
-        readonly upper: FloatType;
-    }>>;
-    readonly adjusted: OptionType<StructType<{
-        readonly effect: FloatType;
-        readonly ci: OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-    }>>;
-    readonly n_total: IntegerType;
-    readonly n_treated: IntegerType;
-    readonly n_control: IntegerType;
-    /** Rows OUTSIDE the propensity common support — units with no like-for-like
-     *  counterpart on the other side. Display-only; nothing is dropped. */
-    readonly n_dropped: IntegerType;
-    readonly balance: ArrayType<StructType<{
-        readonly column: StringType;
-        /** The original confounder this row belongs to — equals `column` for a numeric
-         *  confounder; the base confounder for a one-hot categorical level. */
-        readonly base_column: StringType;
-        readonly treated_mean: FloatType;
-        readonly control_mean: FloatType;
-        readonly std_diff: FloatType;
-        /** Post-adjustment SMD (weighted means, same pooled-sd denominator) — proof the
-         *  adjustment closed the gap. `some` only for the propensity estimator with
-         *  computable scores.
-         *  twin: east-py-datascience BalanceRowType.std_diff_adjusted */
-        readonly std_diff_adjusted: OptionType<FloatType>;
-    }>>;
-    readonly overlap: StructType<{
-        readonly treated_propensity: VectorType<FloatType>;
-        readonly control_propensity: VectorType<FloatType>;
-        readonly common_support_frac: FloatType;
-        /** Clears the **refuse** gate `min_overlap` — NOT a quality signal (true at the
-         *  default 0.10 gate still means barely-overlapping). Read `support_strength`. */
-        readonly positivity_ok: BooleanType;
-        /** Graded common-support tier (`refused` / `thin` / `strong`).
-         *  twin: datascience OverlapDiagnosticType.support_strength */
-        readonly support_strength: VariantType<{
-            readonly refused: NullType;
-            readonly thin: NullType;
-            readonly strong: NullType;
-        }>;
-    }>;
-    readonly refutation: OptionType<StructType<{
-        /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
-        readonly placebo_effect: OptionType<FloatType>;
-        /** Whether the placebo effect vanished. */
-        readonly placebo_passes: OptionType<BooleanType>;
-        /** Whether a decoy random common cause left the estimate inside its CI. */
-        readonly random_cc_within_ci: OptionType<BooleanType>;
-        /** Mean effect across data subsamples (stability). */
-        readonly data_subset_effect: OptionType<FloatType>;
-        /** Std of the effect across data subsamples. */
-        readonly data_subset_std: OptionType<FloatType>;
-        /** Closed-form E-value (risk-ratio scale) — confounder strength needed to explain the
-         *  effect away. A monotone transform of the standardized effect (not independent of it). */
-        readonly robustness_value: OptionType<FloatType>;
-        /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
-        readonly sensitivity: OptionType<StructType<{
-            readonly strengths: VectorType<FloatType>;
-            readonly effects: VectorType<FloatType>;
-            /** Observed-confounder benchmarks on the SAME strengths axis (empty when none is
-             *  computable) — lets the surface say "survives a hidden cause as strong as
-             *  `incoming_grade`". Clamped to the last simulated strength. */
-            readonly benchmarks: ArrayType<StructType<{
-                readonly column: StringType;
-                readonly strength: FloatType;
-            }>>;
-        }>>;
-        /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a material
-         *  effect matches the expected direction, `some(false)` if it points the other way,
-         *  `none` when no prior or the effect is near-zero.
-         *  twin: datascience RefutationType.expected_sign_ok */
-        readonly expected_sign_ok: OptionType<BooleanType>;
-    }>>;
-    /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
-    readonly dose_response: OptionType<StructType<{
-        readonly feature: StringType;
-        readonly grid: VectorType<FloatType>;
-        readonly effect: VectorType<FloatType>;
-        readonly lower: OptionType<VectorType<FloatType>>;
-        readonly upper: OptionType<VectorType<FloatType>>;
-        /** Rows per dose bin — drives the surface's "you are here" (busiest bin) marker. */
-        readonly size: VectorType<IntegerType>;
-    }>>;
-    readonly verdict: VariantType<{
-        readonly causal: NullType;
-        readonly modest: NullType;
-        readonly adjustment_insufficient: NullType;
-        readonly non_identifiable_positivity: NullType;
-        readonly not_estimable: StringType;
-    }>;
-    /** Why the verdict fell short of `causal` — every failing gate (empty for
-     *  `causal` and for the refusals, where the tag itself is the reason). */
-    readonly verdict_reasons: ArrayType<VariantType<{
-        /** The placebo (shuffle) refuter didn't collapse to ~0. */
-        readonly placebo_failed: NullType;
-        /** |effect| below the materiality band (0.10 × outcome_sd). */
-        readonly not_material: NullType;
-        /** The adjusted CI straddles zero. */
-        readonly ci_spans_zero: NullType;
-        /** Material + CI-clear but pointing against `config.expected_sign`. */
-        readonly wrong_sign: NullType;
-        /** Common support cleared the refuse gate but is below `strong_overlap`. */
-        readonly thin_support: NullType;
-        /** E-value below the (opt-in) `evalue_floor`. */
-        readonly low_robustness: NullType;
-    }>>;
-    /** The outcome's standard deviation — the scale the materiality band is on. */
-    readonly outcome_sd: FloatType;
-    /** The materiality band the verdict applied (0.10 × outcome_sd), echoed so the
-     *  surface can say "smaller than what would matter here (±x)". */
-    readonly materiality_threshold: FloatType;
-    /** Raw outcome mean of the treated arm (`none` when the arm is empty). */
-    readonly treated_outcome_mean: OptionType<FloatType>;
-    /** Raw outcome mean of the control arm (`none` when the arm is empty). */
-    readonly control_outcome_mean: OptionType<FloatType>;
-}>;
-/** Type alias for {@link ExperimentResultType}. */
-export type ExperimentResultType = typeof ExperimentResultType;
-/**
- * Why the trial is sized the way it is — set from the verdict, so the tab's
- * headline + visuals change with the result rather than reading the same twice.
- */
-export declare const DesignBasisType: VariantType<{
-    /** Clear effect → power the trial to detect the *observed* effect. */
-    readonly detect_observed: NullType;
-    /** Fuzzy / maybe-nothing → power to the smallest effect worth acting on. */
-    readonly resolve_vs_null: NullType;
-    /** A trust check failed → randomise to remove the bias adjustment couldn't. */
-    readonly de_bias: NullType;
-    /** No overlap → randomise within the comparable range. */
-    readonly restrict_to_overlap: NullType;
-    /** No control group exists → hold back a random sample next time. */
-    readonly create_control: NullType;
-}>;
-/** Type alias for {@link DesignBasisType}. */
-export type DesignBasisType = typeof DesignBasisType;
-/** One sizing option — a split and the head-count it needs (even split first). */
-export declare const TrialOptionType: StructType<{
-    /** Plain label, e.g. "Even split" / "Treat fewer". */
-    readonly label: StringType;
-    /** Fraction assigned to the treatment (0..1; 0.5 = even). */
-    readonly treated_share: FloatType;
-    readonly n_treated: IntegerType;
-    readonly n_control: IntegerType;
-    readonly n_total: IntegerType;
-}>;
-/** Type alias for {@link TrialOptionType}. */
-export type TrialOptionType = typeof TrialOptionType;
-/** The "chance of detecting it" curve — total head-count → power (0..1). */
-export declare const PowerCurveType: StructType<{
-    readonly n: VectorType<IntegerType>;
-    readonly power: VectorType<FloatType>;
-}>;
-/** Type alias for {@link PowerCurveType}. */
-export type PowerCurveType = typeof PowerCurveType;
-/**
- * The validation-trial recipe — a randomised controlled trial sized from the
- * observed effect (or the materiality threshold) and the outcome spread, with
- * the groups matched on the confounders that were most imbalanced. Everything
- * the "Validate" tab paints is derived from these fields.
- */
-export declare const ExperimentDesignType: StructType<{
-    /** The verdict that drove the recommendation (echoed for framing). */
-    readonly verdict: VariantType<{
-        readonly causal: NullType;
-        readonly modest: NullType;
-        readonly adjustment_insufficient: NullType;
-        readonly non_identifiable_positivity: NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly basis: VariantType<{
-        /** Clear effect → power the trial to detect the *observed* effect. */
-        readonly detect_observed: NullType;
-        /** Fuzzy / maybe-nothing → power to the smallest effect worth acting on. */
-        readonly resolve_vs_null: NullType;
-        /** A trust check failed → randomise to remove the bias adjustment couldn't. */
-        readonly de_bias: NullType;
-        /** No overlap → randomise within the comparable range. */
-        readonly restrict_to_overlap: NullType;
-        /** No control group exists → hold back a random sample next time. */
-        readonly create_control: NullType;
-    }>;
-    /** The effect size the trial is powered to detect (observed, or materiality). */
-    readonly target_effect: FloatType;
-    /** Outcome spread (pooled SD) used to size it. */
-    readonly outcome_sd: FloatType;
-    readonly target_power: FloatType;
-    readonly alpha: FloatType;
-    /** Chance the CURRENT sample would already detect `target_effect` (the "you're here" marker); `none` when there's no comparison group. */
-    readonly current_power: OptionType<FloatType>;
-    /** Categories both groups must be matched on (the most-imbalanced confounders). */
-    readonly match_on: ArrayType<StringType>;
-    /** Ranked split options (even split first; cost-saving alternates). */
-    readonly options: ArrayType<StructType<{
-        /** Plain label, e.g. "Even split" / "Treat fewer". */
-        readonly label: StringType;
-        /** Fraction assigned to the treatment (0..1; 0.5 = even). */
-        readonly treated_share: FloatType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_total: IntegerType;
-    }>>;
-    /** The detect-chance curve for the chart. */
-    readonly power_curve: StructType<{
-        readonly n: VectorType<IntegerType>;
-        readonly power: VectorType<FloatType>;
-    }>;
-    /** One generated, plain-language sentence framing the recipe. */
-    readonly rationale: StringType;
-}>;
-/** Type alias for {@link ExperimentDesignType}. */
-export type ExperimentDesignType = typeof ExperimentDesignType;
-/** Optional knobs `Causal.designValidation` accepts (all developer-defaulted). */
-export declare const DesignConfigType: StructType<{
-    /** Significance level (default 0.05). */
-    readonly alpha: OptionType<FloatType>;
-    /** Target chance of detecting the effect (default 0.8). */
-    readonly target_power: OptionType<FloatType>;
-    /** Smallest effect worth acting on — sizes the trial to this when set / when there's no trustworthy observed effect. */
-    readonly materiality: OptionType<FloatType>;
-    /** Treatment shares to offer as options (default [0.5]). */
-    readonly treated_shares: OptionType<ArrayType<FloatType>>;
-}>;
-/** Type alias for {@link DesignConfigType}. */
-export type DesignConfigType = typeof DesignConfigType;
-/**
- * The UI-side population filter — a set of {@link Slice} predicates the Step-4
- * rail edits. It narrows the rows **client-side, before** the `experiment` call,
- * so it is deliberately **not** a field of {@link ExperimentConfigType} (the
- * bound function never sees it; the config stays byte-identical to the causal
- * library's contract). Bound as its own optional staged dataset so a surface can
- * seed / persist / commit the framing filters.
- */
-export declare const PopulationType: ArrayType<VariantType<{
-    readonly string: import("@elaraai/east").StructType<{
-        readonly fieldId: import("@elaraai/east").StringType;
-        readonly op: import("@elaraai/east").VariantType<{
-            readonly eq: import("@elaraai/east").StringType;
-            readonly neq: import("@elaraai/east").StringType;
-            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-            readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-            readonly contains: import("@elaraai/east").StringType;
-            readonly matches: import("@elaraai/east").StringType;
-            readonly startsWith: import("@elaraai/east").StringType;
-            readonly endsWith: import("@elaraai/east").StringType;
-            readonly isEmpty: import("@elaraai/east").NullType;
-            readonly isNotEmpty: import("@elaraai/east").NullType;
-        }>;
-    }>;
-    readonly integer: import("@elaraai/east").StructType<{
-        readonly fieldId: import("@elaraai/east").StringType;
-        readonly op: import("@elaraai/east").VariantType<{
-            readonly eq: import("@elaraai/east").IntegerType;
-            readonly neq: import("@elaraai/east").IntegerType;
-            readonly lt: import("@elaraai/east").IntegerType;
-            readonly lte: import("@elaraai/east").IntegerType;
-            readonly gt: import("@elaraai/east").IntegerType;
-            readonly gte: import("@elaraai/east").IntegerType;
-            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-        }>;
-    }>;
-    readonly float: import("@elaraai/east").StructType<{
-        readonly fieldId: import("@elaraai/east").StringType;
-        readonly op: import("@elaraai/east").VariantType<{
-            readonly lt: import("@elaraai/east").FloatType;
-            readonly lte: import("@elaraai/east").FloatType;
-            readonly gt: import("@elaraai/east").FloatType;
-            readonly gte: import("@elaraai/east").FloatType;
-        }>;
-    }>;
-    readonly datetime: import("@elaraai/east").StructType<{
-        readonly fieldId: import("@elaraai/east").StringType;
-        readonly op: import("@elaraai/east").VariantType<{
-            readonly before: import("@elaraai/east").DateTimeType;
-            readonly after: import("@elaraai/east").DateTimeType;
-            readonly between: import("@elaraai/east").StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-        }>;
-    }>;
-    readonly boolean: import("@elaraai/east").StructType<{
-        readonly fieldId: import("@elaraai/east").StringType;
-        readonly op: import("@elaraai/east").VariantType<{
-            readonly is: import("@elaraai/east").BooleanType;
-        }>;
-    }>;
-}>>;
-/** Type alias for {@link PopulationType}. */
-export type PopulationType = typeof PopulationType;
-/**
- * One developer-authored, vetted experiment configuration — a named question whose
- * `spec` is loaded into the working config (and whose optional `population` sets the
- * scope) when it is selected from the surface's question selector. A committed result
- * records the originating configuration by `id`.
- *
- * A configuration bundles the **vetted backdoor set + scope** so a non-expert can pick a
- * correct causal question from a menu rather than assemble one. `spec` is a full
- * {@link ExperimentConfigType} (column names are plain strings); `population` is the
- * optional Step-4 scope (`none` ⇒ no scope); `group` sections the selector. An entry may
- * also carry a precomputed `result`/`design` so the surface paints an answer with no live
- * call.
- */
-export declare const ConfigurationType: StructType<{
-    /** Stable key — the journal records THIS (not `label`), and it drives selection
-     *  identity, so a renamed `label` never orphans a committed row. */
-    readonly id: StringType;
-    /** Display title shown in the question selector. */
-    readonly label: StringType;
-    /** The causal question — the vetted, pre-baked {@link ExperimentConfigType} this
-     *  entry frames (loaded into the working config when selected). */
-    readonly spec: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: OptionType<ArrayType<StringType>>;
-        readonly method: OptionType<VariantType<{
-            readonly linear_regression: NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: OptionType<VariantType<{
-                    readonly ips_weight: NullType;
-                    readonly ips_stabilized_weight: NullType;
-                    readonly ips_normalized_weight: NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: OptionType<VariantType<{
-            readonly ate: NullType;
-            readonly att: NullType;
-            readonly atc: NullType;
-        }>>;
-        readonly refute: OptionType<StructType<{
-            /** Permuted-treatment negative control — a real effect should vanish. */
-            readonly placebo: BooleanType;
-            /** Inject an independent random common cause — the effect should hold. */
-            readonly random_common_cause: BooleanType;
-            /** Re-estimate on random subsamples — the effect should be stable. */
-            readonly data_subset: BooleanType;
-            /** Unobserved-confounder strengths to simulate → the sensitivity / tipping curve. */
-            readonly sensitivity: OptionType<ArrayType<FloatType>>;
-        }>>;
-        /** Continuous column for the ALE dose-response curve (the "How much?" view). */
-        readonly dose_feature: OptionType<StringType>;
-        readonly min_overlap: OptionType<FloatType>;
-        readonly min_treatment_variation: OptionType<FloatType>;
-        readonly bootstrap: OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: OptionType<StringType>;
-            readonly confidence_level: OptionType<FloatType>;
-        }>>;
-        readonly random_state: OptionType<IntegerType>;
-        /** Graded-overlap threshold — common support below this keeps `causal` from the
-         *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
-        readonly strong_overlap: OptionType<FloatType>;
-        /** Robustness floor — a `causal` verdict whose E-value is below this is downgraded to
-         *  `modest`. Off by default. (E-value is a monotone transform of the standardized effect.) */
-        readonly evalue_floor: OptionType<FloatType>;
-        /** Directional prior — a material, CI-clear effect of the opposite sign is flagged
-         *  (`expected_sign_ok = some(false)`, verdict `adjustment_insufficient`). Off by default. */
-        readonly expected_sign: OptionType<VariantType<{
-            readonly positive: NullType;
-            readonly negative: NullType;
-        }>>;
-    }>;
-    /** Optional population scope to apply on select; `none` ⇒ no scope. */
-    readonly population: OptionType<ArrayType<VariantType<{
-        readonly string: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").StringType;
-                readonly neq: import("@elaraai/east").StringType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly contains: import("@elaraai/east").StringType;
-                readonly matches: import("@elaraai/east").StringType;
-                readonly startsWith: import("@elaraai/east").StringType;
-                readonly endsWith: import("@elaraai/east").StringType;
-                readonly isEmpty: import("@elaraai/east").NullType;
-                readonly isNotEmpty: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly integer: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").IntegerType;
-                readonly neq: import("@elaraai/east").IntegerType;
-                readonly lt: import("@elaraai/east").IntegerType;
-                readonly lte: import("@elaraai/east").IntegerType;
-                readonly gt: import("@elaraai/east").IntegerType;
-                readonly gte: import("@elaraai/east").IntegerType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-            }>;
-        }>;
-        readonly float: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly lt: import("@elaraai/east").FloatType;
-                readonly lte: import("@elaraai/east").FloatType;
-                readonly gt: import("@elaraai/east").FloatType;
-                readonly gte: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        readonly datetime: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>>;
-    /** Optional section header — entries sharing a `group` are bucketed together. */
-    readonly group: OptionType<StringType>;
-    /** Optional precomputed answer for this question (e.g. a dataflow task ran
-     *  `Causal.experiment` once). `none` ⇒ compute live via the `experiment` function. */
-    readonly result: OptionType<StructType<{
-        readonly naive: FloatType;
-        readonly naive_ci: OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-        readonly adjusted: OptionType<StructType<{
-            readonly effect: FloatType;
-            readonly ci: OptionType<StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>>;
-        }>>;
-        readonly n_total: IntegerType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        /** Rows OUTSIDE the propensity common support — units with no like-for-like
-         *  counterpart on the other side. Display-only; nothing is dropped. */
-        readonly n_dropped: IntegerType;
-        readonly balance: ArrayType<StructType<{
-            readonly column: StringType;
-            /** The original confounder this row belongs to — equals `column` for a numeric
-             *  confounder; the base confounder for a one-hot categorical level. */
-            readonly base_column: StringType;
-            readonly treated_mean: FloatType;
-            readonly control_mean: FloatType;
-            readonly std_diff: FloatType;
-            /** Post-adjustment SMD (weighted means, same pooled-sd denominator) — proof the
-             *  adjustment closed the gap. `some` only for the propensity estimator with
-             *  computable scores.
-             *  twin: east-py-datascience BalanceRowType.std_diff_adjusted */
-            readonly std_diff_adjusted: OptionType<FloatType>;
-        }>>;
-        readonly overlap: StructType<{
-            readonly treated_propensity: VectorType<FloatType>;
-            readonly control_propensity: VectorType<FloatType>;
-            readonly common_support_frac: FloatType;
-            /** Clears the **refuse** gate `min_overlap` — NOT a quality signal (true at the
-             *  default 0.10 gate still means barely-overlapping). Read `support_strength`. */
-            readonly positivity_ok: BooleanType;
-            /** Graded common-support tier (`refused` / `thin` / `strong`).
-             *  twin: datascience OverlapDiagnosticType.support_strength */
-            readonly support_strength: VariantType<{
-                readonly refused: NullType;
-                readonly thin: NullType;
-                readonly strong: NullType;
-            }>;
-        }>;
-        readonly refutation: OptionType<StructType<{
-            /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
-            readonly placebo_effect: OptionType<FloatType>;
-            /** Whether the placebo effect vanished. */
-            readonly placebo_passes: OptionType<BooleanType>;
-            /** Whether a decoy random common cause left the estimate inside its CI. */
-            readonly random_cc_within_ci: OptionType<BooleanType>;
-            /** Mean effect across data subsamples (stability). */
-            readonly data_subset_effect: OptionType<FloatType>;
-            /** Std of the effect across data subsamples. */
-            readonly data_subset_std: OptionType<FloatType>;
-            /** Closed-form E-value (risk-ratio scale) — confounder strength needed to explain the
-             *  effect away. A monotone transform of the standardized effect (not independent of it). */
-            readonly robustness_value: OptionType<FloatType>;
-            /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
-            readonly sensitivity: OptionType<StructType<{
-                readonly strengths: VectorType<FloatType>;
-                readonly effects: VectorType<FloatType>;
-                /** Observed-confounder benchmarks on the SAME strengths axis (empty when none is
-                 *  computable) — lets the surface say "survives a hidden cause as strong as
-                 *  `incoming_grade`". Clamped to the last simulated strength. */
-                readonly benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: FloatType;
-                }>>;
-            }>>;
-            /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a material
-             *  effect matches the expected direction, `some(false)` if it points the other way,
-             *  `none` when no prior or the effect is near-zero.
-             *  twin: datascience RefutationType.expected_sign_ok */
-            readonly expected_sign_ok: OptionType<BooleanType>;
-        }>>;
-        /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
-        readonly dose_response: OptionType<StructType<{
-            readonly feature: StringType;
-            readonly grid: VectorType<FloatType>;
-            readonly effect: VectorType<FloatType>;
-            readonly lower: OptionType<VectorType<FloatType>>;
-            readonly upper: OptionType<VectorType<FloatType>>;
-            /** Rows per dose bin — drives the surface's "you are here" (busiest bin) marker. */
-            readonly size: VectorType<IntegerType>;
-        }>>;
-        readonly verdict: VariantType<{
-            readonly causal: NullType;
-            readonly modest: NullType;
-            readonly adjustment_insufficient: NullType;
-            readonly non_identifiable_positivity: NullType;
-            readonly not_estimable: StringType;
-        }>;
-        /** Why the verdict fell short of `causal` — every failing gate (empty for
-         *  `causal` and for the refusals, where the tag itself is the reason). */
-        readonly verdict_reasons: ArrayType<VariantType<{
-            /** The placebo (shuffle) refuter didn't collapse to ~0. */
-            readonly placebo_failed: NullType;
-            /** |effect| below the materiality band (0.10 × outcome_sd). */
-            readonly not_material: NullType;
-            /** The adjusted CI straddles zero. */
-            readonly ci_spans_zero: NullType;
-            /** Material + CI-clear but pointing against `config.expected_sign`. */
-            readonly wrong_sign: NullType;
-            /** Common support cleared the refuse gate but is below `strong_overlap`. */
-            readonly thin_support: NullType;
-            /** E-value below the (opt-in) `evalue_floor`. */
-            readonly low_robustness: NullType;
-        }>>;
-        /** The outcome's standard deviation — the scale the materiality band is on. */
-        readonly outcome_sd: FloatType;
-        /** The materiality band the verdict applied (0.10 × outcome_sd), echoed so the
-         *  surface can say "smaller than what would matter here (±x)". */
-        readonly materiality_threshold: FloatType;
-        /** Raw outcome mean of the treated arm (`none` when the arm is empty). */
-        readonly treated_outcome_mean: OptionType<FloatType>;
-        /** Raw outcome mean of the control arm (`none` when the arm is empty). */
-        readonly control_outcome_mean: OptionType<FloatType>;
-    }>>;
-    /** Optional precomputed "Validate" recipe ({@link ExperimentDesignType}) for this
-     *  question; `none` ⇒ compute live via the `design` function (if bound). */
-    readonly design: OptionType<StructType<{
-        /** The verdict that drove the recommendation (echoed for framing). */
-        readonly verdict: VariantType<{
-            readonly causal: NullType;
-            readonly modest: NullType;
-            readonly adjustment_insufficient: NullType;
-            readonly non_identifiable_positivity: NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly basis: VariantType<{
-            /** Clear effect → power the trial to detect the *observed* effect. */
-            readonly detect_observed: NullType;
-            /** Fuzzy / maybe-nothing → power to the smallest effect worth acting on. */
-            readonly resolve_vs_null: NullType;
-            /** A trust check failed → randomise to remove the bias adjustment couldn't. */
-            readonly de_bias: NullType;
-            /** No overlap → randomise within the comparable range. */
-            readonly restrict_to_overlap: NullType;
-            /** No control group exists → hold back a random sample next time. */
-            readonly create_control: NullType;
-        }>;
-        /** The effect size the trial is powered to detect (observed, or materiality). */
-        readonly target_effect: FloatType;
-        /** Outcome spread (pooled SD) used to size it. */
-        readonly outcome_sd: FloatType;
-        readonly target_power: FloatType;
-        readonly alpha: FloatType;
-        /** Chance the CURRENT sample would already detect `target_effect` (the "you're here" marker); `none` when there's no comparison group. */
-        readonly current_power: OptionType<FloatType>;
-        /** Categories both groups must be matched on (the most-imbalanced confounders). */
-        readonly match_on: ArrayType<StringType>;
-        /** Ranked split options (even split first; cost-saving alternates). */
-        readonly options: ArrayType<StructType<{
-            /** Plain label, e.g. "Even split" / "Treat fewer". */
-            readonly label: StringType;
-            /** Fraction assigned to the treatment (0..1; 0.5 = even). */
-            readonly treated_share: FloatType;
-            readonly n_treated: IntegerType;
-            readonly n_control: IntegerType;
-            readonly n_total: IntegerType;
-        }>>;
-        /** The detect-chance curve for the chart. */
-        readonly power_curve: StructType<{
-            readonly n: VectorType<IntegerType>;
-            readonly power: VectorType<FloatType>;
-        }>;
-        /** One generated, plain-language sentence framing the recipe. */
-        readonly rationale: StringType;
-    }>>;
-}>;
-/** Type alias for {@link ConfigurationType}. */
-export type ConfigurationType = typeof ConfigurationType;
-/**
- * Optional per-column display metadata the developer supplies once. Keyed by
- * column name. Lets the derived prose read "worse" instead of "lower" and show
- * friendly labels / units.
- */
-export declare const ColumnMetaType: DictType<StringType, StructType<{
-    readonly label: OptionType<StringType>;
-    readonly unit: OptionType<StringType>;
-    readonly higherIsBetter: OptionType<BooleanType>;
-}>>;
-/** Type alias for {@link ColumnMetaType}. */
-export type ColumnMetaType = typeof ColumnMetaType;
-/**
- * A committed experiment in the journal — the framed config + the verdict +
- * headline effect + who committed it when. The renderer derives the verdict
- * words and colour from `verdict` / `adjusted`.
- */
-export declare const JournalRowType: StructType<{
-    readonly config: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: OptionType<ArrayType<StringType>>;
-        readonly method: OptionType<VariantType<{
-            readonly linear_regression: NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: OptionType<VariantType<{
-                    readonly ips_weight: NullType;
-                    readonly ips_stabilized_weight: NullType;
-                    readonly ips_normalized_weight: NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: OptionType<VariantType<{
-            readonly ate: NullType;
-            readonly att: NullType;
-            readonly atc: NullType;
-        }>>;
-        readonly refute: OptionType<StructType<{
-            /** Permuted-treatment negative control — a real effect should vanish. */
-            readonly placebo: BooleanType;
-            /** Inject an independent random common cause — the effect should hold. */
-            readonly random_common_cause: BooleanType;
-            /** Re-estimate on random subsamples — the effect should be stable. */
-            readonly data_subset: BooleanType;
-            /** Unobserved-confounder strengths to simulate → the sensitivity / tipping curve. */
-            readonly sensitivity: OptionType<ArrayType<FloatType>>;
-        }>>;
-        /** Continuous column for the ALE dose-response curve (the "How much?" view). */
-        readonly dose_feature: OptionType<StringType>;
-        readonly min_overlap: OptionType<FloatType>;
-        readonly min_treatment_variation: OptionType<FloatType>;
-        readonly bootstrap: OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: OptionType<StringType>;
-            readonly confidence_level: OptionType<FloatType>;
-        }>>;
-        readonly random_state: OptionType<IntegerType>;
-        /** Graded-overlap threshold — common support below this keeps `causal` from the
-         *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
-        readonly strong_overlap: OptionType<FloatType>;
-        /** Robustness floor — a `causal` verdict whose E-value is below this is downgraded to
-         *  `modest`. Off by default. (E-value is a monotone transform of the standardized effect.) */
-        readonly evalue_floor: OptionType<FloatType>;
-        /** Directional prior — a material, CI-clear effect of the opposite sign is flagged
-         *  (`expected_sign_ok = some(false)`, verdict `adjustment_insufficient`). Off by default. */
-        readonly expected_sign: OptionType<VariantType<{
-            readonly positive: NullType;
-            readonly negative: NullType;
-        }>>;
-    }>;
-    readonly verdict: VariantType<{
-        readonly causal: NullType;
-        readonly modest: NullType;
-        readonly adjustment_insufficient: NullType;
-        readonly non_identifiable_positivity: NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly naive: FloatType;
-    readonly adjusted: OptionType<FloatType>;
-    readonly committed_at: DateTimeType;
-    readonly committed_by: StringType;
-    /** The `id` of the preset this experiment was framed from (`none` for a
-     *  free-form / pre-presets row); the surface renders it as a "from {label}" chip. */
-    readonly preset: OptionType<StringType>;
-}>;
-/** Type alias for {@link JournalRowType}. */
-export type JournalRowType = typeof JournalRowType;
-/** The journal dataset — committed experiments, newest first. */
-export declare const JournalType: ArrayType<StructType<{
-    readonly config: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: OptionType<ArrayType<StringType>>;
-        readonly method: OptionType<VariantType<{
-            readonly linear_regression: NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: OptionType<VariantType<{
-                    readonly ips_weight: NullType;
-                    readonly ips_stabilized_weight: NullType;
-                    readonly ips_normalized_weight: NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: OptionType<VariantType<{
-            readonly ate: NullType;
-            readonly att: NullType;
-            readonly atc: NullType;
-        }>>;
-        readonly refute: OptionType<StructType<{
-            /** Permuted-treatment negative control — a real effect should vanish. */
-            readonly placebo: BooleanType;
-            /** Inject an independent random common cause — the effect should hold. */
-            readonly random_common_cause: BooleanType;
-            /** Re-estimate on random subsamples — the effect should be stable. */
-            readonly data_subset: BooleanType;
-            /** Unobserved-confounder strengths to simulate → the sensitivity / tipping curve. */
-            readonly sensitivity: OptionType<ArrayType<FloatType>>;
-        }>>;
-        /** Continuous column for the ALE dose-response curve (the "How much?" view). */
-        readonly dose_feature: OptionType<StringType>;
-        readonly min_overlap: OptionType<FloatType>;
-        readonly min_treatment_variation: OptionType<FloatType>;
-        readonly bootstrap: OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: OptionType<StringType>;
-            readonly confidence_level: OptionType<FloatType>;
-        }>>;
-        readonly random_state: OptionType<IntegerType>;
-        /** Graded-overlap threshold — common support below this keeps `causal` from the
-         *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
-        readonly strong_overlap: OptionType<FloatType>;
-        /** Robustness floor — a `causal` verdict whose E-value is below this is downgraded to
-         *  `modest`. Off by default. (E-value is a monotone transform of the standardized effect.) */
-        readonly evalue_floor: OptionType<FloatType>;
-        /** Directional prior — a material, CI-clear effect of the opposite sign is flagged
-         *  (`expected_sign_ok = some(false)`, verdict `adjustment_insufficient`). Off by default. */
-        readonly expected_sign: OptionType<VariantType<{
-            readonly positive: NullType;
-            readonly negative: NullType;
-        }>>;
-    }>;
-    readonly verdict: VariantType<{
-        readonly causal: NullType;
-        readonly modest: NullType;
-        readonly adjustment_insufficient: NullType;
-        readonly non_identifiable_positivity: NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly naive: FloatType;
-    readonly adjusted: OptionType<FloatType>;
-    readonly committed_at: DateTimeType;
-    readonly committed_by: StringType;
-    /** The `id` of the preset this experiment was framed from (`none` for a
-     *  free-form / pre-presets row); the surface renders it as a "from {label}" chip. */
-    readonly preset: OptionType<StringType>;
-}>>;
-/** Type alias for {@link JournalType}. */
-export type JournalType = typeof JournalType;
-//# sourceMappingURL=types.d.ts.map