trilean 0.0.0 → 1.0.0

package/dist/tree.d.ts

@@ -0,0 +1,368 @@
+import { t as JsonValue } from "./json-value-B1Hjjjri.js";
+import { z } from "zod";
+//#region src/tree.d.ts
+declare const ComparisonOperatorSchema: z.ZodEnum<{
+  gt: "gt";
+  gte: "gte";
+  lt: "lt";
+  lte: "lte";
+  eq: "eq";
+  neq: "neq";
+}>;
+type ComparisonOperator = z.infer<typeof ComparisonOperatorSchema>;
+declare const TextComparisonOperatorSchema: z.ZodEnum<{
+  equals: "equals";
+  notEquals: "notEquals";
+  matches: "matches";
+  notMatches: "notMatches";
+}>;
+type TextComparisonOperator = z.infer<typeof TextComparisonOperatorSchema>;
+declare const MembershipOperatorSchema: z.ZodEnum<{
+  in: "in";
+  notIn: "notIn";
+}>;
+type MembershipOperator = z.infer<typeof MembershipOperatorSchema>;
+declare const ArithmeticOperatorSchema: z.ZodEnum<{
+  add: "add";
+  subtract: "subtract";
+  multiply: "multiply";
+  divide: "divide";
+  power: "power";
+  modulo: "modulo";
+}>;
+type ArithmeticOperator = z.infer<typeof ArithmeticOperatorSchema>;
+declare const NotNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"not">;
+  operand: typeof PredicateNodeSchema;
+}, z.core.$strip>;
+type NotNode = z.infer<typeof NotNodeSchema>;
+declare const AndNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"and">;
+  left: typeof PredicateNodeSchema;
+  right: typeof PredicateNodeSchema;
+}, z.core.$strip>;
+type AndNode = z.infer<typeof AndNodeSchema>;
+declare const OrNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"or">;
+  left: typeof PredicateNodeSchema;
+  right: typeof PredicateNodeSchema;
+}, z.core.$strip>;
+type OrNode = z.infer<typeof OrNodeSchema>;
+declare const AllOfNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"allOf">;
+  operands: z.ZodArray<typeof PredicateNodeSchema>;
+}, z.core.$strip>;
+type AllOfNode = z.infer<typeof AllOfNodeSchema>;
+declare const AnyOfNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"anyOf">;
+  operands: z.ZodArray<typeof PredicateNodeSchema>;
+}, z.core.$strip>;
+type AnyOfNode = z.infer<typeof AnyOfNodeSchema>;
+declare const CompareNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"compare">;
+  op: z.ZodEnum<{
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    eq: "eq";
+    neq: "neq";
+  }>;
+  left: typeof ExpressionNodeSchema;
+  right: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type CompareNode = z.infer<typeof CompareNodeSchema>;
+declare const TextCompareNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"textCompare">;
+  op: z.ZodEnum<{
+    equals: "equals";
+    notEquals: "notEquals";
+    matches: "matches";
+    notMatches: "notMatches";
+  }>;
+  left: typeof ExpressionNodeSchema;
+  right: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type TextCompareNode = z.infer<typeof TextCompareNodeSchema>;
+declare const MemberOfNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"memberOf">;
+  op: z.ZodEnum<{
+    in: "in";
+    notIn: "notIn";
+  }>;
+  operand: typeof ExpressionNodeSchema;
+  candidates: z.ZodArray<typeof ExpressionNodeSchema>;
+}, z.core.$strip>;
+type MemberOfNode = z.infer<typeof MemberOfNodeSchema>;
+declare const ExistsNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"exists">;
+  operand: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type ExistsNode = z.infer<typeof ExistsNodeSchema>;
+declare const SomeNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"some">;
+  collection: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  item: typeof PredicateNodeSchema;
+  filter: z.ZodOptional<typeof PredicateNodeSchema>;
+}, z.core.$strip>;
+type SomeNode = z.infer<typeof SomeNodeSchema>;
+declare const EveryNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"every">;
+  collection: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  item: typeof PredicateNodeSchema;
+  filter: z.ZodOptional<typeof PredicateNodeSchema>;
+}, z.core.$strip>;
+type EveryNode = z.infer<typeof EveryNodeSchema>;
+declare const PredicateNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"not">;
+  operand: typeof PredicateNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"and">;
+  left: typeof PredicateNodeSchema;
+  right: typeof PredicateNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"or">;
+  left: typeof PredicateNodeSchema;
+  right: typeof PredicateNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"allOf">;
+  operands: z.ZodArray<typeof PredicateNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"anyOf">;
+  operands: z.ZodArray<typeof PredicateNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"compare">;
+  op: z.ZodEnum<{
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    eq: "eq";
+    neq: "neq";
+  }>;
+  left: typeof ExpressionNodeSchema;
+  right: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"textCompare">;
+  op: z.ZodEnum<{
+    equals: "equals";
+    notEquals: "notEquals";
+    matches: "matches";
+    notMatches: "notMatches";
+  }>;
+  left: typeof ExpressionNodeSchema;
+  right: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"memberOf">;
+  op: z.ZodEnum<{
+    in: "in";
+    notIn: "notIn";
+  }>;
+  operand: typeof ExpressionNodeSchema;
+  candidates: z.ZodArray<typeof ExpressionNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"exists">;
+  operand: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"some">;
+  collection: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  item: typeof PredicateNodeSchema;
+  filter: z.ZodOptional<typeof PredicateNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"every">;
+  collection: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  item: typeof PredicateNodeSchema;
+  filter: z.ZodOptional<typeof PredicateNodeSchema>;
+}, z.core.$strip>], "kind">;
+type PredicateNode = z.infer<typeof PredicateNodeSchema>;
+declare const NumberLiteralNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"numberLiteral">;
+  value: z.ZodNumber;
+  unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+type NumberLiteralNode = z.infer<typeof NumberLiteralNodeSchema>;
+declare const TextLiteralNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"textLiteral">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type TextLiteralNode = z.infer<typeof TextLiteralNodeSchema>;
+declare const InstantLiteralNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"instantLiteral">;
+  value: z.ZodString;
+}, z.core.$strip>;
+type InstantLiteralNode = z.infer<typeof InstantLiteralNodeSchema>;
+declare const DurationLiteralNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"durationLiteral">;
+  value: z.ZodNumber;
+  unit: z.ZodEnum<{
+    ms: "ms";
+    s: "s";
+    min: "min";
+    h: "h";
+    d: "d";
+  }>;
+}, z.core.$strip>;
+type DurationLiteralNode = z.infer<typeof DurationLiteralNodeSchema>;
+declare const ReferenceNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"reference">;
+  key: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+type ReferenceNode = z.infer<typeof ReferenceNodeSchema>;
+declare const ArithmeticNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"arithmetic">;
+  op: z.ZodEnum<{
+    add: "add";
+    subtract: "subtract";
+    multiply: "multiply";
+    divide: "divide";
+    power: "power";
+    modulo: "modulo";
+  }>;
+  left: typeof ExpressionNodeSchema;
+  right: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type ArithmeticNode = z.infer<typeof ArithmeticNodeSchema>;
+declare const NegateNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"negate">;
+  operand: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type NegateNode = z.infer<typeof NegateNodeSchema>;
+declare const CallNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"call">;
+  fn: z.ZodString;
+  args: z.ZodArray<typeof ExpressionNodeSchema>;
+}, z.core.$strip>;
+type CallNode = z.infer<typeof CallNodeSchema>;
+declare const LookupNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"lookup">;
+  table: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  keys: z.ZodArray<typeof ExpressionNodeSchema>;
+}, z.core.$strip>;
+type LookupNode = z.infer<typeof LookupNodeSchema>;
+declare const ConditionalCaseSchema: z.ZodObject<{
+  when: typeof PredicateNodeSchema;
+  then: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type ConditionalCase = z.infer<typeof ConditionalCaseSchema>;
+declare const ConditionalNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"conditional">;
+  cases: z.ZodArray<typeof ConditionalCaseSchema>;
+  fallback: typeof ExpressionNodeSchema;
+}, z.core.$strip>;
+type ConditionalNode = z.infer<typeof ConditionalNodeSchema>;
+declare const FoldCombinerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  mode: z.ZodLiteral<"max">;
+  item: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  mode: z.ZodLiteral<"min">;
+  item: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  mode: z.ZodLiteral<"reduce">;
+  initial: typeof ExpressionNodeSchema;
+  combine: typeof ExpressionNodeSchema;
+}, z.core.$strip>], "mode">;
+type FoldCombiner = z.infer<typeof FoldCombinerSchema>;
+declare const FoldNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"fold">;
+  collection: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  filter: z.ZodOptional<typeof PredicateNodeSchema>;
+  combiner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"max">;
+    item: typeof ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"min">;
+    item: typeof ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"reduce">;
+    initial: typeof ExpressionNodeSchema;
+    combine: typeof ExpressionNodeSchema;
+  }, z.core.$strip>], "mode">;
+}, z.core.$strip>;
+type FoldNode = z.infer<typeof FoldNodeSchema>;
+declare const AccumulatorNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"accumulator">;
+}, z.core.$strip>;
+type AccumulatorNode = z.infer<typeof AccumulatorNodeSchema>;
+declare const DelegateNodeSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"delegate">;
+  system: z.ZodString;
+  payload: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strip>;
+type DelegateNode = z.infer<typeof DelegateNodeSchema>;
+declare const ExpressionNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"numberLiteral">;
+  value: z.ZodNumber;
+  unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"textLiteral">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"instantLiteral">;
+  value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"durationLiteral">;
+  value: z.ZodNumber;
+  unit: z.ZodEnum<{
+    ms: "ms";
+    s: "s";
+    min: "min";
+    h: "h";
+    d: "d";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"reference">;
+  key: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"arithmetic">;
+  op: z.ZodEnum<{
+    add: "add";
+    subtract: "subtract";
+    multiply: "multiply";
+    divide: "divide";
+    power: "power";
+    modulo: "modulo";
+  }>;
+  left: typeof ExpressionNodeSchema;
+  right: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"negate">;
+  operand: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"call">;
+  fn: z.ZodString;
+  args: z.ZodArray<typeof ExpressionNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"lookup">;
+  table: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  keys: z.ZodArray<typeof ExpressionNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"conditional">;
+  cases: z.ZodArray<typeof ConditionalCaseSchema>;
+  fallback: typeof ExpressionNodeSchema;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"fold">;
+  collection: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+  filter: z.ZodOptional<typeof PredicateNodeSchema>;
+  combiner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"max">;
+    item: typeof ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"min">;
+    item: typeof ExpressionNodeSchema;
+  }, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"reduce">;
+    initial: typeof ExpressionNodeSchema;
+    combine: typeof ExpressionNodeSchema;
+  }, z.core.$strip>], "mode">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"accumulator">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"delegate">;
+  system: z.ZodString;
+  payload: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strip>], "kind">;
+type ExpressionNode = z.infer<typeof ExpressionNodeSchema>;
+//#endregion
+export { AccumulatorNode, AccumulatorNodeSchema, AllOfNode, AllOfNodeSchema, AndNode, AndNodeSchema, AnyOfNode, AnyOfNodeSchema, ArithmeticNode, ArithmeticNodeSchema, ArithmeticOperator, ArithmeticOperatorSchema, CallNode, CallNodeSchema, CompareNode, CompareNodeSchema, ComparisonOperator, ComparisonOperatorSchema, ConditionalCase, ConditionalCaseSchema, ConditionalNode, ConditionalNodeSchema, DelegateNode, DelegateNodeSchema, DurationLiteralNode, DurationLiteralNodeSchema, EveryNode, EveryNodeSchema, ExistsNode, ExistsNodeSchema, ExpressionNode, ExpressionNodeSchema, FoldCombiner, FoldCombinerSchema, FoldNode, FoldNodeSchema, InstantLiteralNode, InstantLiteralNodeSchema, LookupNode, LookupNodeSchema, MemberOfNode, MemberOfNodeSchema, MembershipOperator, MembershipOperatorSchema, NegateNode, NegateNodeSchema, NotNode, NotNodeSchema, NumberLiteralNode, NumberLiteralNodeSchema, OrNode, OrNodeSchema, PredicateNode, PredicateNodeSchema, ReferenceNode, ReferenceNodeSchema, SomeNode, SomeNodeSchema, TextCompareNode, TextCompareNodeSchema, TextComparisonOperator, TextComparisonOperatorSchema, TextLiteralNode, TextLiteralNodeSchema };

package/dist/tree.js

@@ -0,0 +1,257 @@
+import { DurationUnitSchema, UnitSchema } from "./computed-value.js";
+import { JsonValueSchema } from "./json-value.js";
+import { z } from "zod";
+//#region src/tree.ts
+const ComparisonOperatorSchema = z.enum([
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"eq",
+	"neq"
+]);
+const TextComparisonOperatorSchema = z.enum([
+	"equals",
+	"notEquals",
+	"matches",
+	"notMatches"
+]);
+const MembershipOperatorSchema = z.enum(["in", "notIn"]);
+const ArithmeticOperatorSchema = z.enum([
+	"add",
+	"subtract",
+	"multiply",
+	"divide",
+	"power",
+	"modulo"
+]);
+const NotNodeSchema = z.object({
+	kind: z.literal("not"),
+	get operand() {
+		return PredicateNodeSchema;
+	}
+});
+const AndNodeSchema = z.object({
+	kind: z.literal("and"),
+	get left() {
+		return PredicateNodeSchema;
+	},
+	get right() {
+		return PredicateNodeSchema;
+	}
+});
+const OrNodeSchema = z.object({
+	kind: z.literal("or"),
+	get left() {
+		return PredicateNodeSchema;
+	},
+	get right() {
+		return PredicateNodeSchema;
+	}
+});
+const AllOfNodeSchema = z.object({
+	kind: z.literal("allOf"),
+	get operands() {
+		return z.array(PredicateNodeSchema);
+	}
+});
+const AnyOfNodeSchema = z.object({
+	kind: z.literal("anyOf"),
+	get operands() {
+		return z.array(PredicateNodeSchema);
+	}
+});
+const CompareNodeSchema = z.object({
+	kind: z.literal("compare"),
+	op: ComparisonOperatorSchema,
+	get left() {
+		return ExpressionNodeSchema;
+	},
+	get right() {
+		return ExpressionNodeSchema;
+	}
+});
+const TextCompareNodeSchema = z.object({
+	kind: z.literal("textCompare"),
+	op: TextComparisonOperatorSchema,
+	get left() {
+		return ExpressionNodeSchema;
+	},
+	get right() {
+		return ExpressionNodeSchema;
+	}
+});
+const MemberOfNodeSchema = z.object({
+	kind: z.literal("memberOf"),
+	op: MembershipOperatorSchema,
+	get operand() {
+		return ExpressionNodeSchema;
+	},
+	get candidates() {
+		return z.array(ExpressionNodeSchema);
+	}
+});
+const ExistsNodeSchema = z.object({
+	kind: z.literal("exists"),
+	get operand() {
+		return ExpressionNodeSchema;
+	}
+});
+const SomeNodeSchema = z.object({
+	kind: z.literal("some"),
+	collection: JsonValueSchema,
+	get item() {
+		return PredicateNodeSchema;
+	},
+	get filter() {
+		return PredicateNodeSchema.optional();
+	}
+});
+const EveryNodeSchema = z.object({
+	kind: z.literal("every"),
+	collection: JsonValueSchema,
+	get item() {
+		return PredicateNodeSchema;
+	},
+	get filter() {
+		return PredicateNodeSchema.optional();
+	}
+});
+const PredicateNodeSchema = z.discriminatedUnion("kind", [
+	NotNodeSchema,
+	AndNodeSchema,
+	OrNodeSchema,
+	AllOfNodeSchema,
+	AnyOfNodeSchema,
+	CompareNodeSchema,
+	TextCompareNodeSchema,
+	MemberOfNodeSchema,
+	ExistsNodeSchema,
+	SomeNodeSchema,
+	EveryNodeSchema
+]);
+const NumberLiteralNodeSchema = z.object({
+	kind: z.literal("numberLiteral"),
+	value: z.number(),
+	unit: UnitSchema.optional()
+});
+const TextLiteralNodeSchema = z.object({
+	kind: z.literal("textLiteral"),
+	value: z.string()
+});
+const InstantLiteralNodeSchema = z.object({
+	kind: z.literal("instantLiteral"),
+	/** ISO-8601 timestamp. */
+	value: z.string()
+});
+const DurationLiteralNodeSchema = z.object({
+	kind: z.literal("durationLiteral"),
+	value: z.number(),
+	unit: DurationUnitSchema
+});
+const ReferenceNodeSchema = z.object({
+	kind: z.literal("reference"),
+	key: JsonValueSchema,
+	unit: UnitSchema.optional()
+});
+const ArithmeticNodeSchema = z.object({
+	kind: z.literal("arithmetic"),
+	op: ArithmeticOperatorSchema,
+	get left() {
+		return ExpressionNodeSchema;
+	},
+	get right() {
+		return ExpressionNodeSchema;
+	}
+});
+const NegateNodeSchema = z.object({
+	kind: z.literal("negate"),
+	get operand() {
+		return ExpressionNodeSchema;
+	}
+});
+const CallNodeSchema = z.object({
+	kind: z.literal("call"),
+	fn: z.string(),
+	get args() {
+		return z.array(ExpressionNodeSchema);
+	}
+});
+const LookupNodeSchema = z.object({
+	kind: z.literal("lookup"),
+	table: JsonValueSchema,
+	get keys() {
+		return z.array(ExpressionNodeSchema);
+	}
+});
+const ConditionalCaseSchema = z.object({
+	get when() {
+		return PredicateNodeSchema;
+	},
+	get then() {
+		return ExpressionNodeSchema;
+	}
+});
+const ConditionalNodeSchema = z.object({
+	kind: z.literal("conditional"),
+	get cases() {
+		return z.array(ConditionalCaseSchema);
+	},
+	get fallback() {
+		return ExpressionNodeSchema;
+	}
+});
+const FoldCombinerSchema = z.discriminatedUnion("mode", [
+	z.object({
+		mode: z.literal("max"),
+		get item() {
+			return ExpressionNodeSchema;
+		}
+	}),
+	z.object({
+		mode: z.literal("min"),
+		get item() {
+			return ExpressionNodeSchema;
+		}
+	}),
+	z.object({
+		mode: z.literal("reduce"),
+		get initial() {
+			return ExpressionNodeSchema;
+		},
+		get combine() {
+			return ExpressionNodeSchema;
+		}
+	})
+]);
+const FoldNodeSchema = z.object({
+	kind: z.literal("fold"),
+	collection: JsonValueSchema,
+	get filter() {
+		return PredicateNodeSchema.optional();
+	},
+	combiner: FoldCombinerSchema
+});
+const AccumulatorNodeSchema = z.object({ kind: z.literal("accumulator") });
+const DelegateNodeSchema = z.object({
+	kind: z.literal("delegate"),
+	system: z.string(),
+	payload: JsonValueSchema
+});
+const ExpressionNodeSchema = z.discriminatedUnion("kind", [
+	NumberLiteralNodeSchema,
+	TextLiteralNodeSchema,
+	InstantLiteralNodeSchema,
+	DurationLiteralNodeSchema,
+	ReferenceNodeSchema,
+	ArithmeticNodeSchema,
+	NegateNodeSchema,
+	CallNodeSchema,
+	LookupNodeSchema,
+	ConditionalNodeSchema,
+	FoldNodeSchema,
+	AccumulatorNodeSchema,
+	DelegateNodeSchema
+]);
+//#endregion
+export { AccumulatorNodeSchema, AllOfNodeSchema, AndNodeSchema, AnyOfNodeSchema, ArithmeticNodeSchema, ArithmeticOperatorSchema, CallNodeSchema, CompareNodeSchema, ComparisonOperatorSchema, ConditionalCaseSchema, ConditionalNodeSchema, DelegateNodeSchema, DurationLiteralNodeSchema, EveryNodeSchema, ExistsNodeSchema, ExpressionNodeSchema, FoldCombinerSchema, FoldNodeSchema, InstantLiteralNodeSchema, LookupNodeSchema, MemberOfNodeSchema, MembershipOperatorSchema, NegateNodeSchema, NotNodeSchema, NumberLiteralNodeSchema, OrNodeSchema, PredicateNodeSchema, ReferenceNodeSchema, SomeNodeSchema, TextCompareNodeSchema, TextComparisonOperatorSchema, TextLiteralNodeSchema };