@elaraai/e3-ui 1.0.11 → 1.0.13

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

@@ -0,0 +1,575 @@
+/**
+ * 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;
+/** 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>;
+}>;
+/** 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;
+}>;
+/** Type alias for {@link BalanceRowType}. */
+export type BalanceRowType = typeof BalanceRowType;
+/** 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;
+    readonly positivity_ok: BooleanType;
+}>;
+/** Type alias for {@link OverlapDiagnosticType}. */
+export type OverlapDiagnosticType = typeof OverlapDiagnosticType;
+/** 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 — confounder strength needed to explain the effect away. */
+    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>;
+    }>>;
+}>;
+/** 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;
+/**
+ * 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;
+    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;
+    }>>;
+    readonly overlap: StructType<{
+        readonly treated_propensity: VectorType<FloatType>;
+        readonly control_propensity: VectorType<FloatType>;
+        readonly common_support_frac: FloatType;
+        readonly positivity_ok: BooleanType;
+    }>;
+    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 — confounder strength needed to explain the effect away. */
+        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>;
+        }>>;
+    }>>;
+    /** 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;
+    }>;
+}>;
+/** 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 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;
+/**
+ * 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>;
+    }>;
+    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;
+}>;
+/** 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>;
+    }>;
+    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;
+}>>;
+/** Type alias for {@link JournalType}. */
+export type JournalType = typeof JournalType;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/experiment/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACH,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,QAAQ,EACR,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,UAAU,EACb,MAAM,eAAe,CAAC;AAOvB,6BAA6B;AAC7B,eAAO,MAAM,MAAM;;;EAAqD,CAAC;AACzE,qCAAqC;AACrC,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,2CAA2C;AAC3C,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AACH,kDAAkD;AAClD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC;AAE7D,0CAA0C;AAC1C,eAAO,MAAM,aAAa;;;;;;;;;EAKxB,CAAC;AACH,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD,6CAA6C;AAC7C,eAAO,MAAM,eAAe;;;;EAI1B,CAAC;AACH,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAErD,mDAAmD;AACnD,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AACH,kDAAkD;AAClD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC;AAE7D,sCAAsC;AACtC,eAAO,MAAM,cAAc;IACvB,yEAAyE;;IAEzE,0EAA0E;;IAE1E,sEAAsE;;IAEtE,qFAAqF;;EAEvF,CAAC;AACH,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAMnD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;QAzB7B,yEAAyE;;QAEzE,0EAA0E;;QAE1E,sEAAsE;;QAEtE,qFAAqF;;;IA2BrF,gFAAgF;;;;;;;;;;EAMlF,CAAC;AACH,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAM/D,uFAAuF;AACvF,eAAO,MAAM,cAAc;;IAEvB;2EACuE;;;;;EAKzE,CAAC;AACH,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,iEAAiE;AACjE,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AACH,oDAAoD;AACpD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC;AAEjE,8DAA8D;AAC9D,eAAO,MAAM,cAAc;IACvB,mEAAmE;;IAEnE,2CAA2C;;IAE3C,2EAA2E;;IAE3E,sDAAsD;;IAEtD,gDAAgD;;IAEhD,mFAAmF;;IAEnF,4FAA4F;;;;;EAK9F,CAAC;AACH,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB;;;;;;IAMzB,oFAAoF;;EAEtF,CAAC;AACH,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;EAMhC,CAAC;AACH,oDAAoD;AACpD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;QA3E7B;+EACuE;;;;;;;;;;;;;QAqBvE,mEAAmE;;QAEnE,2CAA2C;;QAE3C,2EAA2E;;QAE3E,sDAAsD;;QAEtD,gDAAgD;;QAEhD,mFAAmF;;QAEnF,4FAA4F;;;;;;IAoD5F,uFAAuF;;;;;;;QApCvF,oFAAoF;;;;;;;;;;EAuCtF,CAAC;AACH,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAe/D;;;GAGG;AACH,eAAO,MAAM,eAAe;IACxB,sEAAsE;;IAEtE,4EAA4E;;IAE5E,+EAA+E;;IAE/E,0DAA0D;;IAE1D,qEAAqE;;EAEvE,CAAC;AACH,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAErD,kFAAkF;AAClF,eAAO,MAAM,eAAe;IACxB,sDAAsD;;IAEtD,6DAA6D;;;;;EAK/D,CAAC;AACH,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAErD,4EAA4E;AAC5E,eAAO,MAAM,cAAc;;;EAGzB,CAAC;AACH,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC7B,sEAAsE;;;;;;;;;QA1CtE,sEAAsE;;QAEtE,4EAA4E;;QAE5E,+EAA+E;;QAE/E,0DAA0D;;QAE1D,qEAAqE;;;IAqCrE,iFAAiF;;IAEjF,kDAAkD;;;;IAIlD,0IAA0I;;IAE1I,mFAAmF;;IAEnF,uEAAuE;;QAvCvE,sDAAsD;;QAEtD,6DAA6D;;;;;;IAuC7D,6CAA6C;;;;;IAE7C,iEAAiE;;EAEnE,CAAC;AACH,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAE/D,kFAAkF;AAClF,eAAO,MAAM,gBAAgB;IACzB,yCAAyC;;IAEzC,2DAA2D;;IAE3D,wHAAwH;;IAExH,4DAA4D;;EAE9D,CAAC;AACH,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAMvD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmC,CAAC;AAC/D,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;GAIxB,CAAC;AACJ,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;YAlRvB,yEAAyE;;YAEzE,0EAA0E;;YAE1E,sEAAsE;;YAEtE,qFAAqF;;;QA2BrF,gFAAgF;;;;;;;;;;;;;;;;;;;;;;EAwPlF,CAAC;AACH,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,iEAAiE;AACjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;YA9RpB,yEAAyE;;YAEzE,0EAA0E;;YAE1E,sEAAsE;;YAEtE,qFAAqF;;;QA2BrF,gFAAgF;;;;;;;;;;;;;;;;;;;;;;GA6PhC,CAAC;AACrD,0CAA0C;AAC1C,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC"}