@elaraai/e3-ui 1.0.11 → 1.0.12

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

@@ -0,0 +1,640 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Experiment` component — an interactive causal-experiment surface.
+ *
+ * @remarks
+ * `Experiment` lets a domain expert ask *"did X change Y?"* against a dataset
+ * and trust the answer, without meeting a statistician's vocabulary. It is a
+ * registered extension component (architecturally like {@link Ontology}): the
+ * author writes one tag, `Experiment.Root({ … })`; the React renderer lives in
+ * `@elaraai/e3-ui-components` and is wired via
+ * `implementUIComponent(Experiment.Component, EastChakraExperiment)`.
+ *
+ * **Generic over the input row, like `Table`.** The author binds the input
+ * dataset (`data: BoundValue<ArrayType<Row>>`); the renderer introspects its
+ * row struct to drive the treatment / outcome / confounder pickers, so the
+ * **end user** re-frames the experiment from the dataset's own columns.
+ *
+ * **The user adjusts → results go stale → Run re-computes.** Editing a picker
+ * stages a new {@link ExperimentSpecType} and marks the result stale; **Run**
+ * calls the author-supplied estimator functions ({@link Func.bind} handles) and
+ * the answer arrives reactively; **Commit** appends to the journal. The causal
+ * compute (DoWhy / EconML) lives entirely in those function bodies, so `e3-ui`
+ * never imports `east-py-datascience`.
+ *
+ * **Visual-first and derived.** Because the user frames an arbitrary
+ * experiment, nothing on the result side is hand-authored — every word is a
+ * column name the user picked, a number an estimator returned, or a status
+ * derived by rule (interval clears zero → HIGHER / LOWER; spans zero → NO CLEAR
+ * EFFECT; raw and adjusted disagree in sign → the "misleading" banner). The
+ * contract types ({@link ExperimentSpecType}, {@link ExperimentResultType}, …)
+ * live in {@link "./experiment/types"} and are reached via `Experiment.Types.*`.
+ *
+ * @packageDocumentation
+ */
+import { NullType, BooleanType, StringType, ArrayType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
+import { type UIComponentType } from '@elaraai/east-ui';
+import { type BoundValue } from '../data.js';
+import { type BoundFunc } from '../func.js';
+import { ExperimentSpecType, ExperimentResultType, RefuteResultType, DoseResultType, JournalType } from './types.js';
+export { WeightingSchemeType, EstimatorType, TargetUnitsType, TrimType, ExperimentSpecType, CiType, BalanceRowType, ExperimentResultType, RefuteKindType, RefuteCheckType, RefuteResultType, DoseSegmentType, DoseResultType, JournalRowType, JournalType, ColumnMetaType, } from './types.js';
+/**
+ * The `estimate` function signature: `(rows, spec) → ExperimentResult`. The
+ * renderer calls this on **Run** with the bound `data` and the staged spec.
+ *
+ * @typeParam Row - The input dataset's row struct.
+ */
+export type EstimateFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType], ExperimentResultType>;
+/**
+ * The optional `refute` function signature: `(rows, spec) → RefuteResult` — the
+ * robustness battery shown in the "Can we trust it?" tab.
+ *
+ * @typeParam Row - The input dataset's row struct.
+ */
+export type RefuteFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType], RefuteResultType>;
+/**
+ * The optional `dose` function signature: `(rows, spec, feature) → DoseResult` —
+ * the ALE dose-response curve for the chosen `feature` column shown in the "How
+ * much?" tab.
+ *
+ * @typeParam Row - The input dataset's row struct.
+ */
+export type DoseFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType, StringType], DoseResultType>;
+/** Initial result tab variant — `answer` (default), `trust`, or `dose`. */
+export declare const ExperimentTabType: VariantType<{
+    readonly answer: NullType;
+    readonly trust: NullType;
+    readonly dose: NullType;
+}>;
+/** Type alias for {@link ExperimentTabType}. */
+export type ExperimentTabType = typeof ExperimentTabType;
+/**
+ * The `Experiment` component payload — binding descriptors + options. Renderers
+ * decode this and resolve each binding to a live, reactive value / call handle.
+ *
+ * @property data - {@link DiffBindingType} for the input dataset — the renderer
+ *   introspects its row struct for the pickers and passes it to the functions.
+ * @property spec - {@link DiffBindingType} for the staged {@link ExperimentSpecType}.
+ * @property estimate - {@link FuncBindingType} for the `estimate` function.
+ * @property refute - Optional {@link FuncBindingType} for the `refute` function.
+ * @property dose - Optional {@link FuncBindingType} for the `dose` function.
+ * @property journal - Optional {@link DiffBindingType} for the committed-experiment journal.
+ * @property columnMeta - Optional per-column display metadata.
+ * @property readonly - Render without the Run / Commit / edit affordances.
+ * @property defaultTab - Initial result tab ({@link ExperimentTabType}).
+ */
+export declare const ExperimentPayloadType: StructType<{
+    readonly data: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly spec: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly estimate: StructType<{
+        readonly name: StringType;
+    }>;
+    readonly refute: OptionType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly dose: OptionType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly journal: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>>;
+    readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
+        readonly label: OptionType<StringType>;
+        readonly unit: OptionType<StringType>;
+        readonly higherIsBetter: OptionType<BooleanType>;
+    }>>>;
+    readonly readonly: OptionType<BooleanType>;
+    readonly defaultTab: OptionType<VariantType<{
+        readonly answer: NullType;
+        readonly trust: NullType;
+        readonly dose: NullType;
+    }>>;
+}>;
+/** Type alias for {@link ExperimentPayloadType}. */
+export type ExperimentPayloadType = typeof ExperimentPayloadType;
+/** Initial result tab as a string literal. */
+export type ExperimentTabLiteral = 'answer' | 'trust' | 'dose';
+/**
+ * Internal {@link EastUI.component} carrier. The React renderer registers
+ * against this in `@elaraai/e3-ui-components`.
+ */
+export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
+    readonly data: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly spec: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly estimate: StructType<{
+        readonly name: StringType;
+    }>;
+    readonly refute: OptionType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly dose: OptionType<StructType<{
+        readonly name: StringType;
+    }>>;
+    readonly journal: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>>;
+    readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
+        readonly label: OptionType<StringType>;
+        readonly unit: OptionType<StringType>;
+        readonly higherIsBetter: OptionType<BooleanType>;
+    }>>>;
+    readonly readonly: OptionType<BooleanType>;
+    readonly defaultTab: OptionType<VariantType<{
+        readonly answer: NullType;
+        readonly trust: NullType;
+        readonly dose: NullType;
+    }>>;
+}>>;
+/**
+ * Options for {@link Experiment.Root}, generic over the input row struct.
+ *
+ * @typeParam Row - The input dataset's row struct — inferred from `data`.
+ *
+ * @property data - The {@link Data.bind} handle for the input dataset.
+ * @property spec - The {@link Data.bind} handle for the staged experiment spec.
+ * @property estimate - The {@link Func.bind} handle for the estimator.
+ * @property refute - Optional {@link Func.bind} handle for the robustness battery.
+ * @property dose - Optional {@link Func.bind} handle for the dose-response curve.
+ * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
+ * @property columnMeta - Optional per-column display metadata.
+ * @property readonly - Render without mutation affordances.
+ * @property defaultTab - Initial result tab.
+ */
+/**
+ * Per-column display config — the friendly label, unit suffix, and good
+ * direction the surface uses to phrase results ("worse" instead of "lower").
+ */
+export interface ExperimentColumnConfig {
+    /** Friendly label shown instead of the raw column name. */
+    label?: string;
+    /** Unit suffix ("MPa", "$", …). */
+    unit?: string;
+    /** Whether a larger value is the good direction (flips "lower" → "worse"). */
+    higherIsBetter?: boolean;
+}
+/**
+ * Type-safe per-column config, keyed by the bound dataset's field names (the
+ * `Table` columns pattern) — only real columns are accepted as keys.
+ *
+ * @typeParam Row - The input dataset's row struct.
+ */
+export type ExperimentColumns<Row extends StructType> = {
+    [K in Extract<keyof Row['fields'], string>]?: ExperimentColumnConfig;
+};
+export interface ExperimentOptions<Row extends StructType> {
+    data: BoundValue<ArrayType<Row>>;
+    spec: BoundValue<ExperimentSpecType>;
+    estimate: EstimateFunc<Row>;
+    refute?: RefuteFunc<Row>;
+    dose?: DoseFunc<Row>;
+    journal?: BoundValue<JournalType>;
+    /** Per-column display config, keyed by the data row's fields (like `Table`). */
+    columns?: ExperimentColumns<Row>;
+    readonly?: SubtypeExprOrValue<OptionType<BooleanType>>;
+    defaultTab?: ExperimentTabLiteral;
+}
+/**
+ * Build an Experiment surface bound to an input dataset + estimator functions.
+ *
+ * @typeParam Row - The input dataset's row struct, inferred from `data`.
+ * @param options - {@link ExperimentOptions}. `data`, `spec` and `estimate` are
+ *   required; the rest are optional.
+ * @returns An East expression of {@link UIComponentType}.
+ */
+declare function createExperiment<Row extends StructType>(options: ExperimentOptions<Row>): ExprType<UIComponentType>;
+/**
+ * The Experiment component namespace. Surfaces an interactive causal-experiment
+ * over a bound input dataset + estimator functions, generic over the row struct
+ * (the `Table` pattern), with the staged-binding machinery the rest of e3-ui
+ * uses.
+ *
+ * @remarks
+ * Use `Experiment.Root({ data, spec, estimate, refute, dose, journal })` inside
+ * a `Reactive` block. The `Component` property is the {@link EastUI.component}
+ * carrier the renderer registers against; `Types` exposes the render-contract
+ * value types (`Spec`, `Result`, `Refute`, `Dose`, `Journal`, …).
+ */
+export declare const Experiment: {
+    readonly Root: typeof createExperiment;
+    /** The internal {@link EastUI.component} carrier renderers register against. */
+    readonly Component: import("@elaraai/east-ui").UIComponentDef<StructType<{
+        readonly data: StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>;
+        readonly spec: StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>;
+        readonly estimate: StructType<{
+            readonly name: StringType;
+        }>;
+        readonly refute: OptionType<StructType<{
+            readonly name: StringType;
+        }>>;
+        readonly dose: OptionType<StructType<{
+            readonly name: StringType;
+        }>>;
+        readonly journal: OptionType<StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>>;
+        readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
+            readonly label: OptionType<StringType>;
+            readonly unit: OptionType<StringType>;
+            readonly higherIsBetter: OptionType<BooleanType>;
+        }>>>;
+        readonly readonly: OptionType<BooleanType>;
+        readonly defaultTab: OptionType<VariantType<{
+            readonly answer: NullType;
+            readonly trust: NullType;
+            readonly dose: NullType;
+        }>>;
+    }>>;
+    readonly Types: {
+        /** Rendered payload struct (bindings + options). */
+        readonly Payload: StructType<{
+            readonly data: StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>;
+            readonly spec: StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>;
+            readonly estimate: StructType<{
+                readonly name: StringType;
+            }>;
+            readonly refute: OptionType<StructType<{
+                readonly name: StringType;
+            }>>;
+            readonly dose: OptionType<StructType<{
+                readonly name: StringType;
+            }>>;
+            readonly journal: OptionType<StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>>;
+            readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
+                readonly label: OptionType<StringType>;
+                readonly unit: OptionType<StringType>;
+                readonly higherIsBetter: OptionType<BooleanType>;
+            }>>>;
+            readonly readonly: OptionType<BooleanType>;
+            readonly defaultTab: OptionType<VariantType<{
+                readonly answer: NullType;
+                readonly trust: NullType;
+                readonly dose: NullType;
+            }>>;
+        }>;
+        /** The experiment-spec value type (what the pickers stage). */
+        readonly Spec: StructType<{
+            readonly treatment: StringType;
+            readonly outcome: StringType;
+            readonly confounders: ArrayType<StringType>;
+            readonly categorical: ArrayType<StringType>;
+            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 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;
+                    }>;
+                }>;
+            }>>>;
+            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 targetUnits: OptionType<VariantType<{
+                readonly ate: NullType;
+                readonly att: NullType;
+                readonly atc: NullType;
+            }>>;
+            readonly trim: OptionType<VariantType<{
+                readonly overlap: NullType;
+                readonly bounds: StructType<{
+                    readonly lower: import("@elaraai/east").FloatType;
+                    readonly upper: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+        }>;
+        /** The estimator answer value type. */
+        readonly Result: StructType<{
+            readonly effect: import("@elaraai/east").FloatType;
+            readonly ci: OptionType<StructType<{
+                readonly lower: import("@elaraai/east").FloatType;
+                readonly upper: import("@elaraai/east").FloatType;
+            }>>;
+            readonly naive: import("@elaraai/east").FloatType;
+            readonly naiveCi: OptionType<StructType<{
+                readonly lower: import("@elaraai/east").FloatType;
+                readonly upper: import("@elaraai/east").FloatType;
+            }>>;
+            readonly nTotal: import("@elaraai/east").IntegerType;
+            readonly nTreated: import("@elaraai/east").IntegerType;
+            readonly nControl: import("@elaraai/east").IntegerType;
+            readonly nDropped: import("@elaraai/east").IntegerType;
+            readonly balance: ArrayType<StructType<{
+                readonly column: StringType;
+                readonly treatedMean: import("@elaraai/east").FloatType;
+                readonly controlMean: import("@elaraai/east").FloatType;
+                readonly stdDiff: import("@elaraai/east").FloatType;
+            }>>;
+        }>;
+        /** The robustness-battery value type. */
+        readonly Refute: StructType<{
+            readonly checks: ArrayType<StructType<{
+                readonly kind: VariantType<{
+                    readonly placebo: NullType;
+                    readonly random_common_cause: NullType;
+                    readonly data_subset: NullType;
+                    readonly unobserved: NullType;
+                }>;
+                readonly estimatedEffect: import("@elaraai/east").FloatType;
+                readonly newEffects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly strengths: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+                readonly pValue: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
+        }>;
+        /** The dose-response value type. */
+        readonly Dose: StructType<{
+            readonly feature: StringType;
+            readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+            readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+            readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+            readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+            readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
+            readonly segments: OptionType<ArrayType<StructType<{
+                readonly label: StringType;
+                readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+                readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+            }>>>;
+        }>;
+        /** The committed-experiment journal value type. */
+        readonly Journal: ArrayType<StructType<{
+            readonly spec: StructType<{
+                readonly treatment: StringType;
+                readonly outcome: StringType;
+                readonly confounders: ArrayType<StringType>;
+                readonly categorical: ArrayType<StringType>;
+                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 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;
+                        }>;
+                    }>;
+                }>>>;
+                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 targetUnits: OptionType<VariantType<{
+                    readonly ate: NullType;
+                    readonly att: NullType;
+                    readonly atc: NullType;
+                }>>;
+                readonly trim: OptionType<VariantType<{
+                    readonly overlap: NullType;
+                    readonly bounds: StructType<{
+                        readonly lower: import("@elaraai/east").FloatType;
+                        readonly upper: import("@elaraai/east").FloatType;
+                    }>;
+                }>>;
+            }>;
+            readonly effect: import("@elaraai/east").FloatType;
+            readonly ci: OptionType<StructType<{
+                readonly lower: import("@elaraai/east").FloatType;
+                readonly upper: import("@elaraai/east").FloatType;
+            }>>;
+            readonly committedAt: import("@elaraai/east").DateTimeType;
+            readonly committedBy: StringType;
+        }>>;
+        /** Optional per-column display metadata. */
+        readonly ColumnMeta: import("@elaraai/east").DictType<StringType, StructType<{
+            readonly label: OptionType<StringType>;
+            readonly unit: OptionType<StringType>;
+            readonly higherIsBetter: OptionType<BooleanType>;
+        }>>;
+        /** Initial result tab variant. */
+        readonly Tab: VariantType<{
+            readonly answer: NullType;
+            readonly trust: NullType;
+            readonly dose: NullType;
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/experiment/index.ts"],"names":[],"mappings":"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"}