@elaraai/e3-ui 1.0.4 → 1.0.5

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

@@ -0,0 +1,1338 @@
+/**
+ * The Decision platform types — the lean envelope a reasoning/optimization task
+ * emits and the Decide components render. Designed to be filled in one shot by
+ * an agent: 5 required fields, the rest optional; primitives over structs;
+ * display reuses east-ui's `Format` (no bespoke unit strings).
+ *
+ * Three data sources with different lifecycles (NOT one fat struct):
+ *   - DecisionType        : the optimizer's argument for ONE decision (read-mostly)
+ *   - ReferenceType       : similar past decisions (separate history dataset, joined by caseId)
+ *   - JudgementInputType  : the operator's notes + injected constraints + verdict (staged input — written back)
+ *
+ * run / model / audit / freshness / commit-state come from the e3 platform
+ * (DataflowRun, DatasetRef, binding.status()), not from these values.
+ *
+ * Lives alongside OntologyType — the platform's canonical decision envelope that
+ * the Decide component family (DecisionQueue, …) binds to and renders.
+ */
+import { StructType, VariantType, ArrayType, DictType, OptionType, StringType, FloatType, IntegerType, BooleanType, DateTimeType, NullType, SetType, FunctionType, type SubtypeExprOrValue, type ExprType, type EastType } from "@elaraai/east";
+/** east-ui value-format descriptor (currency / percent / compact / unit / …). */
+declare const TickFormat: VariantType<{
+    readonly number: import("@elaraai/east").StructType<{
+        readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly auto: import("@elaraai/east").NullType;
+            readonly never: import("@elaraai/east").NullType;
+            readonly always: import("@elaraai/east").NullType;
+            readonly exceptZero: import("@elaraai/east").NullType;
+        }>>;
+    }>;
+    readonly currency: import("@elaraai/east").StructType<{
+        readonly currency: import("@elaraai/east").VariantType<{
+            readonly USD: import("@elaraai/east").NullType;
+            readonly EUR: import("@elaraai/east").NullType;
+            readonly GBP: import("@elaraai/east").NullType;
+            readonly JPY: import("@elaraai/east").NullType;
+            readonly CHF: import("@elaraai/east").NullType;
+            readonly CAD: import("@elaraai/east").NullType;
+            readonly AUD: import("@elaraai/east").NullType;
+            readonly NZD: import("@elaraai/east").NullType;
+            readonly CNY: import("@elaraai/east").NullType;
+            readonly HKD: import("@elaraai/east").NullType;
+            readonly SGD: import("@elaraai/east").NullType;
+            readonly KRW: import("@elaraai/east").NullType;
+            readonly INR: import("@elaraai/east").NullType;
+            readonly TWD: import("@elaraai/east").NullType;
+            readonly THB: import("@elaraai/east").NullType;
+            readonly MYR: import("@elaraai/east").NullType;
+            readonly IDR: import("@elaraai/east").NullType;
+            readonly PHP: import("@elaraai/east").NullType;
+            readonly VND: import("@elaraai/east").NullType;
+            readonly SEK: import("@elaraai/east").NullType;
+            readonly NOK: import("@elaraai/east").NullType;
+            readonly DKK: import("@elaraai/east").NullType;
+            readonly PLN: import("@elaraai/east").NullType;
+            readonly CZK: import("@elaraai/east").NullType;
+            readonly HUF: import("@elaraai/east").NullType;
+            readonly RUB: import("@elaraai/east").NullType;
+            readonly UAH: import("@elaraai/east").NullType;
+            readonly RON: import("@elaraai/east").NullType;
+            readonly MXN: import("@elaraai/east").NullType;
+            readonly BRL: import("@elaraai/east").NullType;
+            readonly ARS: import("@elaraai/east").NullType;
+            readonly CLP: import("@elaraai/east").NullType;
+            readonly COP: import("@elaraai/east").NullType;
+            readonly PEN: import("@elaraai/east").NullType;
+            readonly AED: import("@elaraai/east").NullType;
+            readonly SAR: import("@elaraai/east").NullType;
+            readonly ILS: import("@elaraai/east").NullType;
+            readonly ZAR: import("@elaraai/east").NullType;
+            readonly TRY: import("@elaraai/east").NullType;
+            readonly EGP: import("@elaraai/east").NullType;
+            readonly NGN: import("@elaraai/east").NullType;
+            readonly KES: import("@elaraai/east").NullType;
+        }>;
+        readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly code: import("@elaraai/east").NullType;
+            readonly symbol: import("@elaraai/east").NullType;
+            readonly narrowSymbol: import("@elaraai/east").NullType;
+            readonly name: import("@elaraai/east").NullType;
+        }>>;
+        readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly short: import("@elaraai/east").NullType;
+            readonly long: import("@elaraai/east").NullType;
+        }>>;
+        readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+    }>;
+    readonly percent: import("@elaraai/east").StructType<{
+        readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly auto: import("@elaraai/east").NullType;
+            readonly never: import("@elaraai/east").NullType;
+            readonly always: import("@elaraai/east").NullType;
+            readonly exceptZero: import("@elaraai/east").NullType;
+        }>>;
+    }>;
+    readonly compact: import("@elaraai/east").StructType<{
+        readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly short: import("@elaraai/east").NullType;
+            readonly long: import("@elaraai/east").NullType;
+        }>>;
+    }>;
+    readonly unit: import("@elaraai/east").StructType<{
+        readonly unit: import("@elaraai/east").VariantType<{
+            readonly bit: import("@elaraai/east").NullType;
+            readonly byte: import("@elaraai/east").NullType;
+            readonly kilobit: import("@elaraai/east").NullType;
+            readonly kilobyte: import("@elaraai/east").NullType;
+            readonly megabit: import("@elaraai/east").NullType;
+            readonly megabyte: import("@elaraai/east").NullType;
+            readonly gigabit: import("@elaraai/east").NullType;
+            readonly gigabyte: import("@elaraai/east").NullType;
+            readonly terabit: import("@elaraai/east").NullType;
+            readonly terabyte: import("@elaraai/east").NullType;
+            readonly petabyte: import("@elaraai/east").NullType;
+            readonly nanosecond: import("@elaraai/east").NullType;
+            readonly microsecond: import("@elaraai/east").NullType;
+            readonly millisecond: import("@elaraai/east").NullType;
+            readonly second: import("@elaraai/east").NullType;
+            readonly minute: import("@elaraai/east").NullType;
+            readonly hour: import("@elaraai/east").NullType;
+            readonly day: import("@elaraai/east").NullType;
+            readonly week: import("@elaraai/east").NullType;
+            readonly month: import("@elaraai/east").NullType;
+            readonly year: import("@elaraai/east").NullType;
+            readonly millimeter: import("@elaraai/east").NullType;
+            readonly centimeter: import("@elaraai/east").NullType;
+            readonly meter: import("@elaraai/east").NullType;
+            readonly kilometer: import("@elaraai/east").NullType;
+            readonly inch: import("@elaraai/east").NullType;
+            readonly foot: import("@elaraai/east").NullType;
+            readonly yard: import("@elaraai/east").NullType;
+            readonly mile: import("@elaraai/east").NullType;
+            readonly gram: import("@elaraai/east").NullType;
+            readonly kilogram: import("@elaraai/east").NullType;
+            readonly milligram: import("@elaraai/east").NullType;
+            readonly ounce: import("@elaraai/east").NullType;
+            readonly pound: import("@elaraai/east").NullType;
+            readonly stone: import("@elaraai/east").NullType;
+            readonly celsius: import("@elaraai/east").NullType;
+            readonly fahrenheit: import("@elaraai/east").NullType;
+            readonly milliliter: import("@elaraai/east").NullType;
+            readonly liter: import("@elaraai/east").NullType;
+            readonly gallon: import("@elaraai/east").NullType;
+            readonly fluidOunce: import("@elaraai/east").NullType;
+            readonly acre: import("@elaraai/east").NullType;
+            readonly hectare: import("@elaraai/east").NullType;
+            readonly meterPerSecond: import("@elaraai/east").NullType;
+            readonly kilometerPerHour: import("@elaraai/east").NullType;
+            readonly milePerHour: import("@elaraai/east").NullType;
+            readonly percent: import("@elaraai/east").NullType;
+            readonly degree: import("@elaraai/east").NullType;
+        }>;
+        readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly short: import("@elaraai/east").NullType;
+            readonly narrow: import("@elaraai/east").NullType;
+            readonly long: import("@elaraai/east").NullType;
+        }>>;
+    }>;
+    readonly scientific: import("@elaraai/east").NullType;
+    readonly engineering: import("@elaraai/east").NullType;
+    readonly date: import("@elaraai/east").StructType<{
+        readonly format: StringType;
+    }>;
+    readonly time: import("@elaraai/east").StructType<{
+        readonly format: StringType;
+    }>;
+    readonly datetime: import("@elaraai/east").StructType<{
+        readonly format: StringType;
+    }>;
+}>;
+type TickFormatType = typeof TickFormat;
+export declare const UrgencyType: VariantType<{
+    readonly overdue: NullType;
+    readonly due: NullType;
+    readonly routine: NullType;
+}>;
+export type UrgencyType = typeof UrgencyType;
+/**
+ * Stakes level classification for a decision.
+ *
+ * @property low - Routine consequence if wrong
+ * @property medium - Noticeable consequence; standard review
+ * @property high - Significant consequence; expect scrutiny
+ * @property critical - Irreversible-scale consequence; gates extra ceremony
+ */
+export declare const StakesLevelType: VariantType<{
+    readonly low: NullType;
+    readonly medium: NullType;
+    readonly high: NullType;
+    readonly critical: NullType;
+}>;
+/** Type alias for {@link StakesLevelType}. */
+export type StakesLevelType = typeof StakesLevelType;
+/** String-literal proxy for {@link StakesLevelType}. */
+export type StakesLevelLiteral = "low" | "medium" | "high" | "critical";
+/**
+ * One piece of the model's argument, rendered as a typed evidence chip.
+ *
+ * @property label - The evidence category ("forecast", "capacity", "track")
+ * @property text - The headline fact ("SE region +14%")
+ * @property note - Supporting context ("next 2 wks · holiday-demand driver")
+ */
+export declare const EvidenceType: StructType<{
+    readonly label: StringType;
+    readonly text: StringType;
+    readonly note: OptionType<StringType>;
+}>;
+/** Type alias for {@link EvidenceType}. */
+export type EvidenceType = typeof EvidenceType;
+/**
+ * One judgement question gating commit.
+ *
+ * @property id - Stable answer key — rewording `text` never orphans answers
+ * @property text - What the operator reads
+ */
+export declare const PromptType: StructType<{
+    readonly id: StringType;
+    readonly text: StringType;
+}>;
+/** Type alias for {@link PromptType}. */
+export type PromptType = typeof PromptType;
+/**
+ * One constrainable knob this case accepts — a case of the solution's
+ * constraint contract variant (see `JudgementInputType`'s type parameter).
+ *
+ * @property case - The contract variant's case name
+ * @property label - What the operator reads in the constraint builder
+ */
+export declare const LeverType: StructType<{
+    readonly case: StringType;
+    readonly label: StringType;
+}>;
+/** Type alias for {@link LeverType}. */
+export type LeverType = typeof LeverType;
+/**
+ * The captured response to one judgement prompt.
+ *
+ * @property yes - The operator stands behind the input
+ * @property no - The operator contradicts it — blocks commit
+ * @property unknown - The operator can't say — routes the case to handoff
+ */
+export declare const AnswerType: VariantType<{
+    readonly yes: NullType;
+    readonly no: NullType;
+    readonly unknown: NullType;
+}>;
+/** Type alias for {@link AnswerType}. */
+export type AnswerType = typeof AnswerType;
+/** String-literal proxy for {@link AnswerType}. */
+export type AnswerLiteral = "yes" | "no" | "unknown";
+/**
+ * The operator's final word on a case — how it left the queue.
+ *
+ * @property accepted - The chosen option's label (empty string accepts the
+ *   recommendation itself)
+ * @property rejected - The recommendation was rejected; the operator takes
+ *   the decision manually
+ * @property deferred - Put off, with an optional note ("revisit after wk 12")
+ * @property handoff - Routed to someone else — the recipient / routing note
+ *   (the "don't know" exit)
+ */
+export declare const VerdictType: VariantType<{
+    readonly accepted: StringType;
+    readonly rejected: NullType;
+    readonly deferred: OptionType<StringType>;
+    readonly handoff: StringType;
+}>;
+/** Type alias for {@link VerdictType}. */
+export type VerdictType = typeof VerdictType;
+export declare const DecisionOptionType: StructType<{
+    readonly id: OptionType<StringType>;
+    readonly label: StringType;
+    readonly value: FloatType;
+    readonly downside: OptionType<FloatType>;
+    readonly confidence: OptionType<FloatType>;
+    readonly note: OptionType<StringType>;
+}>;
+export type DecisionOptionType = typeof DecisionOptionType;
+export declare const DecisionType: StructType<{
+    readonly id: StringType;
+    readonly kind: StringType;
+    readonly title: StringType;
+    readonly urgency: VariantType<{
+        readonly overdue: NullType;
+        readonly due: NullType;
+        readonly routine: NullType;
+    }>;
+    readonly value: FloatType;
+    readonly deadline: OptionType<DateTimeType>;
+    readonly format: OptionType<VariantType<{
+        readonly number: import("@elaraai/east").StructType<{
+            readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly auto: import("@elaraai/east").NullType;
+                readonly never: import("@elaraai/east").NullType;
+                readonly always: import("@elaraai/east").NullType;
+                readonly exceptZero: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly currency: import("@elaraai/east").StructType<{
+            readonly currency: import("@elaraai/east").VariantType<{
+                readonly USD: import("@elaraai/east").NullType;
+                readonly EUR: import("@elaraai/east").NullType;
+                readonly GBP: import("@elaraai/east").NullType;
+                readonly JPY: import("@elaraai/east").NullType;
+                readonly CHF: import("@elaraai/east").NullType;
+                readonly CAD: import("@elaraai/east").NullType;
+                readonly AUD: import("@elaraai/east").NullType;
+                readonly NZD: import("@elaraai/east").NullType;
+                readonly CNY: import("@elaraai/east").NullType;
+                readonly HKD: import("@elaraai/east").NullType;
+                readonly SGD: import("@elaraai/east").NullType;
+                readonly KRW: import("@elaraai/east").NullType;
+                readonly INR: import("@elaraai/east").NullType;
+                readonly TWD: import("@elaraai/east").NullType;
+                readonly THB: import("@elaraai/east").NullType;
+                readonly MYR: import("@elaraai/east").NullType;
+                readonly IDR: import("@elaraai/east").NullType;
+                readonly PHP: import("@elaraai/east").NullType;
+                readonly VND: import("@elaraai/east").NullType;
+                readonly SEK: import("@elaraai/east").NullType;
+                readonly NOK: import("@elaraai/east").NullType;
+                readonly DKK: import("@elaraai/east").NullType;
+                readonly PLN: import("@elaraai/east").NullType;
+                readonly CZK: import("@elaraai/east").NullType;
+                readonly HUF: import("@elaraai/east").NullType;
+                readonly RUB: import("@elaraai/east").NullType;
+                readonly UAH: import("@elaraai/east").NullType;
+                readonly RON: import("@elaraai/east").NullType;
+                readonly MXN: import("@elaraai/east").NullType;
+                readonly BRL: import("@elaraai/east").NullType;
+                readonly ARS: import("@elaraai/east").NullType;
+                readonly CLP: import("@elaraai/east").NullType;
+                readonly COP: import("@elaraai/east").NullType;
+                readonly PEN: import("@elaraai/east").NullType;
+                readonly AED: import("@elaraai/east").NullType;
+                readonly SAR: import("@elaraai/east").NullType;
+                readonly ILS: import("@elaraai/east").NullType;
+                readonly ZAR: import("@elaraai/east").NullType;
+                readonly TRY: import("@elaraai/east").NullType;
+                readonly EGP: import("@elaraai/east").NullType;
+                readonly NGN: import("@elaraai/east").NullType;
+                readonly KES: import("@elaraai/east").NullType;
+            }>;
+            readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly code: import("@elaraai/east").NullType;
+                readonly symbol: import("@elaraai/east").NullType;
+                readonly narrowSymbol: import("@elaraai/east").NullType;
+                readonly name: import("@elaraai/east").NullType;
+            }>>;
+            readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly short: import("@elaraai/east").NullType;
+                readonly long: import("@elaraai/east").NullType;
+            }>>;
+            readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        }>;
+        readonly percent: import("@elaraai/east").StructType<{
+            readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly auto: import("@elaraai/east").NullType;
+                readonly never: import("@elaraai/east").NullType;
+                readonly always: import("@elaraai/east").NullType;
+                readonly exceptZero: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly compact: import("@elaraai/east").StructType<{
+            readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly short: import("@elaraai/east").NullType;
+                readonly long: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly unit: import("@elaraai/east").StructType<{
+            readonly unit: import("@elaraai/east").VariantType<{
+                readonly bit: import("@elaraai/east").NullType;
+                readonly byte: import("@elaraai/east").NullType;
+                readonly kilobit: import("@elaraai/east").NullType;
+                readonly kilobyte: import("@elaraai/east").NullType;
+                readonly megabit: import("@elaraai/east").NullType;
+                readonly megabyte: import("@elaraai/east").NullType;
+                readonly gigabit: import("@elaraai/east").NullType;
+                readonly gigabyte: import("@elaraai/east").NullType;
+                readonly terabit: import("@elaraai/east").NullType;
+                readonly terabyte: import("@elaraai/east").NullType;
+                readonly petabyte: import("@elaraai/east").NullType;
+                readonly nanosecond: import("@elaraai/east").NullType;
+                readonly microsecond: import("@elaraai/east").NullType;
+                readonly millisecond: import("@elaraai/east").NullType;
+                readonly second: import("@elaraai/east").NullType;
+                readonly minute: import("@elaraai/east").NullType;
+                readonly hour: import("@elaraai/east").NullType;
+                readonly day: import("@elaraai/east").NullType;
+                readonly week: import("@elaraai/east").NullType;
+                readonly month: import("@elaraai/east").NullType;
+                readonly year: import("@elaraai/east").NullType;
+                readonly millimeter: import("@elaraai/east").NullType;
+                readonly centimeter: import("@elaraai/east").NullType;
+                readonly meter: import("@elaraai/east").NullType;
+                readonly kilometer: import("@elaraai/east").NullType;
+                readonly inch: import("@elaraai/east").NullType;
+                readonly foot: import("@elaraai/east").NullType;
+                readonly yard: import("@elaraai/east").NullType;
+                readonly mile: import("@elaraai/east").NullType;
+                readonly gram: import("@elaraai/east").NullType;
+                readonly kilogram: import("@elaraai/east").NullType;
+                readonly milligram: import("@elaraai/east").NullType;
+                readonly ounce: import("@elaraai/east").NullType;
+                readonly pound: import("@elaraai/east").NullType;
+                readonly stone: import("@elaraai/east").NullType;
+                readonly celsius: import("@elaraai/east").NullType;
+                readonly fahrenheit: import("@elaraai/east").NullType;
+                readonly milliliter: import("@elaraai/east").NullType;
+                readonly liter: import("@elaraai/east").NullType;
+                readonly gallon: import("@elaraai/east").NullType;
+                readonly fluidOunce: import("@elaraai/east").NullType;
+                readonly acre: import("@elaraai/east").NullType;
+                readonly hectare: import("@elaraai/east").NullType;
+                readonly meterPerSecond: import("@elaraai/east").NullType;
+                readonly kilometerPerHour: import("@elaraai/east").NullType;
+                readonly milePerHour: import("@elaraai/east").NullType;
+                readonly percent: import("@elaraai/east").NullType;
+                readonly degree: import("@elaraai/east").NullType;
+            }>;
+            readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly short: import("@elaraai/east").NullType;
+                readonly narrow: import("@elaraai/east").NullType;
+                readonly long: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly scientific: import("@elaraai/east").NullType;
+        readonly engineering: import("@elaraai/east").NullType;
+        readonly date: import("@elaraai/east").StructType<{
+            readonly format: StringType;
+        }>;
+        readonly time: import("@elaraai/east").StructType<{
+            readonly format: StringType;
+        }>;
+        readonly datetime: import("@elaraai/east").StructType<{
+            readonly format: StringType;
+        }>;
+    }>>;
+    readonly summary: OptionType<StringType>;
+    readonly downside: OptionType<FloatType>;
+    readonly confidence: OptionType<FloatType>;
+    readonly detail: OptionType<StringType>;
+    readonly stakes: OptionType<VariantType<{
+        readonly low: NullType;
+        readonly medium: NullType;
+        readonly high: NullType;
+        readonly critical: NullType;
+    }>>;
+    readonly prompts: ArrayType<StructType<{
+        readonly id: StringType;
+        readonly text: StringType;
+    }>>;
+    readonly levers: ArrayType<StructType<{
+        readonly case: StringType;
+        readonly label: StringType;
+    }>>;
+    readonly evidence: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly text: StringType;
+        readonly note: OptionType<StringType>;
+    }>>;
+    readonly alternatives: ArrayType<StructType<{
+        readonly id: OptionType<StringType>;
+        readonly label: StringType;
+        readonly value: FloatType;
+        readonly downside: OptionType<FloatType>;
+        readonly confidence: OptionType<FloatType>;
+        readonly note: OptionType<StringType>;
+    }>>;
+}>;
+export type DecisionType = typeof DecisionType;
+export declare const ReferenceType: StructType<{
+    readonly caseId: StringType;
+    readonly meta: OptionType<StringType>;
+    readonly outcome: OptionType<StringType>;
+    readonly similarity: OptionType<FloatType>;
+}>;
+export type ReferenceType = typeof ReferenceType;
+/**
+ * Judgement.Inject — a typed requirement the next optimiser run must satisfy.
+ *
+ * Type-first variant (the `SlicePredicateType` shape): the outer case is the
+ * constrained field's primitive kind, the inner case the requirement
+ * operator with its typed payload. LOB-shaped on purpose — bounds, pins,
+ * set membership, date windows — and mechanically translatable to solver
+ * constraints (linear ≤/≥/=, membership encodings) by the reasoning task.
+ * Aggregate constraints (counts/sums over groups) are a later variant case.
+ *
+ * @property string - `eq` / `neq` pin or forbid a value; `in` / `notIn` set
+ *   membership
+ * @property integer - `eq` pin; `atMost` / `atLeast` bounds; `between` range
+ * @property float - `eq` pin; `atMost` / `atLeast` bounds; `between` range
+ * @property datetime - `before` / `after` bounds; `between` window
+ * @property boolean - `is` requirement
+ */
+export declare const DecisionConstraintType: VariantType<{
+    readonly string: VariantType<{
+        readonly eq: StringType;
+        readonly neq: StringType;
+        readonly in: SetType<StringType>;
+        readonly notIn: SetType<StringType>;
+    }>;
+    readonly integer: VariantType<{
+        readonly eq: IntegerType;
+        readonly atMost: IntegerType;
+        readonly atLeast: IntegerType;
+        readonly between: StructType<{
+            readonly min: IntegerType;
+            readonly max: IntegerType;
+        }>;
+    }>;
+    readonly float: VariantType<{
+        readonly eq: FloatType;
+        readonly atMost: FloatType;
+        readonly atLeast: FloatType;
+        readonly between: StructType<{
+            readonly min: FloatType;
+            readonly max: FloatType;
+        }>;
+    }>;
+    readonly datetime: VariantType<{
+        readonly before: DateTimeType;
+        readonly after: DateTimeType;
+        readonly between: StructType<{
+            readonly min: DateTimeType;
+            readonly max: DateTimeType;
+        }>;
+    }>;
+    readonly boolean: VariantType<{
+        readonly is: BooleanType;
+    }>;
+}>;
+/** Type alias for {@link DecisionConstraintType}. */
+export type DecisionConstraintType = typeof DecisionConstraintType;
+/**
+ * One constrainable field in a surface's constraint vocabulary — what the
+ * judgement panel's typed builder offers. Mirrors `Slice.config` fields,
+ * minus accessors: constraints are interpreted by the reasoning task, never
+ * evaluated client-side.
+ *
+ * @property label - Display label ("Cho weekly hours cap")
+ * @property kind - The field's primitive kind — drives the typed op editor
+ */
+/** A constraint field's primitive kind — drives the typed op editor. */
+export declare const ConstraintKindType: VariantType<{
+    readonly string: NullType;
+    readonly integer: NullType;
+    readonly float: NullType;
+    readonly datetime: NullType;
+    readonly boolean: NullType;
+}>;
+/** Type alias for {@link ConstraintKindType}. */
+export type ConstraintKindType = typeof ConstraintKindType;
+export declare const ConstraintFieldType: StructType<{
+    readonly label: StringType;
+    readonly kind: VariantType<{
+        readonly string: NullType;
+        readonly integer: NullType;
+        readonly float: NullType;
+        readonly datetime: NullType;
+        readonly boolean: NullType;
+    }>;
+}>;
+/** Type alias for {@link ConstraintFieldType}. */
+export type ConstraintFieldType = typeof ConstraintFieldType;
+/**
+ * The surface's constraint vocabulary, keyed by field id (the model-namespace
+ * path the reasoning task resolves, e.g. `"cho.hardCapHrs"`).
+ */
+export declare const ConstraintVocabularyType: DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly kind: VariantType<{
+        readonly string: NullType;
+        readonly integer: NullType;
+        readonly float: NullType;
+        readonly datetime: NullType;
+        readonly boolean: NullType;
+    }>;
+}>>;
+/** Type alias for {@link ConstraintVocabularyType}. */
+export type ConstraintVocabularyType = typeof ConstraintVocabularyType;
+/** `update(editedDecision)` — the writer a probe (`modify`) editor receives.
+ *  Calling it writes the edited decision back through its owning binding. */
+export declare const DecisionUpdateType: FunctionType<[StructType<{
+    readonly id: StringType;
+    readonly kind: StringType;
+    readonly title: StringType;
+    readonly urgency: VariantType<{
+        readonly overdue: NullType;
+        readonly due: NullType;
+        readonly routine: NullType;
+    }>;
+    readonly value: FloatType;
+    readonly deadline: OptionType<DateTimeType>;
+    readonly format: OptionType<VariantType<{
+        readonly number: import("@elaraai/east").StructType<{
+            readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly auto: import("@elaraai/east").NullType;
+                readonly never: import("@elaraai/east").NullType;
+                readonly always: import("@elaraai/east").NullType;
+                readonly exceptZero: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly currency: import("@elaraai/east").StructType<{
+            readonly currency: import("@elaraai/east").VariantType<{
+                readonly USD: import("@elaraai/east").NullType;
+                readonly EUR: import("@elaraai/east").NullType;
+                readonly GBP: import("@elaraai/east").NullType;
+                readonly JPY: import("@elaraai/east").NullType;
+                readonly CHF: import("@elaraai/east").NullType;
+                readonly CAD: import("@elaraai/east").NullType;
+                readonly AUD: import("@elaraai/east").NullType;
+                readonly NZD: import("@elaraai/east").NullType;
+                readonly CNY: import("@elaraai/east").NullType;
+                readonly HKD: import("@elaraai/east").NullType;
+                readonly SGD: import("@elaraai/east").NullType;
+                readonly KRW: import("@elaraai/east").NullType;
+                readonly INR: import("@elaraai/east").NullType;
+                readonly TWD: import("@elaraai/east").NullType;
+                readonly THB: import("@elaraai/east").NullType;
+                readonly MYR: import("@elaraai/east").NullType;
+                readonly IDR: import("@elaraai/east").NullType;
+                readonly PHP: import("@elaraai/east").NullType;
+                readonly VND: import("@elaraai/east").NullType;
+                readonly SEK: import("@elaraai/east").NullType;
+                readonly NOK: import("@elaraai/east").NullType;
+                readonly DKK: import("@elaraai/east").NullType;
+                readonly PLN: import("@elaraai/east").NullType;
+                readonly CZK: import("@elaraai/east").NullType;
+                readonly HUF: import("@elaraai/east").NullType;
+                readonly RUB: import("@elaraai/east").NullType;
+                readonly UAH: import("@elaraai/east").NullType;
+                readonly RON: import("@elaraai/east").NullType;
+                readonly MXN: import("@elaraai/east").NullType;
+                readonly BRL: import("@elaraai/east").NullType;
+                readonly ARS: import("@elaraai/east").NullType;
+                readonly CLP: import("@elaraai/east").NullType;
+                readonly COP: import("@elaraai/east").NullType;
+                readonly PEN: import("@elaraai/east").NullType;
+                readonly AED: import("@elaraai/east").NullType;
+                readonly SAR: import("@elaraai/east").NullType;
+                readonly ILS: import("@elaraai/east").NullType;
+                readonly ZAR: import("@elaraai/east").NullType;
+                readonly TRY: import("@elaraai/east").NullType;
+                readonly EGP: import("@elaraai/east").NullType;
+                readonly NGN: import("@elaraai/east").NullType;
+                readonly KES: import("@elaraai/east").NullType;
+            }>;
+            readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly code: import("@elaraai/east").NullType;
+                readonly symbol: import("@elaraai/east").NullType;
+                readonly narrowSymbol: import("@elaraai/east").NullType;
+                readonly name: import("@elaraai/east").NullType;
+            }>>;
+            readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly short: import("@elaraai/east").NullType;
+                readonly long: import("@elaraai/east").NullType;
+            }>>;
+            readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+        }>;
+        readonly percent: import("@elaraai/east").StructType<{
+            readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly auto: import("@elaraai/east").NullType;
+                readonly never: import("@elaraai/east").NullType;
+                readonly always: import("@elaraai/east").NullType;
+                readonly exceptZero: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly compact: import("@elaraai/east").StructType<{
+            readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly short: import("@elaraai/east").NullType;
+                readonly long: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly unit: import("@elaraai/east").StructType<{
+            readonly unit: import("@elaraai/east").VariantType<{
+                readonly bit: import("@elaraai/east").NullType;
+                readonly byte: import("@elaraai/east").NullType;
+                readonly kilobit: import("@elaraai/east").NullType;
+                readonly kilobyte: import("@elaraai/east").NullType;
+                readonly megabit: import("@elaraai/east").NullType;
+                readonly megabyte: import("@elaraai/east").NullType;
+                readonly gigabit: import("@elaraai/east").NullType;
+                readonly gigabyte: import("@elaraai/east").NullType;
+                readonly terabit: import("@elaraai/east").NullType;
+                readonly terabyte: import("@elaraai/east").NullType;
+                readonly petabyte: import("@elaraai/east").NullType;
+                readonly nanosecond: import("@elaraai/east").NullType;
+                readonly microsecond: import("@elaraai/east").NullType;
+                readonly millisecond: import("@elaraai/east").NullType;
+                readonly second: import("@elaraai/east").NullType;
+                readonly minute: import("@elaraai/east").NullType;
+                readonly hour: import("@elaraai/east").NullType;
+                readonly day: import("@elaraai/east").NullType;
+                readonly week: import("@elaraai/east").NullType;
+                readonly month: import("@elaraai/east").NullType;
+                readonly year: import("@elaraai/east").NullType;
+                readonly millimeter: import("@elaraai/east").NullType;
+                readonly centimeter: import("@elaraai/east").NullType;
+                readonly meter: import("@elaraai/east").NullType;
+                readonly kilometer: import("@elaraai/east").NullType;
+                readonly inch: import("@elaraai/east").NullType;
+                readonly foot: import("@elaraai/east").NullType;
+                readonly yard: import("@elaraai/east").NullType;
+                readonly mile: import("@elaraai/east").NullType;
+                readonly gram: import("@elaraai/east").NullType;
+                readonly kilogram: import("@elaraai/east").NullType;
+                readonly milligram: import("@elaraai/east").NullType;
+                readonly ounce: import("@elaraai/east").NullType;
+                readonly pound: import("@elaraai/east").NullType;
+                readonly stone: import("@elaraai/east").NullType;
+                readonly celsius: import("@elaraai/east").NullType;
+                readonly fahrenheit: import("@elaraai/east").NullType;
+                readonly milliliter: import("@elaraai/east").NullType;
+                readonly liter: import("@elaraai/east").NullType;
+                readonly gallon: import("@elaraai/east").NullType;
+                readonly fluidOunce: import("@elaraai/east").NullType;
+                readonly acre: import("@elaraai/east").NullType;
+                readonly hectare: import("@elaraai/east").NullType;
+                readonly meterPerSecond: import("@elaraai/east").NullType;
+                readonly kilometerPerHour: import("@elaraai/east").NullType;
+                readonly milePerHour: import("@elaraai/east").NullType;
+                readonly percent: import("@elaraai/east").NullType;
+                readonly degree: import("@elaraai/east").NullType;
+            }>;
+            readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                readonly short: import("@elaraai/east").NullType;
+                readonly narrow: import("@elaraai/east").NullType;
+                readonly long: import("@elaraai/east").NullType;
+            }>>;
+        }>;
+        readonly scientific: import("@elaraai/east").NullType;
+        readonly engineering: import("@elaraai/east").NullType;
+        readonly date: import("@elaraai/east").StructType<{
+            readonly format: StringType;
+        }>;
+        readonly time: import("@elaraai/east").StructType<{
+            readonly format: StringType;
+        }>;
+        readonly datetime: import("@elaraai/east").StructType<{
+            readonly format: StringType;
+        }>;
+    }>>;
+    readonly summary: OptionType<StringType>;
+    readonly downside: OptionType<FloatType>;
+    readonly confidence: OptionType<FloatType>;
+    readonly detail: OptionType<StringType>;
+    readonly stakes: OptionType<VariantType<{
+        readonly low: NullType;
+        readonly medium: NullType;
+        readonly high: NullType;
+        readonly critical: NullType;
+    }>>;
+    readonly prompts: ArrayType<StructType<{
+        readonly id: StringType;
+        readonly text: StringType;
+    }>>;
+    readonly levers: ArrayType<StructType<{
+        readonly case: StringType;
+        readonly label: StringType;
+    }>>;
+    readonly evidence: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly text: StringType;
+        readonly note: OptionType<StringType>;
+    }>>;
+    readonly alternatives: ArrayType<StructType<{
+        readonly id: OptionType<StringType>;
+        readonly label: StringType;
+        readonly value: FloatType;
+        readonly downside: OptionType<FloatType>;
+        readonly confidence: OptionType<FloatType>;
+        readonly note: OptionType<StringType>;
+    }>>;
+}>], NullType>;
+/** Type alias for {@link DecisionUpdateType}. */
+export type DecisionUpdateType = typeof DecisionUpdateType;
+/**
+ * Build the judgement-record type for a solution's constraint contract — the
+ * `sliceConfigFor(rowType)` pattern. The contract is a by-name `VariantType`
+ * declared once in the solution package and imported by both the reasoning
+ * task (which `$.matchTag`s constraints, fully typed) and the surface (whose
+ * builder renders a typed editor per case payload). Defaults to
+ * {@link DecisionConstraintType}, the primitive op-variant.
+ */
+export declare function judgementInputType<C extends EastType = DecisionConstraintType>(constraint?: C): StructType<{
+    readonly caseId: StringType;
+    readonly answers: DictType<StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>>;
+    readonly knowledge: OptionType<StringType>;
+    readonly constraints: ArrayType<C>;
+    readonly verdict: OptionType<VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>>;
+    readonly resolvedAt: OptionType<DateTimeType>;
+}>;
+/** The default judgement-record type (primitive op-variant constraints). */
+export declare const JudgementInputType: StructType<{
+    readonly caseId: StringType;
+    readonly answers: DictType<StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>>;
+    readonly knowledge: OptionType<StringType>;
+    readonly constraints: ArrayType<VariantType<{
+        readonly string: VariantType<{
+            readonly eq: StringType;
+            readonly neq: StringType;
+            readonly in: SetType<StringType>;
+            readonly notIn: SetType<StringType>;
+        }>;
+        readonly integer: VariantType<{
+            readonly eq: IntegerType;
+            readonly atMost: IntegerType;
+            readonly atLeast: IntegerType;
+            readonly between: StructType<{
+                readonly min: IntegerType;
+                readonly max: IntegerType;
+            }>;
+        }>;
+        readonly float: VariantType<{
+            readonly eq: FloatType;
+            readonly atMost: FloatType;
+            readonly atLeast: FloatType;
+            readonly between: StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>;
+        }>;
+        readonly datetime: VariantType<{
+            readonly before: DateTimeType;
+            readonly after: DateTimeType;
+            readonly between: StructType<{
+                readonly min: DateTimeType;
+                readonly max: DateTimeType;
+            }>;
+        }>;
+        readonly boolean: VariantType<{
+            readonly is: BooleanType;
+        }>;
+    }>>;
+    readonly verdict: OptionType<VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>>;
+    readonly resolvedAt: OptionType<DateTimeType>;
+}>;
+export type JudgementInputType = typeof JudgementInputType;
+/** String-literal proxy for {@link UrgencyType}. */
+export type UrgencyLiteral = "overdue" | "due" | "routine";
+/** Plain-JS shape for {@link Decision.option}. */
+export interface DecisionOptionInput {
+    id?: SubtypeExprOrValue<StringType>;
+    label: SubtypeExprOrValue<StringType>;
+    value: SubtypeExprOrValue<FloatType>;
+    downside?: SubtypeExprOrValue<FloatType>;
+    confidence?: SubtypeExprOrValue<FloatType>;
+    note?: SubtypeExprOrValue<StringType>;
+}
+declare function createDecisionOption(input: DecisionOptionInput): ExprType<DecisionOptionType>;
+/** Plain-JS shape for one evidence chip (see {@link EvidenceType}). */
+/** String-literal proxy for a constraint field's primitive kind. */
+export type ConstraintKindLiteral = "string" | "integer" | "float" | "datetime" | "boolean";
+/** Plain-JS shape for one constraint-vocabulary field — coerced to
+ *  {@link ConstraintFieldType} by `Decision.bind`. */
+export interface ConstraintFieldInput {
+    label: SubtypeExprOrValue<StringType>;
+    kind: ConstraintKindLiteral | SubtypeExprOrValue<ConstraintKindType>;
+}
+export interface EvidenceInput {
+    label: SubtypeExprOrValue<StringType>;
+    text: SubtypeExprOrValue<StringType>;
+    note?: SubtypeExprOrValue<StringType>;
+}
+/** Plain-JS shape for {@link Decision.make} — required core + optional rest. */
+export interface DecisionInput {
+    id: SubtypeExprOrValue<StringType>;
+    kind: SubtypeExprOrValue<StringType>;
+    title: SubtypeExprOrValue<StringType>;
+    urgency: SubtypeExprOrValue<UrgencyType> | UrgencyLiteral;
+    value: SubtypeExprOrValue<FloatType>;
+    deadline?: SubtypeExprOrValue<DateTimeType>;
+    format?: SubtypeExprOrValue<TickFormatType>;
+    summary?: SubtypeExprOrValue<StringType>;
+    downside?: SubtypeExprOrValue<FloatType>;
+    confidence?: SubtypeExprOrValue<FloatType>;
+    detail?: SubtypeExprOrValue<StringType>;
+    stakes?: StakesLevelLiteral | SubtypeExprOrValue<StakesLevelType>;
+    prompts?: (string | PromptInput)[] | ExprType<ArrayType<PromptType>>;
+    levers?: LeverInput[] | ExprType<ArrayType<LeverType>>;
+    evidence?: EvidenceInput[] | ExprType<ArrayType<EvidenceType>>;
+    alternatives?: SubtypeExprOrValue<ArrayType<DecisionOptionType>>;
+}
+/** Plain-JS shape for one judgement prompt — a bare string derives `id`
+ *  from the text. */
+export interface PromptInput {
+    id?: SubtypeExprOrValue<StringType>;
+    text: SubtypeExprOrValue<StringType>;
+}
+/** Plain-JS shape for one lever (see {@link LeverType}). */
+export interface LeverInput {
+    case: SubtypeExprOrValue<StringType>;
+    label: SubtypeExprOrValue<StringType>;
+}
+declare function createDecision(input: DecisionInput): ExprType<DecisionType>;
+/** Plain-JS shape for {@link Decision.reference}. */
+export interface DecisionReferenceInput {
+    caseId: SubtypeExprOrValue<StringType>;
+    meta?: SubtypeExprOrValue<StringType>;
+    outcome?: SubtypeExprOrValue<StringType>;
+    similarity?: SubtypeExprOrValue<FloatType>;
+}
+declare function createReference(input: DecisionReferenceInput): ExprType<ReferenceType>;
+/** Plain-JS shape for {@link Decision.judgement}. */
+export interface DecisionJudgementInput {
+    caseId: SubtypeExprOrValue<StringType>;
+    answers?: SubtypeExprOrValue<DictType<StringType, AnswerType>>;
+    knowledge?: SubtypeExprOrValue<StringType>;
+    constraints?: SubtypeExprOrValue<ArrayType<DecisionConstraintType>>;
+    verdict?: SubtypeExprOrValue<VerdictType>;
+    resolvedAt?: SubtypeExprOrValue<DateTimeType>;
+}
+declare function createJudgement(input: DecisionJudgementInput): ExprType<JudgementInputType>;
+/**
+ * The Decision platform namespace — ergonomic constructors + the East `Types`.
+ *
+ * @example
+ * ```ts
+ * Decision.make({
+ *   id: "cap-SE-0916", kind: "capacity",
+ *   title: "Raise SE senior-engineer cover to 6 FTE",
+ *   urgency: "overdue", value: 80000,
+ *   format: Format.Currency({ currency: "USD", compact: "short" }),
+ *   downside: -8000, confidence: 0.82,
+ *   evidence: ["forecast: SE +14%"],
+ *   alternatives: [Decision.option({ label: "Hire 1 contractor", value: 48000, downside: -15000 })],
+ * });
+ * ```
+ */
+export declare const Decision: {
+    /** Build one decision — required core + optional rest (optionals default to absent). */
+    readonly make: typeof createDecision;
+    /** Build one of a decision's other evaluated options. */
+    readonly option: typeof createDecisionOption;
+    /** Build one similar-past-decision reference (separate history dataset). */
+    readonly reference: typeof createReference;
+    /** Build one staged judgement contribution (knowledge + injected constraints + verdict). */
+    readonly judgement: typeof createJudgement;
+    readonly Types: {
+        readonly Decision: StructType<{
+            readonly id: StringType;
+            readonly kind: StringType;
+            readonly title: StringType;
+            readonly urgency: VariantType<{
+                readonly overdue: NullType;
+                readonly due: NullType;
+                readonly routine: NullType;
+            }>;
+            readonly value: FloatType;
+            readonly deadline: OptionType<DateTimeType>;
+            readonly format: OptionType<VariantType<{
+                readonly number: import("@elaraai/east").StructType<{
+                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                    readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly auto: import("@elaraai/east").NullType;
+                        readonly never: import("@elaraai/east").NullType;
+                        readonly always: import("@elaraai/east").NullType;
+                        readonly exceptZero: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly currency: import("@elaraai/east").StructType<{
+                    readonly currency: import("@elaraai/east").VariantType<{
+                        readonly USD: import("@elaraai/east").NullType;
+                        readonly EUR: import("@elaraai/east").NullType;
+                        readonly GBP: import("@elaraai/east").NullType;
+                        readonly JPY: import("@elaraai/east").NullType;
+                        readonly CHF: import("@elaraai/east").NullType;
+                        readonly CAD: import("@elaraai/east").NullType;
+                        readonly AUD: import("@elaraai/east").NullType;
+                        readonly NZD: import("@elaraai/east").NullType;
+                        readonly CNY: import("@elaraai/east").NullType;
+                        readonly HKD: import("@elaraai/east").NullType;
+                        readonly SGD: import("@elaraai/east").NullType;
+                        readonly KRW: import("@elaraai/east").NullType;
+                        readonly INR: import("@elaraai/east").NullType;
+                        readonly TWD: import("@elaraai/east").NullType;
+                        readonly THB: import("@elaraai/east").NullType;
+                        readonly MYR: import("@elaraai/east").NullType;
+                        readonly IDR: import("@elaraai/east").NullType;
+                        readonly PHP: import("@elaraai/east").NullType;
+                        readonly VND: import("@elaraai/east").NullType;
+                        readonly SEK: import("@elaraai/east").NullType;
+                        readonly NOK: import("@elaraai/east").NullType;
+                        readonly DKK: import("@elaraai/east").NullType;
+                        readonly PLN: import("@elaraai/east").NullType;
+                        readonly CZK: import("@elaraai/east").NullType;
+                        readonly HUF: import("@elaraai/east").NullType;
+                        readonly RUB: import("@elaraai/east").NullType;
+                        readonly UAH: import("@elaraai/east").NullType;
+                        readonly RON: import("@elaraai/east").NullType;
+                        readonly MXN: import("@elaraai/east").NullType;
+                        readonly BRL: import("@elaraai/east").NullType;
+                        readonly ARS: import("@elaraai/east").NullType;
+                        readonly CLP: import("@elaraai/east").NullType;
+                        readonly COP: import("@elaraai/east").NullType;
+                        readonly PEN: import("@elaraai/east").NullType;
+                        readonly AED: import("@elaraai/east").NullType;
+                        readonly SAR: import("@elaraai/east").NullType;
+                        readonly ILS: import("@elaraai/east").NullType;
+                        readonly ZAR: import("@elaraai/east").NullType;
+                        readonly TRY: import("@elaraai/east").NullType;
+                        readonly EGP: import("@elaraai/east").NullType;
+                        readonly NGN: import("@elaraai/east").NullType;
+                        readonly KES: import("@elaraai/east").NullType;
+                    }>;
+                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly code: import("@elaraai/east").NullType;
+                        readonly symbol: import("@elaraai/east").NullType;
+                        readonly narrowSymbol: import("@elaraai/east").NullType;
+                        readonly name: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly short: import("@elaraai/east").NullType;
+                        readonly long: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                }>;
+                readonly percent: import("@elaraai/east").StructType<{
+                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                    readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly auto: import("@elaraai/east").NullType;
+                        readonly never: import("@elaraai/east").NullType;
+                        readonly always: import("@elaraai/east").NullType;
+                        readonly exceptZero: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly compact: import("@elaraai/east").StructType<{
+                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly short: import("@elaraai/east").NullType;
+                        readonly long: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly unit: import("@elaraai/east").StructType<{
+                    readonly unit: import("@elaraai/east").VariantType<{
+                        readonly bit: import("@elaraai/east").NullType;
+                        readonly byte: import("@elaraai/east").NullType;
+                        readonly kilobit: import("@elaraai/east").NullType;
+                        readonly kilobyte: import("@elaraai/east").NullType;
+                        readonly megabit: import("@elaraai/east").NullType;
+                        readonly megabyte: import("@elaraai/east").NullType;
+                        readonly gigabit: import("@elaraai/east").NullType;
+                        readonly gigabyte: import("@elaraai/east").NullType;
+                        readonly terabit: import("@elaraai/east").NullType;
+                        readonly terabyte: import("@elaraai/east").NullType;
+                        readonly petabyte: import("@elaraai/east").NullType;
+                        readonly nanosecond: import("@elaraai/east").NullType;
+                        readonly microsecond: import("@elaraai/east").NullType;
+                        readonly millisecond: import("@elaraai/east").NullType;
+                        readonly second: import("@elaraai/east").NullType;
+                        readonly minute: import("@elaraai/east").NullType;
+                        readonly hour: import("@elaraai/east").NullType;
+                        readonly day: import("@elaraai/east").NullType;
+                        readonly week: import("@elaraai/east").NullType;
+                        readonly month: import("@elaraai/east").NullType;
+                        readonly year: import("@elaraai/east").NullType;
+                        readonly millimeter: import("@elaraai/east").NullType;
+                        readonly centimeter: import("@elaraai/east").NullType;
+                        readonly meter: import("@elaraai/east").NullType;
+                        readonly kilometer: import("@elaraai/east").NullType;
+                        readonly inch: import("@elaraai/east").NullType;
+                        readonly foot: import("@elaraai/east").NullType;
+                        readonly yard: import("@elaraai/east").NullType;
+                        readonly mile: import("@elaraai/east").NullType;
+                        readonly gram: import("@elaraai/east").NullType;
+                        readonly kilogram: import("@elaraai/east").NullType;
+                        readonly milligram: import("@elaraai/east").NullType;
+                        readonly ounce: import("@elaraai/east").NullType;
+                        readonly pound: import("@elaraai/east").NullType;
+                        readonly stone: import("@elaraai/east").NullType;
+                        readonly celsius: import("@elaraai/east").NullType;
+                        readonly fahrenheit: import("@elaraai/east").NullType;
+                        readonly milliliter: import("@elaraai/east").NullType;
+                        readonly liter: import("@elaraai/east").NullType;
+                        readonly gallon: import("@elaraai/east").NullType;
+                        readonly fluidOunce: import("@elaraai/east").NullType;
+                        readonly acre: import("@elaraai/east").NullType;
+                        readonly hectare: import("@elaraai/east").NullType;
+                        readonly meterPerSecond: import("@elaraai/east").NullType;
+                        readonly kilometerPerHour: import("@elaraai/east").NullType;
+                        readonly milePerHour: import("@elaraai/east").NullType;
+                        readonly percent: import("@elaraai/east").NullType;
+                        readonly degree: import("@elaraai/east").NullType;
+                    }>;
+                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly short: import("@elaraai/east").NullType;
+                        readonly narrow: import("@elaraai/east").NullType;
+                        readonly long: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly scientific: import("@elaraai/east").NullType;
+                readonly engineering: import("@elaraai/east").NullType;
+                readonly date: import("@elaraai/east").StructType<{
+                    readonly format: StringType;
+                }>;
+                readonly time: import("@elaraai/east").StructType<{
+                    readonly format: StringType;
+                }>;
+                readonly datetime: import("@elaraai/east").StructType<{
+                    readonly format: StringType;
+                }>;
+            }>>;
+            readonly summary: OptionType<StringType>;
+            readonly downside: OptionType<FloatType>;
+            readonly confidence: OptionType<FloatType>;
+            readonly detail: OptionType<StringType>;
+            readonly stakes: OptionType<VariantType<{
+                readonly low: NullType;
+                readonly medium: NullType;
+                readonly high: NullType;
+                readonly critical: NullType;
+            }>>;
+            readonly prompts: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly text: StringType;
+            }>>;
+            readonly levers: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly evidence: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly text: StringType;
+                readonly note: OptionType<StringType>;
+            }>>;
+            readonly alternatives: ArrayType<StructType<{
+                readonly id: OptionType<StringType>;
+                readonly label: StringType;
+                readonly value: FloatType;
+                readonly downside: OptionType<FloatType>;
+                readonly confidence: OptionType<FloatType>;
+                readonly note: OptionType<StringType>;
+            }>>;
+        }>;
+        readonly Option: StructType<{
+            readonly id: OptionType<StringType>;
+            readonly label: StringType;
+            readonly value: FloatType;
+            readonly downside: OptionType<FloatType>;
+            readonly confidence: OptionType<FloatType>;
+            readonly note: OptionType<StringType>;
+        }>;
+        readonly Urgency: VariantType<{
+            readonly overdue: NullType;
+            readonly due: NullType;
+            readonly routine: NullType;
+        }>;
+        readonly Stakes: VariantType<{
+            readonly low: NullType;
+            readonly medium: NullType;
+            readonly high: NullType;
+            readonly critical: NullType;
+        }>;
+        readonly StakesLevel: VariantType<{
+            readonly low: NullType;
+            readonly medium: NullType;
+            readonly high: NullType;
+            readonly critical: NullType;
+        }>;
+        readonly Prompt: StructType<{
+            readonly id: StringType;
+            readonly text: StringType;
+        }>;
+        readonly Lever: StructType<{
+            readonly case: StringType;
+            readonly label: StringType;
+        }>;
+        readonly Evidence: StructType<{
+            readonly label: StringType;
+            readonly text: StringType;
+            readonly note: OptionType<StringType>;
+        }>;
+        readonly Reference: StructType<{
+            readonly caseId: StringType;
+            readonly meta: OptionType<StringType>;
+            readonly outcome: OptionType<StringType>;
+            readonly similarity: OptionType<FloatType>;
+        }>;
+        readonly JudgementInput: typeof judgementInputType;
+        readonly DefaultJudgementInput: StructType<{
+            readonly caseId: StringType;
+            readonly answers: DictType<StringType, VariantType<{
+                readonly yes: NullType;
+                readonly no: NullType;
+                readonly unknown: NullType;
+            }>>;
+            readonly knowledge: OptionType<StringType>;
+            readonly constraints: ArrayType<VariantType<{
+                readonly string: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                }>;
+                readonly integer: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly atMost: IntegerType;
+                    readonly atLeast: IntegerType;
+                    readonly between: StructType<{
+                        readonly min: IntegerType;
+                        readonly max: IntegerType;
+                    }>;
+                }>;
+                readonly float: VariantType<{
+                    readonly eq: FloatType;
+                    readonly atMost: FloatType;
+                    readonly atLeast: FloatType;
+                    readonly between: StructType<{
+                        readonly min: FloatType;
+                        readonly max: FloatType;
+                    }>;
+                }>;
+                readonly datetime: VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly min: DateTimeType;
+                        readonly max: DateTimeType;
+                    }>;
+                }>;
+                readonly boolean: VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>>;
+            readonly verdict: OptionType<VariantType<{
+                readonly accepted: StringType;
+                readonly rejected: NullType;
+                readonly deferred: OptionType<StringType>;
+                readonly handoff: StringType;
+            }>>;
+            readonly resolvedAt: OptionType<DateTimeType>;
+        }>;
+        readonly Constraint: VariantType<{
+            readonly string: VariantType<{
+                readonly eq: StringType;
+                readonly neq: StringType;
+                readonly in: SetType<StringType>;
+                readonly notIn: SetType<StringType>;
+            }>;
+            readonly integer: VariantType<{
+                readonly eq: IntegerType;
+                readonly atMost: IntegerType;
+                readonly atLeast: IntegerType;
+                readonly between: StructType<{
+                    readonly min: IntegerType;
+                    readonly max: IntegerType;
+                }>;
+            }>;
+            readonly float: VariantType<{
+                readonly eq: FloatType;
+                readonly atMost: FloatType;
+                readonly atLeast: FloatType;
+                readonly between: StructType<{
+                    readonly min: FloatType;
+                    readonly max: FloatType;
+                }>;
+            }>;
+            readonly datetime: VariantType<{
+                readonly before: DateTimeType;
+                readonly after: DateTimeType;
+                readonly between: StructType<{
+                    readonly min: DateTimeType;
+                    readonly max: DateTimeType;
+                }>;
+            }>;
+            readonly boolean: VariantType<{
+                readonly is: BooleanType;
+            }>;
+        }>;
+        readonly ConstraintField: StructType<{
+            readonly label: StringType;
+            readonly kind: VariantType<{
+                readonly string: NullType;
+                readonly integer: NullType;
+                readonly float: NullType;
+                readonly datetime: NullType;
+                readonly boolean: NullType;
+            }>;
+        }>;
+        readonly ConstraintVocabulary: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly kind: VariantType<{
+                readonly string: NullType;
+                readonly integer: NullType;
+                readonly float: NullType;
+                readonly datetime: NullType;
+                readonly boolean: NullType;
+            }>;
+        }>>;
+        readonly Answer: VariantType<{
+            readonly yes: NullType;
+            readonly no: NullType;
+            readonly unknown: NullType;
+        }>;
+        readonly Verdict: VariantType<{
+            readonly accepted: StringType;
+            readonly rejected: NullType;
+            readonly deferred: OptionType<StringType>;
+            readonly handoff: StringType;
+        }>;
+    };
+};
+export {};
+//# sourceMappingURL=types.d.ts.map