@coldsmirk/abacus-core 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -2,9 +2,20 @@ import { InitInput } from "@gorules/zen-engine-wasm";
 
 //#region src/engine/intellisense.d.ts
 /**
- * Whether an expression is a standard value expression or a unary (test) expression.
+ * How an expression editor interprets its document:
+ *
+ * - `"standard"` — a single ZEN value expression.
+ * - `"unary"` — a single ZEN unary (test) expression, evaluating to a boolean.
+ * - `"template"` — literal text with `{{ expression }}` holes; each hole is a
+ * standard value expression, the surrounding text is inert.
+ *
+ * The single-expression intellisense functions here ({@link getDiagnosticsSync},
+ * {@link analyzeTypesSync}) treat a `"template"` argument as `"standard"` — they
+ * analyze one expression. Whole template documents are handled hole-by-hole by
+ * the template functions ({@link analyzeTemplateSync},
+ * {@link getTemplateDiagnosticsSync}).
  */
-type ExpressionMode = "standard" | "unary";
+type ExpressionMode = "standard" | "unary" | "template";
 /**
  * A ZEN type descriptor — the shape the engine understands for type-aware
  * completion and validation: a primitive kind name or one of the structural
@@ -273,6 +284,22 @@ declare const CONDITION_OPERATORS: readonly ["eq", "ne", "gt", "gte", "lt", "lte
  * vocabulary (the flow editor shares it instead of re-declaring its own).
  */
 type ConditionOperator = typeof CONDITION_OPERATORS[number];
+/**
+ * The shape of an operator's right-hand operand:
+ *
+ * - `scalar` — a single comparison value (`eq`, `gt`, `contains`, …);
+ * - `array` — a list of membership values (`in` / `not_in`);
+ * - `none` — no operand at all (`is_empty` / `is_not_empty`).
+ */
+type ConditionOperatorArity = "scalar" | "array" | "none";
+/**
+ * The arity of `operator`'s right-hand operand (see
+ * {@link ConditionOperatorArity}). One definition site next to
+ * {@link CONDITION_OPERATORS}, so the tree compiler's arity enforcement and a
+ * condition editor's operand controls classify operators identically instead of
+ * each keeping a drift-prone copy.
+ */
+declare function conditionOperatorArity(operator: ConditionOperator): ConditionOperatorArity;
 /**
  * A field/operator/value condition.
  */
@@ -379,6 +406,97 @@ declare function selectBranchWith(branches: readonly ConditionBranchInput[], con
  */
 declare function selectBranch(branches: readonly ConditionBranchInput[], context: ExpressionContext): Promise<BranchSelection>;
 //#endregion
+//#region src/condition/tree-types.d.ts
+/**
+ * The visual condition **tree** model: an arbitrarily nested and/or tree of typed
+ * comparison rules that {@link compileConditionTree} serializes to a single ZEN
+ * boolean expression and {@link liftConditionTree} reconstructs from one. It is a
+ * distinct, self-contained shape from the compiler's flat {@link ConditionInput} —
+ * the tree is what a structured builder UI edits, whereas `ConditionInput` is the
+ * narrowed per-condition shape the compiler consumes. The two meet only at the
+ * leaf: a {@link ConditionTreeRule} lowers to a field {@link ConditionInput} so the
+ * operator vocabulary, literal encoding, and injection guard have one owner.
+ */
+/**
+ * A scalar operand: the value types ZEN compares against and that survive the
+ * compile/lift round-trip (strings, numbers, booleans). Objects and null are not
+ * representable as a rule operand.
+ */
+type ConditionScalar = string | number | boolean;
+/**
+ * A rule's right-hand operand, whose shape follows the operator's arity:
+ *
+ * - comparison / string operators (`eq`, `gt`, `contains`, …) take a single
+ * {@link ConditionScalar};
+ * - membership operators (`in`, `not_in`) take an array of scalars;
+ * - the emptiness operators (`is_empty`, `is_not_empty`) take no operand and omit
+ * `right` entirely.
+ *
+ * The builder keeps a rule's `right` consistent with its operator's arity as the
+ * author switches operators.
+ */
+type ConditionTreeValue = ConditionScalar | readonly ConditionScalar[];
+/**
+ * The tree's operator vocabulary as a runtime list — the compiler's full
+ * {@link CONDITION_OPERATORS} set under the tree name. An alias, not a second
+ * hand-maintained list, so the tree vocabulary can never drift from the compiler's;
+ * it gives tree code and the builder UI one tree-named import for the operators they
+ * support.
+ */
+declare const CONDITION_TREE_OPERATORS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "contains", "not_contains", "starts_with", "ends_with", "in", "not_in", "is_empty", "is_not_empty"];
+/**
+ * The tree's operator type: every operator {@link compileCondition} can emit (all
+ * 14). The builder deliberately constructs the whole set, so there is no "the library
+ * compiles it but the builder cannot express it" gap. Derived from
+ * {@link CONDITION_TREE_OPERATORS} so the type and the runtime list share one
+ * definition; identical to the compiler's `ConditionOperator`.
+ */
+type ConditionTreeOperator = typeof CONDITION_TREE_OPERATORS[number];
+/**
+ * A leaf comparison. `left` is a field path emitted **verbatim** into ZEN (guarded
+ * by the same identifier-path predicate as {@link compileCondition}); `right`
+ * carries the operand for the operator's arity (see {@link ConditionTreeValue}) and
+ * is absent for the emptiness operators.
+ */
+interface ConditionTreeRule {
+  kind: "rule";
+  left: string;
+  operator: ConditionTreeOperator;
+  right?: ConditionTreeValue;
+}
+/**
+ * A boolean group joining its `items` with `op`. Items are leaf rules or nested
+ * groups, making the model an arbitrarily deep and/or tree. The root of a lifted
+ * condition is always a group, so callers can treat {@link ConditionTreeGroup} as
+ * the tree's entry type.
+ */
+interface ConditionTreeGroup {
+  kind: "group";
+  op: "and" | "or";
+  items: readonly ConditionTreeNode[];
+}
+/**
+ * A node in the condition tree: a nested group or a leaf rule.
+ */
+type ConditionTreeNode = ConditionTreeGroup | ConditionTreeRule;
+//#endregion
+//#region src/condition/compile-tree.d.ts
+/**
+ * Compile a condition tree to a canonical ZEN expression, or `""` when no rule in
+ * the tree is compilable (see the module note for the drop semantics).
+ */
+declare function compileConditionTree(tree: ConditionTreeGroup): string;
+//#endregion
+//#region src/condition/lift-tree.d.ts
+/**
+ * Lift a ZEN expression to a condition tree, or `null` when it is not in the
+ * canonical form {@link compileConditionTree} produces (the consumer then keeps the
+ * raw expression). Groups nested deeper than 64 parenthesized levels are refused as
+ * non-canonical rather than risking parser-stack overflow on adversarial input. The
+ * returned root is always a group.
+ */
+declare function liftConditionTree(expression: string): ConditionTreeGroup | null;
+//#endregion
 //#region src/engine/evaluate.d.ts
 /**
  * Evaluate a standard ZEN expression, loading the engine on first use.
@@ -491,5 +609,73 @@ declare function configureExpressionMessages({
  */
 declare function getExpressionMessages(): ExpressionMessages;
 //#endregion
-export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type LoadEngineOptions, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileGroup, configureEngine, configureExpressionMessages, enMessages, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, isEngineReady, loadEngine, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, selectBranch, selectBranchWith, toZenLiteral, zhCNMessages };
+//#region src/engine/template.d.ts
+/**
+ * One `{{ expression }}` hole located in a template document. `from` / `to` are
+ * the character offsets of the inner expression itself — the text between the
+ * `{{` and `}}` delimiters, delimiters excluded — so a hole's diagnostics and
+ * inferred-type spans map straight back onto the template with no delimiter math.
+ */
+interface TemplateHole {
+  /**
+   * Offset of the inner expression start (immediately after `{{`).
+   */
+  from: number;
+  /**
+   * Offset of the inner expression end (immediately before `}}`).
+   */
+  to: number;
+  /**
+   * The inner expression text, i.e. `source.slice(from, to)`.
+   */
+  expression: string;
+}
+/**
+ * Extract every `{{ expression }}` hole from a template document, in source
+ * order. Literal text outside holes is ignored. Pure string scan — no engine
+ * required — matching the `@gorules/lezer-zen-template` hole grammar, so it is
+ * consistent with the editor's highlighting and completion gating.
+ */
+declare function parseTemplateHoles(source: string): TemplateHole[];
+/**
+ * The template hole whose inner expression range contains `pos` (boundaries
+ * included, so a caret sitting right after `{{` or right before `}}` counts as
+ * inside), or `null` when `pos` is in literal text. Drives the editor's
+ * hole-scoped completion and hover: intelligence fires inside a hole, nothing in
+ * the surrounding literal text.
+ */
+declare function templateHoleAt(source: string, pos: number): TemplateHole | null;
+/**
+ * Type-check every hole of a template against a `variables` context and merge the
+ * results into one {@link ExpressionAnalysis} whose spans are offset onto the
+ * template document. Each hole is a standard ZEN value expression; literal text
+ * contributes nothing. `rootKind` is the context itself (shared by every hole),
+ * so top-level completion works even in an empty hole.
+ *
+ * Best-effort: a hole that fails to analyze (e.g. mid-edit syntax) is skipped
+ * rather than discarding the spans of its siblings. Throws
+ * {@link ExpressionNotReadyError} if the engine has not loaded — use only behind
+ * a readiness gate.
+ */
+declare function analyzeTemplateSync(variables: ExpressionType, source: string): ExpressionAnalysis;
+/**
+ * Async {@link analyzeTemplateSync}, loading the engine on first use.
+ */
+declare function analyzeTemplate(variables: ExpressionType, source: string): Promise<ExpressionAnalysis>;
+/**
+ * Validate every hole of a template and return their syntax diagnostics, each
+ * offset onto the template document (empty holes and literal text produce none).
+ * The single-expression {@link getDiagnosticsSync} yields at most one diagnostic
+ * per hole, so a template with several broken holes surfaces each one.
+ *
+ * Throws {@link ExpressionNotReadyError} if the engine has not loaded — use only
+ * behind a readiness gate.
+ */
+declare function getTemplateDiagnosticsSync(source: string): ExpressionDiagnostic[];
+/**
+ * Async {@link getTemplateDiagnosticsSync}, loading the engine on first use.
+ */
+declare function getTemplateDiagnostics(source: string): Promise<ExpressionDiagnostic[]>;
+//#endregion
+export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConditionOperatorArity, type ConditionScalar, type ConditionTreeGroup, type ConditionTreeNode, type ConditionTreeOperator, type ConditionTreeRule, type ConditionTreeValue, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type LoadEngineOptions, type TemplateHole, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, enMessages, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, liftConditionTree, loadEngine, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, selectBranch, selectBranchWith, templateHoleAt, toZenLiteral, zhCNMessages };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -2,9 +2,20 @@ import { InitInput } from "@gorules/zen-engine-wasm";
 
 //#region src/engine/intellisense.d.ts
 /**
- * Whether an expression is a standard value expression or a unary (test) expression.
+ * How an expression editor interprets its document:
+ *
+ * - `"standard"` — a single ZEN value expression.
+ * - `"unary"` — a single ZEN unary (test) expression, evaluating to a boolean.
+ * - `"template"` — literal text with `{{ expression }}` holes; each hole is a
+ * standard value expression, the surrounding text is inert.
+ *
+ * The single-expression intellisense functions here ({@link getDiagnosticsSync},
+ * {@link analyzeTypesSync}) treat a `"template"` argument as `"standard"` — they
+ * analyze one expression. Whole template documents are handled hole-by-hole by
+ * the template functions ({@link analyzeTemplateSync},
+ * {@link getTemplateDiagnosticsSync}).
  */
-type ExpressionMode = "standard" | "unary";
+type ExpressionMode = "standard" | "unary" | "template";
 /**
  * A ZEN type descriptor — the shape the engine understands for type-aware
  * completion and validation: a primitive kind name or one of the structural
@@ -273,6 +284,22 @@ declare const CONDITION_OPERATORS: readonly ["eq", "ne", "gt", "gte", "lt", "lte
  * vocabulary (the flow editor shares it instead of re-declaring its own).
  */
 type ConditionOperator = typeof CONDITION_OPERATORS[number];
+/**
+ * The shape of an operator's right-hand operand:
+ *
+ * - `scalar` — a single comparison value (`eq`, `gt`, `contains`, …);
+ * - `array` — a list of membership values (`in` / `not_in`);
+ * - `none` — no operand at all (`is_empty` / `is_not_empty`).
+ */
+type ConditionOperatorArity = "scalar" | "array" | "none";
+/**
+ * The arity of `operator`'s right-hand operand (see
+ * {@link ConditionOperatorArity}). One definition site next to
+ * {@link CONDITION_OPERATORS}, so the tree compiler's arity enforcement and a
+ * condition editor's operand controls classify operators identically instead of
+ * each keeping a drift-prone copy.
+ */
+declare function conditionOperatorArity(operator: ConditionOperator): ConditionOperatorArity;
 /**
  * A field/operator/value condition.
  */
@@ -379,6 +406,97 @@ declare function selectBranchWith(branches: readonly ConditionBranchInput[], con
  */
 declare function selectBranch(branches: readonly ConditionBranchInput[], context: ExpressionContext): Promise<BranchSelection>;
 //#endregion
+//#region src/condition/tree-types.d.ts
+/**
+ * The visual condition **tree** model: an arbitrarily nested and/or tree of typed
+ * comparison rules that {@link compileConditionTree} serializes to a single ZEN
+ * boolean expression and {@link liftConditionTree} reconstructs from one. It is a
+ * distinct, self-contained shape from the compiler's flat {@link ConditionInput} —
+ * the tree is what a structured builder UI edits, whereas `ConditionInput` is the
+ * narrowed per-condition shape the compiler consumes. The two meet only at the
+ * leaf: a {@link ConditionTreeRule} lowers to a field {@link ConditionInput} so the
+ * operator vocabulary, literal encoding, and injection guard have one owner.
+ */
+/**
+ * A scalar operand: the value types ZEN compares against and that survive the
+ * compile/lift round-trip (strings, numbers, booleans). Objects and null are not
+ * representable as a rule operand.
+ */
+type ConditionScalar = string | number | boolean;
+/**
+ * A rule's right-hand operand, whose shape follows the operator's arity:
+ *
+ * - comparison / string operators (`eq`, `gt`, `contains`, …) take a single
+ * {@link ConditionScalar};
+ * - membership operators (`in`, `not_in`) take an array of scalars;
+ * - the emptiness operators (`is_empty`, `is_not_empty`) take no operand and omit
+ * `right` entirely.
+ *
+ * The builder keeps a rule's `right` consistent with its operator's arity as the
+ * author switches operators.
+ */
+type ConditionTreeValue = ConditionScalar | readonly ConditionScalar[];
+/**
+ * The tree's operator vocabulary as a runtime list — the compiler's full
+ * {@link CONDITION_OPERATORS} set under the tree name. An alias, not a second
+ * hand-maintained list, so the tree vocabulary can never drift from the compiler's;
+ * it gives tree code and the builder UI one tree-named import for the operators they
+ * support.
+ */
+declare const CONDITION_TREE_OPERATORS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "contains", "not_contains", "starts_with", "ends_with", "in", "not_in", "is_empty", "is_not_empty"];
+/**
+ * The tree's operator type: every operator {@link compileCondition} can emit (all
+ * 14). The builder deliberately constructs the whole set, so there is no "the library
+ * compiles it but the builder cannot express it" gap. Derived from
+ * {@link CONDITION_TREE_OPERATORS} so the type and the runtime list share one
+ * definition; identical to the compiler's `ConditionOperator`.
+ */
+type ConditionTreeOperator = typeof CONDITION_TREE_OPERATORS[number];
+/**
+ * A leaf comparison. `left` is a field path emitted **verbatim** into ZEN (guarded
+ * by the same identifier-path predicate as {@link compileCondition}); `right`
+ * carries the operand for the operator's arity (see {@link ConditionTreeValue}) and
+ * is absent for the emptiness operators.
+ */
+interface ConditionTreeRule {
+  kind: "rule";
+  left: string;
+  operator: ConditionTreeOperator;
+  right?: ConditionTreeValue;
+}
+/**
+ * A boolean group joining its `items` with `op`. Items are leaf rules or nested
+ * groups, making the model an arbitrarily deep and/or tree. The root of a lifted
+ * condition is always a group, so callers can treat {@link ConditionTreeGroup} as
+ * the tree's entry type.
+ */
+interface ConditionTreeGroup {
+  kind: "group";
+  op: "and" | "or";
+  items: readonly ConditionTreeNode[];
+}
+/**
+ * A node in the condition tree: a nested group or a leaf rule.
+ */
+type ConditionTreeNode = ConditionTreeGroup | ConditionTreeRule;
+//#endregion
+//#region src/condition/compile-tree.d.ts
+/**
+ * Compile a condition tree to a canonical ZEN expression, or `""` when no rule in
+ * the tree is compilable (see the module note for the drop semantics).
+ */
+declare function compileConditionTree(tree: ConditionTreeGroup): string;
+//#endregion
+//#region src/condition/lift-tree.d.ts
+/**
+ * Lift a ZEN expression to a condition tree, or `null` when it is not in the
+ * canonical form {@link compileConditionTree} produces (the consumer then keeps the
+ * raw expression). Groups nested deeper than 64 parenthesized levels are refused as
+ * non-canonical rather than risking parser-stack overflow on adversarial input. The
+ * returned root is always a group.
+ */
+declare function liftConditionTree(expression: string): ConditionTreeGroup | null;
+//#endregion
 //#region src/engine/evaluate.d.ts
 /**
  * Evaluate a standard ZEN expression, loading the engine on first use.
@@ -491,5 +609,73 @@ declare function configureExpressionMessages({
  */
 declare function getExpressionMessages(): ExpressionMessages;
 //#endregion
-export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type LoadEngineOptions, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileGroup, configureEngine, configureExpressionMessages, enMessages, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, isEngineReady, loadEngine, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, selectBranch, selectBranchWith, toZenLiteral, zhCNMessages };
+//#region src/engine/template.d.ts
+/**
+ * One `{{ expression }}` hole located in a template document. `from` / `to` are
+ * the character offsets of the inner expression itself — the text between the
+ * `{{` and `}}` delimiters, delimiters excluded — so a hole's diagnostics and
+ * inferred-type spans map straight back onto the template with no delimiter math.
+ */
+interface TemplateHole {
+  /**
+   * Offset of the inner expression start (immediately after `{{`).
+   */
+  from: number;
+  /**
+   * Offset of the inner expression end (immediately before `}}`).
+   */
+  to: number;
+  /**
+   * The inner expression text, i.e. `source.slice(from, to)`.
+   */
+  expression: string;
+}
+/**
+ * Extract every `{{ expression }}` hole from a template document, in source
+ * order. Literal text outside holes is ignored. Pure string scan — no engine
+ * required — matching the `@gorules/lezer-zen-template` hole grammar, so it is
+ * consistent with the editor's highlighting and completion gating.
+ */
+declare function parseTemplateHoles(source: string): TemplateHole[];
+/**
+ * The template hole whose inner expression range contains `pos` (boundaries
+ * included, so a caret sitting right after `{{` or right before `}}` counts as
+ * inside), or `null` when `pos` is in literal text. Drives the editor's
+ * hole-scoped completion and hover: intelligence fires inside a hole, nothing in
+ * the surrounding literal text.
+ */
+declare function templateHoleAt(source: string, pos: number): TemplateHole | null;
+/**
+ * Type-check every hole of a template against a `variables` context and merge the
+ * results into one {@link ExpressionAnalysis} whose spans are offset onto the
+ * template document. Each hole is a standard ZEN value expression; literal text
+ * contributes nothing. `rootKind` is the context itself (shared by every hole),
+ * so top-level completion works even in an empty hole.
+ *
+ * Best-effort: a hole that fails to analyze (e.g. mid-edit syntax) is skipped
+ * rather than discarding the spans of its siblings. Throws
+ * {@link ExpressionNotReadyError} if the engine has not loaded — use only behind
+ * a readiness gate.
+ */
+declare function analyzeTemplateSync(variables: ExpressionType, source: string): ExpressionAnalysis;
+/**
+ * Async {@link analyzeTemplateSync}, loading the engine on first use.
+ */
+declare function analyzeTemplate(variables: ExpressionType, source: string): Promise<ExpressionAnalysis>;
+/**
+ * Validate every hole of a template and return their syntax diagnostics, each
+ * offset onto the template document (empty holes and literal text produce none).
+ * The single-expression {@link getDiagnosticsSync} yields at most one diagnostic
+ * per hole, so a template with several broken holes surfaces each one.
+ *
+ * Throws {@link ExpressionNotReadyError} if the engine has not loaded — use only
+ * behind a readiness gate.
+ */
+declare function getTemplateDiagnosticsSync(source: string): ExpressionDiagnostic[];
+/**
+ * Async {@link getTemplateDiagnosticsSync}, loading the engine on first use.
+ */
+declare function getTemplateDiagnostics(source: string): Promise<ExpressionDiagnostic[]>;
+//#endregion
+export { type BranchSelection, type BuiltInExpressionLocale, CONDITION_OPERATORS, CONDITION_TREE_OPERATORS, type ConditionBranchInput, type ConditionGroupInput, type ConditionInput, type ConditionOperator, type ConditionOperatorArity, type ConditionScalar, type ConditionTreeGroup, type ConditionTreeNode, type ConditionTreeOperator, type ConditionTreeRule, type ConditionTreeValue, type ConfigureMessagesOptions, type ExpressionAnalysis, type ExpressionCompletion, type ExpressionConditionInput, type ExpressionContext, type ExpressionDiagnostic, type ExpressionEngine, ExpressionError, type ExpressionLocale, type ExpressionMessages, type ExpressionMode, ExpressionNotReadyError, type ExpressionType, type ExpressionTypeSpan, type FieldConditionInput, type LoadEngineOptions, type TemplateHole, analyzeTemplate, analyzeTemplateSync, analyzeTypes, analyzeTypesSync, compileBranch, compileCondition, compileConditionTree, compileGroup, conditionOperatorArity, configureEngine, configureExpressionMessages, enMessages, evaluate, evaluateSync, evaluateUnary, evaluateUnarySync, getCompletionItems, getCompletionItemsSync, getDiagnostics, getDiagnosticsSync, getEngineError, getEngineSync, getExpressionMessages, getTemplateDiagnostics, getTemplateDiagnosticsSync, isEngineReady, liftConditionTree, loadEngine, parseTemplateHoles, registerExpressionLocale, resetEngine, satisfiesType, satisfiesTypeSync, selectBranch, selectBranchWith, templateHoleAt, toZenLiteral, zhCNMessages };
 //# sourceMappingURL=index.d.ts.map