@elaraai/e3-ui 1.0.12 → 1.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/dist/src/experiment/index.d.ts +376 -322
  2. package/dist/src/experiment/index.d.ts.map +1 -1
  3. package/dist/src/experiment/index.js +57 -58
  4. package/dist/src/experiment/index.js.map +1 -1
  5. package/dist/src/experiment/types.d.ts +439 -475
  6. package/dist/src/experiment/types.d.ts.map +1 -1
  7. package/dist/src/experiment/types.js +218 -256
  8. package/dist/src/experiment/types.js.map +1 -1
  9. package/dist/src/index.js +4 -4
  10. package/dist/src/index.js.map +1 -1
  11. package/dist/test/experiment/experiment.examples.d.ts +174 -415
  12. package/dist/test/experiment/experiment.examples.d.ts.map +1 -1
  13. package/dist/test/experiment/experiment.examples.js +112 -81
  14. package/dist/test/experiment/experiment.examples.js.map +1 -1
  15. package/package.json +7 -7
package/dist/src/experiment/index.d.ts CHANGED
@@ -6,68 +6,50 @@
6
6
  * `Experiment` component — an interactive causal-experiment surface.
7
7
  *
8
8
  * @remarks
9
- * `Experiment` lets a domain expert ask *"did X change Y?"* against a dataset
10
- * and trust the answer, without meeting a statistician's vocabulary. It is a
11
- * registered extension component (architecturally like {@link Ontology}): the
12
- * author writes one tag, `Experiment.Root({ … })`; the React renderer lives in
13
- * `@elaraai/e3-ui-components` and is wired via
14
- * `implementUIComponent(Experiment.Component, EastChakraExperiment)`.
9
+ * `Experiment` lets a domain expert ask *"did X change Y, and can I trust it?"*
10
+ * against a dataset and read a derived, honest answer — without meeting a
11
+ * statistician's vocabulary. It is a registered extension component
12
+ * (architecturally like {@link Ontology}): the author writes one tag,
13
+ * `Experiment.Root({ … })`; the React renderer lives in
14
+ * `@elaraai/e3-ui-components`.
15
15
  *
16
16
  * **Generic over the input row, like `Table`.** The author binds the input
17
- * dataset (`data: BoundValue<ArrayType<Row>>`); the renderer introspects its
18
- * row struct to drive the treatment / outcome / confounder pickers, so the
19
- * **end user** re-frames the experiment from the dataset's own columns.
17
+ * dataset (`data: BoundValue<ArrayType<Row>>`); the renderer introspects its row
18
+ * struct to drive the treatment / outcome / confounder pickers.
20
19
  *
21
- * **The user adjusts → results go stale → Run re-computes.** Editing a picker
22
- * stages a new {@link ExperimentSpecType} and marks the result stale; **Run**
23
- * calls the author-supplied estimator functions ({@link Func.bind} handles) and
24
- * the answer arrives reactively; **Commit** appends to the journal. The causal
25
- * compute (DoWhy / EconML) lives entirely in those function bodies, so `e3-ui`
26
- * never imports `east-py-datascience`.
20
+ * **The user edits the config → Apply runs ONE function.** Editing a picker
21
+ * stages a new {@link ExperimentConfigType}; **Apply** calls the single bound
22
+ * `experiment` function (`(rows, config) → ExperimentResult`) and the answer
23
+ * arrives reactively. The result carries the naive vs adjusted effect, balance,
24
+ * overlap, robustness, and an honesty **verdict** — `adjusted` is `none` when the
25
+ * engine refuses. **Commit** appends to the journal.
27
26
  *
28
- * **Visual-first and derived.** Because the user frames an arbitrary
29
- * experiment, nothing on the result side is hand-authored — every word is a
30
- * column name the user picked, a number an estimator returned, or a status
31
- * derived by rule (interval clears zero → HIGHER / LOWER; spans zero → NO CLEAR
32
- * EFFECT; raw and adjusted disagree in sign → the "misleading" banner). The
33
- * contract types ({@link ExperimentSpecType}, {@link ExperimentResultType}, …)
34
- * live in {@link "./experiment/types"} and are reached via `Experiment.Types.*`.
27
+ * **Visual-first and derived.** Nothing on the result side is hand-authored —
28
+ * every word is a column name the user picked, a number the engine returned, or
29
+ * a status derived by rule from the verdict tag.
35
30
  *
36
31
  * @packageDocumentation
37
32
  */
38
- import { NullType, BooleanType, StringType, ArrayType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
33
+ import { NullType, BooleanType, ArrayType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
39
34
  import { type UIComponentType } from '@elaraai/east-ui';
40
35
  import { type BoundValue } from '../data.js';
41
36
  import { type BoundFunc } from '../func.js';
42
- import { ExperimentSpecType, ExperimentResultType, RefuteResultType, DoseResultType, JournalType } from './types.js';
43
- export { WeightingSchemeType, EstimatorType, TargetUnitsType, TrimType, ExperimentSpecType, CiType, BalanceRowType, ExperimentResultType, RefuteKindType, RefuteCheckType, RefuteResultType, DoseSegmentType, DoseResultType, JournalRowType, JournalType, ColumnMetaType, } from './types.js';
37
+ import { ExperimentConfigType, ExperimentResultType, JournalType, PopulationType, DesignConfigType, ExperimentDesignType } from './types.js';
38
+ export { CiType, WeightingSchemeType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, ExperimentConfigType, BalanceRowType, OverlapDiagnosticType, RefutationType, DoseResponseType, ExperimentVerdictType, ExperimentResultType, JournalRowType, JournalType, ColumnMetaType, PopulationType, } from './types.js';
44
39
  /**
45
- * The `estimate` function signature: `(rows, spec) → ExperimentResult`. The
46
- * renderer calls this on **Run** with the bound `data` and the staged spec.
40
+ * The `experiment` function signature: `(rows, config) → ExperimentResult`. The
41
+ * renderer calls this on **Apply** with the bound `data` and the staged config.
47
42
  *
48
43
  * @typeParam Row - The input dataset's row struct.
49
44
  */
50
- export type EstimateFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType], ExperimentResultType>;
51
- /**
52
- * The optional `refute` function signature: `(rows, spec) → RefuteResult` — the
53
- * robustness battery shown in the "Can we trust it?" tab.
54
- *
55
- * @typeParam Row - The input dataset's row struct.
56
- */
57
- export type RefuteFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType], RefuteResultType>;
58
- /**
59
- * The optional `dose` function signature: `(rows, spec, feature) → DoseResult` —
60
- * the ALE dose-response curve for the chosen `feature` column shown in the "How
61
- * much?" tab.
62
- *
63
- * @typeParam Row - The input dataset's row struct.
64
- */
65
- export type DoseFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType, StringType], DoseResultType>;
66
- /** Initial result tab variant — `answer` (default), `trust`, or `dose`. */
45
+ export type ExperimentFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentConfigType], ExperimentResultType>;
46
+ export type ExperimentDesignFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentConfigType, ExperimentResultType, DesignConfigType], ExperimentDesignType>;
47
+ /** Initial result tab variant — `answer` (default), `trust`, `dose`, or `validate`. */
67
48
  export declare const ExperimentTabType: VariantType<{
68
49
  readonly answer: NullType;
69
50
  readonly trust: NullType;
70
51
  readonly dose: NullType;
52
+ readonly validate: NullType;
71
53
  }>;
72
54
  /** Type alias for {@link ExperimentTabType}. */
73
55
  export type ExperimentTabType = typeof ExperimentTabType;
@@ -76,65 +58,75 @@ export type ExperimentTabType = typeof ExperimentTabType;
76
58
  * decode this and resolve each binding to a live, reactive value / call handle.
77
59
  *
78
60
  * @property data - {@link DiffBindingType} for the input dataset — the renderer
79
- * introspects its row struct for the pickers and passes it to the functions.
80
- * @property spec - {@link DiffBindingType} for the staged {@link ExperimentSpecType}.
81
- * @property estimate - {@link FuncBindingType} for the `estimate` function.
82
- * @property refute - Optional {@link FuncBindingType} for the `refute` function.
83
- * @property dose - Optional {@link FuncBindingType} for the `dose` function.
61
+ * introspects its row struct for the pickers and passes it to the function.
62
+ * @property config - {@link DiffBindingType} for the staged {@link ExperimentConfigType}.
63
+ * @property experiment - {@link FuncBindingType} for the single `experiment` function.
64
+ * @property population - Optional {@link DiffBindingType} for the staged Step-4
65
+ * population filter ({@link PopulationType}); narrows rows UI-side before the call.
84
66
  * @property journal - Optional {@link DiffBindingType} for the committed-experiment journal.
85
67
  * @property columnMeta - Optional per-column display metadata.
86
- * @property readonly - Render without the Run / Commit / edit affordances.
68
+ * @property readonly - Render without the Apply / Commit / edit affordances.
87
69
  * @property defaultTab - Initial result tab ({@link ExperimentTabType}).
88
70
  */
89
71
  export declare const ExperimentPayloadType: StructType<{
90
72
  readonly data: StructType<{
91
73
  readonly source: ArrayType<VariantType<{
92
- readonly field: StringType;
74
+ readonly field: import("@elaraai/east").StringType;
93
75
  }>>;
94
76
  readonly patch: OptionType<ArrayType<VariantType<{
95
- readonly field: StringType;
77
+ readonly field: import("@elaraai/east").StringType;
96
78
  }>>>;
97
79
  readonly mode: VariantType<{
98
80
  readonly staged: NullType;
99
81
  readonly direct: NullType;
100
82
  }>;
101
83
  }>;
102
- readonly spec: StructType<{
84
+ readonly config: StructType<{
103
85
  readonly source: ArrayType<VariantType<{
104
- readonly field: StringType;
86
+ readonly field: import("@elaraai/east").StringType;
105
87
  }>>;
106
88
  readonly patch: OptionType<ArrayType<VariantType<{
107
- readonly field: StringType;
89
+ readonly field: import("@elaraai/east").StringType;
108
90
  }>>>;
109
91
  readonly mode: VariantType<{
110
92
  readonly staged: NullType;
111
93
  readonly direct: NullType;
112
94
  }>;
113
95
  }>;
114
- readonly estimate: StructType<{
115
- readonly name: StringType;
96
+ readonly experiment: StructType<{
97
+ readonly name: import("@elaraai/east").StringType;
116
98
  }>;
117
- readonly refute: OptionType<StructType<{
118
- readonly name: StringType;
119
- }>>;
120
- readonly dose: OptionType<StructType<{
121
- readonly name: StringType;
99
+ readonly population: OptionType<StructType<{
100
+ readonly source: ArrayType<VariantType<{
101
+ readonly field: import("@elaraai/east").StringType;
102
+ }>>;
103
+ readonly patch: OptionType<ArrayType<VariantType<{
104
+ readonly field: import("@elaraai/east").StringType;
105
+ }>>>;
106
+ readonly mode: VariantType<{
107
+ readonly staged: NullType;
108
+ readonly direct: NullType;
109
+ }>;
122
110
  }>>;
123
111
  readonly journal: OptionType<StructType<{
124
112
  readonly source: ArrayType<VariantType<{
125
- readonly field: StringType;
113
+ readonly field: import("@elaraai/east").StringType;
126
114
  }>>;
127
115
  readonly patch: OptionType<ArrayType<VariantType<{
128
- readonly field: StringType;
116
+ readonly field: import("@elaraai/east").StringType;
129
117
  }>>>;
130
118
  readonly mode: VariantType<{
131
119
  readonly staged: NullType;
132
120
  readonly direct: NullType;
133
121
  }>;
134
122
  }>>;
135
- readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
136
- readonly label: OptionType<StringType>;
137
- readonly unit: OptionType<StringType>;
123
+ /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
124
+ readonly design: OptionType<StructType<{
125
+ readonly name: import("@elaraai/east").StringType;
126
+ }>>;
127
+ readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
128
+ readonly label: OptionType<import("@elaraai/east").StringType>;
129
+ readonly unit: OptionType<import("@elaraai/east").StringType>;
138
130
  readonly higherIsBetter: OptionType<BooleanType>;
139
131
  }>>>;
140
132
  readonly readonly: OptionType<BooleanType>;
@@ -142,6 +134,7 @@ export declare const ExperimentPayloadType: StructType<{
142
134
  readonly answer: NullType;
143
135
  readonly trust: NullType;
144
136
  readonly dose: NullType;
137
+ readonly validate: NullType;
145
138
  }>>;
146
139
  }>;
147
140
  /** Type alias for {@link ExperimentPayloadType}. */
@@ -155,52 +148,62 @@ export type ExperimentTabLiteral = 'answer' | 'trust' | 'dose';
155
148
  export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
156
149
  readonly data: StructType<{
157
150
  readonly source: ArrayType<VariantType<{
158
- readonly field: StringType;
151
+ readonly field: import("@elaraai/east").StringType;
159
152
  }>>;
160
153
  readonly patch: OptionType<ArrayType<VariantType<{
161
- readonly field: StringType;
154
+ readonly field: import("@elaraai/east").StringType;
162
155
  }>>>;
163
156
  readonly mode: VariantType<{
164
157
  readonly staged: NullType;
165
158
  readonly direct: NullType;
166
159
  }>;
167
160
  }>;
168
- readonly spec: StructType<{
161
+ readonly config: StructType<{
169
162
  readonly source: ArrayType<VariantType<{
170
- readonly field: StringType;
163
+ readonly field: import("@elaraai/east").StringType;
171
164
  }>>;
172
165
  readonly patch: OptionType<ArrayType<VariantType<{
173
- readonly field: StringType;
166
+ readonly field: import("@elaraai/east").StringType;
174
167
  }>>>;
175
168
  readonly mode: VariantType<{
176
169
  readonly staged: NullType;
177
170
  readonly direct: NullType;
178
171
  }>;
179
172
  }>;
180
- readonly estimate: StructType<{
181
- readonly name: StringType;
173
+ readonly experiment: StructType<{
174
+ readonly name: import("@elaraai/east").StringType;
182
175
  }>;
183
- readonly refute: OptionType<StructType<{
184
- readonly name: StringType;
185
- }>>;
186
- readonly dose: OptionType<StructType<{
187
- readonly name: StringType;
176
+ readonly population: OptionType<StructType<{
177
+ readonly source: ArrayType<VariantType<{
178
+ readonly field: import("@elaraai/east").StringType;
179
+ }>>;
180
+ readonly patch: OptionType<ArrayType<VariantType<{
181
+ readonly field: import("@elaraai/east").StringType;
182
+ }>>>;
183
+ readonly mode: VariantType<{
184
+ readonly staged: NullType;
185
+ readonly direct: NullType;
186
+ }>;
188
187
  }>>;
189
188
  readonly journal: OptionType<StructType<{
190
189
  readonly source: ArrayType<VariantType<{
191
- readonly field: StringType;
190
+ readonly field: import("@elaraai/east").StringType;
192
191
  }>>;
193
192
  readonly patch: OptionType<ArrayType<VariantType<{
194
- readonly field: StringType;
193
+ readonly field: import("@elaraai/east").StringType;
195
194
  }>>>;
196
195
  readonly mode: VariantType<{
197
196
  readonly staged: NullType;
198
197
  readonly direct: NullType;
199
198
  }>;
200
199
  }>>;
201
- readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
202
- readonly label: OptionType<StringType>;
203
- readonly unit: OptionType<StringType>;
200
+ /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
201
+ readonly design: OptionType<StructType<{
202
+ readonly name: import("@elaraai/east").StringType;
203
+ }>>;
204
+ readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
205
+ readonly label: OptionType<import("@elaraai/east").StringType>;
206
+ readonly unit: OptionType<import("@elaraai/east").StringType>;
204
207
  readonly higherIsBetter: OptionType<BooleanType>;
205
208
  }>>>;
206
209
  readonly readonly: OptionType<BooleanType>;
@@ -208,23 +211,9 @@ export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponent
208
211
  readonly answer: NullType;
209
212
  readonly trust: NullType;
210
213
  readonly dose: NullType;
214
+ readonly validate: NullType;
211
215
  }>>;
212
216
  }>>;
213
- /**
214
- * Options for {@link Experiment.Root}, generic over the input row struct.
215
- *
216
- * @typeParam Row - The input dataset's row struct — inferred from `data`.
217
- *
218
- * @property data - The {@link Data.bind} handle for the input dataset.
219
- * @property spec - The {@link Data.bind} handle for the staged experiment spec.
220
- * @property estimate - The {@link Func.bind} handle for the estimator.
221
- * @property refute - Optional {@link Func.bind} handle for the robustness battery.
222
- * @property dose - Optional {@link Func.bind} handle for the dose-response curve.
223
- * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
224
- * @property columnMeta - Optional per-column display metadata.
225
- * @property readonly - Render without mutation affordances.
226
- * @property defaultTab - Initial result tab.
227
- */
228
217
  /**
229
218
  * Per-column display config — the friendly label, unit suffix, and good
230
219
  * direction the surface uses to phrase results ("worse" instead of "lower").
@@ -246,12 +235,29 @@ export interface ExperimentColumnConfig {
246
235
  export type ExperimentColumns<Row extends StructType> = {
247
236
  [K in Extract<keyof Row['fields'], string>]?: ExperimentColumnConfig;
248
237
  };
238
+ /**
239
+ * Options for {@link Experiment.Root}, generic over the input row struct.
240
+ *
241
+ * @typeParam Row - The input dataset's row struct — inferred from `data`.
242
+ *
243
+ * @property data - The {@link Data.bind} handle for the input dataset.
244
+ * @property config - The {@link Data.bind} handle for the staged experiment config.
245
+ * @property experiment - The {@link Func.bind} handle for the experiment function.
246
+ * @property population - Optional {@link Data.bind} handle for the staged Step-4
247
+ * population filter (a {@link PopulationType}); narrows the rows UI-side before
248
+ * the call. Bind it (seeded) to start with filters applied.
249
+ * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
250
+ * @property columns - Optional per-column display config.
251
+ * @property readonly - Render without mutation affordances.
252
+ * @property defaultTab - Initial result tab.
253
+ */
249
254
  export interface ExperimentOptions<Row extends StructType> {
250
255
  data: BoundValue<ArrayType<Row>>;
251
- spec: BoundValue<ExperimentSpecType>;
252
- estimate: EstimateFunc<Row>;
253
- refute?: RefuteFunc<Row>;
254
- dose?: DoseFunc<Row>;
256
+ config: BoundValue<ExperimentConfigType>;
257
+ experiment: ExperimentFunc<Row>;
258
+ /** Optional `design` function — adds the "Validate" tab (the trial recipe). */
259
+ design?: ExperimentDesignFunc<Row>;
260
+ population?: BoundValue<PopulationType>;
255
261
  journal?: BoundValue<JournalType>;
256
262
  /** Per-column display config, keyed by the data row's fields (like `Table`). */
257
263
  columns?: ExperimentColumns<Row>;
@@ -259,25 +265,24 @@ export interface ExperimentOptions<Row extends StructType> {
259
265
  defaultTab?: ExperimentTabLiteral;
260
266
  }
261
267
  /**
262
- * Build an Experiment surface bound to an input dataset + estimator functions.
268
+ * Build an Experiment surface bound to an input dataset + the single experiment
269
+ * function.
263
270
  *
264
271
  * @typeParam Row - The input dataset's row struct, inferred from `data`.
265
- * @param options - {@link ExperimentOptions}. `data`, `spec` and `estimate` are
266
- * required; the rest are optional.
272
+ * @param options - {@link ExperimentOptions}. `data`, `config` and `experiment`
273
+ * are required; the rest are optional.
267
274
  * @returns An East expression of {@link UIComponentType}.
268
275
  */
269
276
  declare function createExperiment<Row extends StructType>(options: ExperimentOptions<Row>): ExprType<UIComponentType>;
270
277
  /**
271
278
  * The Experiment component namespace. Surfaces an interactive causal-experiment
272
- * over a bound input dataset + estimator functions, generic over the row struct
273
- * (the `Table` pattern), with the staged-binding machinery the rest of e3-ui
274
- * uses.
279
+ * over a bound input dataset + a single `experiment` function, generic over the
280
+ * row struct (the `Table` pattern).
275
281
  *
276
282
  * @remarks
277
- * Use `Experiment.Root({ data, spec, estimate, refute, dose, journal })` inside
278
- * a `Reactive` block. The `Component` property is the {@link EastUI.component}
279
- * carrier the renderer registers against; `Types` exposes the render-contract
280
- * value types (`Spec`, `Result`, `Refute`, `Dose`, `Journal`, …).
283
+ * Use `Experiment.Root({ data, config, experiment, journal })` inside a
284
+ * `Reactive` block. `Types` exposes the render-contract value types (`Config`,
285
+ * `Result`, `Verdict`, `Overlap`, `Balance`, `Refutation`, `Journal`, …).
281
286
  */
282
287
  export declare const Experiment: {
283
288
  readonly Root: typeof createExperiment;
@@ -285,52 +290,62 @@ export declare const Experiment: {
285
290
  readonly Component: import("@elaraai/east-ui").UIComponentDef<StructType<{
286
291
  readonly data: StructType<{
287
292
  readonly source: ArrayType<VariantType<{
288
- readonly field: StringType;
293
+ readonly field: import("@elaraai/east").StringType;
289
294
  }>>;
290
295
  readonly patch: OptionType<ArrayType<VariantType<{
291
- readonly field: StringType;
296
+ readonly field: import("@elaraai/east").StringType;
292
297
  }>>>;
293
298
  readonly mode: VariantType<{
294
299
  readonly staged: NullType;
295
300
  readonly direct: NullType;
296
301
  }>;
297
302
  }>;
298
- readonly spec: StructType<{
303
+ readonly config: StructType<{
299
304
  readonly source: ArrayType<VariantType<{
300
- readonly field: StringType;
305
+ readonly field: import("@elaraai/east").StringType;
301
306
  }>>;
302
307
  readonly patch: OptionType<ArrayType<VariantType<{
303
- readonly field: StringType;
308
+ readonly field: import("@elaraai/east").StringType;
304
309
  }>>>;
305
310
  readonly mode: VariantType<{
306
311
  readonly staged: NullType;
307
312
  readonly direct: NullType;
308
313
  }>;
309
314
  }>;
310
- readonly estimate: StructType<{
311
- readonly name: StringType;
315
+ readonly experiment: StructType<{
316
+ readonly name: import("@elaraai/east").StringType;
312
317
  }>;
313
- readonly refute: OptionType<StructType<{
314
- readonly name: StringType;
315
- }>>;
316
- readonly dose: OptionType<StructType<{
317
- readonly name: StringType;
318
+ readonly population: OptionType<StructType<{
319
+ readonly source: ArrayType<VariantType<{
320
+ readonly field: import("@elaraai/east").StringType;
321
+ }>>;
322
+ readonly patch: OptionType<ArrayType<VariantType<{
323
+ readonly field: import("@elaraai/east").StringType;
324
+ }>>>;
325
+ readonly mode: VariantType<{
326
+ readonly staged: NullType;
327
+ readonly direct: NullType;
328
+ }>;
318
329
  }>>;
319
330
  readonly journal: OptionType<StructType<{
320
331
  readonly source: ArrayType<VariantType<{
321
- readonly field: StringType;
332
+ readonly field: import("@elaraai/east").StringType;
322
333
  }>>;
323
334
  readonly patch: OptionType<ArrayType<VariantType<{
324
- readonly field: StringType;
335
+ readonly field: import("@elaraai/east").StringType;
325
336
  }>>>;
326
337
  readonly mode: VariantType<{
327
338
  readonly staged: NullType;
328
339
  readonly direct: NullType;
329
340
  }>;
330
341
  }>>;
331
- readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
332
- readonly label: OptionType<StringType>;
333
- readonly unit: OptionType<StringType>;
342
+ /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
343
+ readonly design: OptionType<StructType<{
344
+ readonly name: import("@elaraai/east").StringType;
345
+ }>>;
346
+ readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
347
+ readonly label: OptionType<import("@elaraai/east").StringType>;
348
+ readonly unit: OptionType<import("@elaraai/east").StringType>;
334
349
  readonly higherIsBetter: OptionType<BooleanType>;
335
350
  }>>>;
336
351
  readonly readonly: OptionType<BooleanType>;
@@ -338,6 +353,7 @@ export declare const Experiment: {
338
353
  readonly answer: NullType;
339
354
  readonly trust: NullType;
340
355
  readonly dose: NullType;
356
+ readonly validate: NullType;
341
357
  }>>;
342
358
  }>>;
343
359
  readonly Types: {
@@ -345,52 +361,62 @@ export declare const Experiment: {
345
361
  readonly Payload: StructType<{
346
362
  readonly data: StructType<{
347
363
  readonly source: ArrayType<VariantType<{
348
- readonly field: StringType;
364
+ readonly field: import("@elaraai/east").StringType;
349
365
  }>>;
350
366
  readonly patch: OptionType<ArrayType<VariantType<{
351
- readonly field: StringType;
367
+ readonly field: import("@elaraai/east").StringType;
352
368
  }>>>;
353
369
  readonly mode: VariantType<{
354
370
  readonly staged: NullType;
355
371
  readonly direct: NullType;
356
372
  }>;
357
373
  }>;
358
- readonly spec: StructType<{
374
+ readonly config: StructType<{
359
375
  readonly source: ArrayType<VariantType<{
360
- readonly field: StringType;
376
+ readonly field: import("@elaraai/east").StringType;
361
377
  }>>;
362
378
  readonly patch: OptionType<ArrayType<VariantType<{
363
- readonly field: StringType;
379
+ readonly field: import("@elaraai/east").StringType;
364
380
  }>>>;
365
381
  readonly mode: VariantType<{
366
382
  readonly staged: NullType;
367
383
  readonly direct: NullType;
368
384
  }>;
369
385
  }>;
370
- readonly estimate: StructType<{
371
- readonly name: StringType;
386
+ readonly experiment: StructType<{
387
+ readonly name: import("@elaraai/east").StringType;
372
388
  }>;
373
- readonly refute: OptionType<StructType<{
374
- readonly name: StringType;
375
- }>>;
376
- readonly dose: OptionType<StructType<{
377
- readonly name: StringType;
389
+ readonly population: OptionType<StructType<{
390
+ readonly source: ArrayType<VariantType<{
391
+ readonly field: import("@elaraai/east").StringType;
392
+ }>>;
393
+ readonly patch: OptionType<ArrayType<VariantType<{
394
+ readonly field: import("@elaraai/east").StringType;
395
+ }>>>;
396
+ readonly mode: VariantType<{
397
+ readonly staged: NullType;
398
+ readonly direct: NullType;
399
+ }>;
378
400
  }>>;
379
401
  readonly journal: OptionType<StructType<{
380
402
  readonly source: ArrayType<VariantType<{
381
- readonly field: StringType;
403
+ readonly field: import("@elaraai/east").StringType;
382
404
  }>>;
383
405
  readonly patch: OptionType<ArrayType<VariantType<{
384
- readonly field: StringType;
406
+ readonly field: import("@elaraai/east").StringType;
385
407
  }>>>;
386
408
  readonly mode: VariantType<{
387
409
  readonly staged: NullType;
388
410
  readonly direct: NullType;
389
411
  }>;
390
412
  }>>;
391
- readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
392
- readonly label: OptionType<StringType>;
393
- readonly unit: OptionType<StringType>;
413
+ /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
414
+ readonly design: OptionType<StructType<{
415
+ readonly name: import("@elaraai/east").StringType;
416
+ }>>;
417
+ readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
418
+ readonly label: OptionType<import("@elaraai/east").StringType>;
419
+ readonly unit: OptionType<import("@elaraai/east").StringType>;
394
420
  readonly higherIsBetter: OptionType<BooleanType>;
395
421
  }>>>;
396
422
  readonly readonly: OptionType<BooleanType>;
@@ -398,65 +424,15 @@ export declare const Experiment: {
398
424
  readonly answer: NullType;
399
425
  readonly trust: NullType;
400
426
  readonly dose: NullType;
427
+ readonly validate: NullType;
401
428
  }>>;
402
429
  }>;
403
- /** The experiment-spec value type (what the pickers stage). */
404
- readonly Spec: StructType<{
405
- readonly treatment: StringType;
406
- readonly outcome: StringType;
407
- readonly confounders: ArrayType<StringType>;
408
- readonly categorical: ArrayType<StringType>;
409
- readonly population: OptionType<ArrayType<VariantType<{
410
- readonly string: import("@elaraai/east").StructType<{
411
- readonly fieldId: import("@elaraai/east").StringType;
412
- readonly op: import("@elaraai/east").VariantType<{
413
- readonly eq: import("@elaraai/east").StringType;
414
- readonly neq: import("@elaraai/east").StringType;
415
- readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
416
- readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
417
- readonly contains: import("@elaraai/east").StringType;
418
- readonly matches: import("@elaraai/east").StringType;
419
- }>;
420
- }>;
421
- readonly integer: import("@elaraai/east").StructType<{
422
- readonly fieldId: import("@elaraai/east").StringType;
423
- readonly op: import("@elaraai/east").VariantType<{
424
- readonly eq: import("@elaraai/east").IntegerType;
425
- readonly neq: import("@elaraai/east").IntegerType;
426
- readonly lt: import("@elaraai/east").IntegerType;
427
- readonly lte: import("@elaraai/east").IntegerType;
428
- readonly gt: import("@elaraai/east").IntegerType;
429
- readonly gte: import("@elaraai/east").IntegerType;
430
- readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
431
- }>;
432
- }>;
433
- readonly float: import("@elaraai/east").StructType<{
434
- readonly fieldId: import("@elaraai/east").StringType;
435
- readonly op: import("@elaraai/east").VariantType<{
436
- readonly lt: import("@elaraai/east").FloatType;
437
- readonly lte: import("@elaraai/east").FloatType;
438
- readonly gt: import("@elaraai/east").FloatType;
439
- readonly gte: import("@elaraai/east").FloatType;
440
- }>;
441
- }>;
442
- readonly datetime: import("@elaraai/east").StructType<{
443
- readonly fieldId: import("@elaraai/east").StringType;
444
- readonly op: import("@elaraai/east").VariantType<{
445
- readonly before: import("@elaraai/east").DateTimeType;
446
- readonly after: import("@elaraai/east").DateTimeType;
447
- readonly between: import("@elaraai/east").StructType<{
448
- readonly from: import("@elaraai/east").DateTimeType;
449
- readonly to: import("@elaraai/east").DateTimeType;
450
- }>;
451
- }>;
452
- }>;
453
- readonly boolean: import("@elaraai/east").StructType<{
454
- readonly fieldId: import("@elaraai/east").StringType;
455
- readonly op: import("@elaraai/east").VariantType<{
456
- readonly is: import("@elaraai/east").BooleanType;
457
- }>;
458
- }>;
459
- }>>>;
430
+ /** The experiment-config value type (what the pickers stage). */
431
+ readonly Config: StructType<{
432
+ readonly treatment: import("@elaraai/east").StringType;
433
+ readonly outcome: import("@elaraai/east").StringType;
434
+ readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
435
+ readonly categorical: OptionType<ArrayType<import("@elaraai/east").StringType>>;
460
436
  readonly method: OptionType<VariantType<{
461
437
  readonly linear_regression: NullType;
462
438
  readonly propensity_score_weighting: StructType<{
@@ -467,131 +443,102 @@ export declare const Experiment: {
467
443
  }>>;
468
444
  }>;
469
445
  }>>;
470
- readonly targetUnits: OptionType<VariantType<{
446
+ readonly estimand: OptionType<VariantType<{
471
447
  readonly ate: NullType;
472
448
  readonly att: NullType;
473
449
  readonly atc: NullType;
474
450
  }>>;
475
- readonly trim: OptionType<VariantType<{
476
- readonly overlap: NullType;
477
- readonly bounds: StructType<{
478
- readonly lower: import("@elaraai/east").FloatType;
479
- readonly upper: import("@elaraai/east").FloatType;
480
- }>;
451
+ readonly refute: OptionType<StructType<{
452
+ readonly placebo: BooleanType;
453
+ readonly random_common_cause: BooleanType;
454
+ readonly data_subset: BooleanType;
455
+ readonly sensitivity: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
456
+ }>>;
457
+ readonly dose_feature: OptionType<import("@elaraai/east").StringType>;
458
+ readonly min_overlap: OptionType<import("@elaraai/east").FloatType>;
459
+ readonly min_treatment_variation: OptionType<import("@elaraai/east").FloatType>;
460
+ readonly bootstrap: OptionType<StructType<{
461
+ readonly reps: import("@elaraai/east").IntegerType;
462
+ readonly cluster_column: OptionType<import("@elaraai/east").StringType>;
463
+ readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
481
464
  }>>;
465
+ readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
482
466
  }>;
483
- /** The estimator answer value type. */
467
+ /** The result value type (numbers + verdict). */
484
468
  readonly Result: StructType<{
485
- readonly effect: import("@elaraai/east").FloatType;
486
- readonly ci: OptionType<StructType<{
487
- readonly lower: import("@elaraai/east").FloatType;
488
- readonly upper: import("@elaraai/east").FloatType;
489
- }>>;
490
469
  readonly naive: import("@elaraai/east").FloatType;
491
- readonly naiveCi: OptionType<StructType<{
470
+ readonly naive_ci: OptionType<StructType<{
492
471
  readonly lower: import("@elaraai/east").FloatType;
493
472
  readonly upper: import("@elaraai/east").FloatType;
494
473
  }>>;
495
- readonly nTotal: import("@elaraai/east").IntegerType;
496
- readonly nTreated: import("@elaraai/east").IntegerType;
497
- readonly nControl: import("@elaraai/east").IntegerType;
498
- readonly nDropped: import("@elaraai/east").IntegerType;
474
+ readonly adjusted: OptionType<StructType<{
475
+ readonly effect: import("@elaraai/east").FloatType;
476
+ readonly ci: OptionType<StructType<{
477
+ readonly lower: import("@elaraai/east").FloatType;
478
+ readonly upper: import("@elaraai/east").FloatType;
479
+ }>>;
480
+ }>>;
481
+ readonly n_total: import("@elaraai/east").IntegerType;
482
+ readonly n_treated: import("@elaraai/east").IntegerType;
483
+ readonly n_control: import("@elaraai/east").IntegerType;
484
+ readonly n_dropped: import("@elaraai/east").IntegerType;
499
485
  readonly balance: ArrayType<StructType<{
500
- readonly column: StringType;
501
- readonly treatedMean: import("@elaraai/east").FloatType;
502
- readonly controlMean: import("@elaraai/east").FloatType;
503
- readonly stdDiff: import("@elaraai/east").FloatType;
486
+ readonly column: import("@elaraai/east").StringType;
487
+ readonly base_column: import("@elaraai/east").StringType;
488
+ readonly treated_mean: import("@elaraai/east").FloatType;
489
+ readonly control_mean: import("@elaraai/east").FloatType;
490
+ readonly std_diff: import("@elaraai/east").FloatType;
504
491
  }>>;
505
- }>;
506
- /** The robustness-battery value type. */
507
- readonly Refute: StructType<{
508
- readonly checks: ArrayType<StructType<{
509
- readonly kind: VariantType<{
510
- readonly placebo: NullType;
511
- readonly random_common_cause: NullType;
512
- readonly data_subset: NullType;
513
- readonly unobserved: NullType;
514
- }>;
515
- readonly estimatedEffect: import("@elaraai/east").FloatType;
516
- readonly newEffects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
517
- readonly strengths: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
518
- readonly pValue: OptionType<import("@elaraai/east").FloatType>;
492
+ readonly overlap: StructType<{
493
+ readonly treated_propensity: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
494
+ readonly control_propensity: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
495
+ readonly common_support_frac: import("@elaraai/east").FloatType;
496
+ readonly positivity_ok: BooleanType;
497
+ }>;
498
+ readonly refutation: OptionType<StructType<{
499
+ readonly placebo_effect: OptionType<import("@elaraai/east").FloatType>;
500
+ readonly placebo_passes: OptionType<BooleanType>;
501
+ readonly random_cc_within_ci: OptionType<BooleanType>;
502
+ readonly data_subset_effect: OptionType<import("@elaraai/east").FloatType>;
503
+ readonly data_subset_std: OptionType<import("@elaraai/east").FloatType>;
504
+ readonly robustness_value: OptionType<import("@elaraai/east").FloatType>;
505
+ readonly sensitivity: OptionType<StructType<{
506
+ readonly strengths: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
507
+ readonly effects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
508
+ }>>;
509
+ }>>;
510
+ readonly dose_response: OptionType<StructType<{
511
+ readonly feature: import("@elaraai/east").StringType;
512
+ readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
513
+ readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
514
+ readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
515
+ readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
516
+ readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
519
517
  }>>;
518
+ readonly verdict: VariantType<{
519
+ readonly causal: NullType;
520
+ readonly modest: NullType;
521
+ readonly adjustment_insufficient: NullType;
522
+ readonly non_identifiable_positivity: NullType;
523
+ readonly not_estimable: import("@elaraai/east").StringType;
524
+ }>;
520
525
  }>;
521
- /** The dose-response value type. */
522
- readonly Dose: StructType<{
523
- readonly feature: StringType;
526
+ /** The ALE dose-response curve value type (the "How much?" tab). */
527
+ readonly DoseResponse: StructType<{
528
+ readonly feature: import("@elaraai/east").StringType;
524
529
  readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
525
530
  readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
526
531
  readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
527
532
  readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
528
533
  readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
529
- readonly segments: OptionType<ArrayType<StructType<{
530
- readonly label: StringType;
531
- readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
532
- readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
533
- readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
534
- readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
535
- }>>>;
536
534
  }>;
537
535
  /** The committed-experiment journal value type. */
538
536
  readonly Journal: ArrayType<StructType<{
539
- readonly spec: StructType<{
540
- readonly treatment: StringType;
541
- readonly outcome: StringType;
542
- readonly confounders: ArrayType<StringType>;
543
- readonly categorical: ArrayType<StringType>;
544
- readonly population: OptionType<ArrayType<VariantType<{
545
- readonly string: import("@elaraai/east").StructType<{
546
- readonly fieldId: import("@elaraai/east").StringType;
547
- readonly op: import("@elaraai/east").VariantType<{
548
- readonly eq: import("@elaraai/east").StringType;
549
- readonly neq: import("@elaraai/east").StringType;
550
- readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
551
- readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
552
- readonly contains: import("@elaraai/east").StringType;
553
- readonly matches: import("@elaraai/east").StringType;
554
- }>;
555
- }>;
556
- readonly integer: import("@elaraai/east").StructType<{
557
- readonly fieldId: import("@elaraai/east").StringType;
558
- readonly op: import("@elaraai/east").VariantType<{
559
- readonly eq: import("@elaraai/east").IntegerType;
560
- readonly neq: import("@elaraai/east").IntegerType;
561
- readonly lt: import("@elaraai/east").IntegerType;
562
- readonly lte: import("@elaraai/east").IntegerType;
563
- readonly gt: import("@elaraai/east").IntegerType;
564
- readonly gte: import("@elaraai/east").IntegerType;
565
- readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
566
- }>;
567
- }>;
568
- readonly float: import("@elaraai/east").StructType<{
569
- readonly fieldId: import("@elaraai/east").StringType;
570
- readonly op: import("@elaraai/east").VariantType<{
571
- readonly lt: import("@elaraai/east").FloatType;
572
- readonly lte: import("@elaraai/east").FloatType;
573
- readonly gt: import("@elaraai/east").FloatType;
574
- readonly gte: import("@elaraai/east").FloatType;
575
- }>;
576
- }>;
577
- readonly datetime: import("@elaraai/east").StructType<{
578
- readonly fieldId: import("@elaraai/east").StringType;
579
- readonly op: import("@elaraai/east").VariantType<{
580
- readonly before: import("@elaraai/east").DateTimeType;
581
- readonly after: import("@elaraai/east").DateTimeType;
582
- readonly between: import("@elaraai/east").StructType<{
583
- readonly from: import("@elaraai/east").DateTimeType;
584
- readonly to: import("@elaraai/east").DateTimeType;
585
- }>;
586
- }>;
587
- }>;
588
- readonly boolean: import("@elaraai/east").StructType<{
589
- readonly fieldId: import("@elaraai/east").StringType;
590
- readonly op: import("@elaraai/east").VariantType<{
591
- readonly is: import("@elaraai/east").BooleanType;
592
- }>;
593
- }>;
594
- }>>>;
537
+ readonly config: StructType<{
538
+ readonly treatment: import("@elaraai/east").StringType;
539
+ readonly outcome: import("@elaraai/east").StringType;
540
+ readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
541
+ readonly categorical: OptionType<ArrayType<import("@elaraai/east").StringType>>;
595
542
  readonly method: OptionType<VariantType<{
596
543
  readonly linear_regression: NullType;
597
544
  readonly propensity_score_weighting: StructType<{
@@ -602,31 +549,137 @@ export declare const Experiment: {
602
549
  }>>;
603
550
  }>;
604
551
  }>>;
605
- readonly targetUnits: OptionType<VariantType<{
552
+ readonly estimand: OptionType<VariantType<{
606
553
  readonly ate: NullType;
607
554
  readonly att: NullType;
608
555
  readonly atc: NullType;
609
556
  }>>;
610
- readonly trim: OptionType<VariantType<{
611
- readonly overlap: NullType;
612
- readonly bounds: StructType<{
613
- readonly lower: import("@elaraai/east").FloatType;
614
- readonly upper: import("@elaraai/east").FloatType;
615
- }>;
557
+ readonly refute: OptionType<StructType<{
558
+ readonly placebo: BooleanType;
559
+ readonly random_common_cause: BooleanType;
560
+ readonly data_subset: BooleanType;
561
+ readonly sensitivity: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
562
+ }>>;
563
+ readonly dose_feature: OptionType<import("@elaraai/east").StringType>;
564
+ readonly min_overlap: OptionType<import("@elaraai/east").FloatType>;
565
+ readonly min_treatment_variation: OptionType<import("@elaraai/east").FloatType>;
566
+ readonly bootstrap: OptionType<StructType<{
567
+ readonly reps: import("@elaraai/east").IntegerType;
568
+ readonly cluster_column: OptionType<import("@elaraai/east").StringType>;
569
+ readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
616
570
  }>>;
571
+ readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
617
572
  }>;
618
- readonly effect: import("@elaraai/east").FloatType;
619
- readonly ci: OptionType<StructType<{
620
- readonly lower: import("@elaraai/east").FloatType;
621
- readonly upper: import("@elaraai/east").FloatType;
573
+ readonly verdict: VariantType<{
574
+ readonly causal: NullType;
575
+ readonly modest: NullType;
576
+ readonly adjustment_insufficient: NullType;
577
+ readonly non_identifiable_positivity: NullType;
578
+ readonly not_estimable: import("@elaraai/east").StringType;
579
+ }>;
580
+ readonly naive: import("@elaraai/east").FloatType;
581
+ readonly adjusted: OptionType<import("@elaraai/east").FloatType>;
582
+ readonly committed_at: import("@elaraai/east").DateTimeType;
583
+ readonly committed_by: import("@elaraai/east").StringType;
584
+ }>>;
585
+ /** The validation-trial recipe value type (the "Validate" tab). */
586
+ readonly Design: StructType<{
587
+ readonly verdict: VariantType<{
588
+ readonly causal: NullType;
589
+ readonly modest: NullType;
590
+ readonly adjustment_insufficient: NullType;
591
+ readonly non_identifiable_positivity: NullType;
592
+ readonly not_estimable: import("@elaraai/east").StringType;
593
+ }>;
594
+ readonly basis: VariantType<{
595
+ readonly detect_observed: NullType;
596
+ readonly resolve_vs_null: NullType;
597
+ readonly de_bias: NullType;
598
+ readonly restrict_to_overlap: NullType;
599
+ readonly create_control: NullType;
600
+ }>;
601
+ readonly target_effect: import("@elaraai/east").FloatType;
602
+ readonly outcome_sd: import("@elaraai/east").FloatType;
603
+ readonly target_power: import("@elaraai/east").FloatType;
604
+ readonly alpha: import("@elaraai/east").FloatType;
605
+ readonly current_power: OptionType<import("@elaraai/east").FloatType>;
606
+ readonly match_on: ArrayType<import("@elaraai/east").StringType>;
607
+ readonly options: ArrayType<StructType<{
608
+ readonly label: import("@elaraai/east").StringType;
609
+ readonly treated_share: import("@elaraai/east").FloatType;
610
+ readonly n_treated: import("@elaraai/east").IntegerType;
611
+ readonly n_control: import("@elaraai/east").IntegerType;
612
+ readonly n_total: import("@elaraai/east").IntegerType;
622
613
  }>>;
623
- readonly committedAt: import("@elaraai/east").DateTimeType;
624
- readonly committedBy: StringType;
614
+ readonly power_curve: StructType<{
615
+ readonly n: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
616
+ readonly power: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
617
+ }>;
618
+ readonly rationale: import("@elaraai/east").StringType;
619
+ }>;
620
+ /** The optional design-knobs value type. */
621
+ readonly DesignConfig: StructType<{
622
+ readonly alpha: OptionType<import("@elaraai/east").FloatType>;
623
+ readonly target_power: OptionType<import("@elaraai/east").FloatType>;
624
+ readonly materiality: OptionType<import("@elaraai/east").FloatType>;
625
+ readonly treated_shares: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
626
+ }>;
627
+ /** The UI-side Step-4 population filter value type (Array of Slice predicates). */
628
+ readonly Population: ArrayType<VariantType<{
629
+ readonly string: import("@elaraai/east").StructType<{
630
+ readonly fieldId: import("@elaraai/east").StringType;
631
+ readonly op: import("@elaraai/east").VariantType<{
632
+ readonly eq: import("@elaraai/east").StringType;
633
+ readonly neq: import("@elaraai/east").StringType;
634
+ readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
635
+ readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
636
+ readonly contains: import("@elaraai/east").StringType;
637
+ readonly matches: import("@elaraai/east").StringType;
638
+ }>;
639
+ }>;
640
+ readonly integer: import("@elaraai/east").StructType<{
641
+ readonly fieldId: import("@elaraai/east").StringType;
642
+ readonly op: import("@elaraai/east").VariantType<{
643
+ readonly eq: import("@elaraai/east").IntegerType;
644
+ readonly neq: import("@elaraai/east").IntegerType;
645
+ readonly lt: import("@elaraai/east").IntegerType;
646
+ readonly lte: import("@elaraai/east").IntegerType;
647
+ readonly gt: import("@elaraai/east").IntegerType;
648
+ readonly gte: import("@elaraai/east").IntegerType;
649
+ readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
650
+ }>;
651
+ }>;
652
+ readonly float: import("@elaraai/east").StructType<{
653
+ readonly fieldId: import("@elaraai/east").StringType;
654
+ readonly op: import("@elaraai/east").VariantType<{
655
+ readonly lt: import("@elaraai/east").FloatType;
656
+ readonly lte: import("@elaraai/east").FloatType;
657
+ readonly gt: import("@elaraai/east").FloatType;
658
+ readonly gte: import("@elaraai/east").FloatType;
659
+ }>;
660
+ }>;
661
+ readonly datetime: import("@elaraai/east").StructType<{
662
+ readonly fieldId: import("@elaraai/east").StringType;
663
+ readonly op: import("@elaraai/east").VariantType<{
664
+ readonly before: import("@elaraai/east").DateTimeType;
665
+ readonly after: import("@elaraai/east").DateTimeType;
666
+ readonly between: import("@elaraai/east").StructType<{
667
+ readonly from: import("@elaraai/east").DateTimeType;
668
+ readonly to: import("@elaraai/east").DateTimeType;
669
+ }>;
670
+ }>;
671
+ }>;
672
+ readonly boolean: import("@elaraai/east").StructType<{
673
+ readonly fieldId: import("@elaraai/east").StringType;
674
+ readonly op: import("@elaraai/east").VariantType<{
675
+ readonly is: import("@elaraai/east").BooleanType;
676
+ }>;
677
+ }>;
625
678
  }>>;
626
679
  /** Optional per-column display metadata. */
627
- readonly ColumnMeta: import("@elaraai/east").DictType<StringType, StructType<{
628
- readonly label: OptionType<StringType>;
629
- readonly unit: OptionType<StringType>;
680
+ readonly ColumnMeta: import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
681
+ readonly label: OptionType<import("@elaraai/east").StringType>;
682
+ readonly unit: OptionType<import("@elaraai/east").StringType>;
630
683
  readonly higherIsBetter: OptionType<BooleanType>;
631
684
  }>>;
632
685
  /** Initial result tab variant. */
@@ -634,6 +687,7 @@ export declare const Experiment: {
634
687
  readonly answer: NullType;
635
688
  readonly trust: NullType;
636
689
  readonly dose: NullType;
690
+ readonly validate: NullType;
637
691
  }>;
638
692
  };
639
693
  };