@shwfed/config 2.12.3 → 2.12.5

package/dist/runtime/vendor/cel-js/lib/functions.js

@@ -4,7 +4,7 @@ import { TYPES, Type } from "./registry.js";
 import { register as registerOptional, optionalOf } from "./optional.js";
 import { objKeys, arrayFrom } from "./globals.js";
 import { TZDate } from "@date-fns/tz";
-import { startOfDay, startOfWeek, startOfMonth, startOfYear, endOfDay, endOfWeek, endOfMonth, endOfYear, addDays, addWeeks, addMonths, addYears, addHours, addMinutes, setDate as setDayOfMonth, setMonth, setYear, format as formatDate, differenceInMilliseconds, differenceInSeconds, differenceInMinutes, differenceInHours, differenceInDays, differenceInWeeks, differenceInMonths, differenceInYears } from "date-fns";
+import { startOfMinute, startOfHour, startOfDay, startOfWeek, startOfMonth, startOfYear, endOfMinute, endOfHour, endOfDay, endOfWeek, endOfMonth, endOfYear, addMilliseconds, addSeconds, addMinutes, addHours, addDays, addWeeks, addMonths, addYears, setMilliseconds, setSeconds, setMinutes, setHours, setDate as setDayOfMonth, setMonth, setYear, format as formatDate, differenceInMilliseconds, differenceInSeconds, differenceInMinutes, differenceInHours, differenceInDays, differenceInWeeks, differenceInMonths, differenceInYears } from "date-fns";
 function toNum(v) {
   if (v instanceof Decimal) return v.toNumber();
   if (typeof v === "bigint") return Number(v);
@@ -82,53 +82,6 @@ export function registerFunctions(registry) {
     }
   });
   functionOverload("number(bool): number", (v) => Decimal.from(v ? 1 : 0));
-  functionOverload("int(number): number", (v) => {
-    const d = Decimal.from(v);
-    if (d.isInteger()) return d;
-    const n = d.toNumber();
-    if (!Number.isFinite(n)) throw evaluationError("numeric_overflow", "int() type error: integer overflow");
-    return Decimal.from(BigInt(Math.trunc(n)));
-  });
-  functionOverload("int(string): number", (v) => {
-    const s = v;
-    if (s !== s.trim() || s.length > 20 || s.includes("0x")) {
-      throw evaluationError("int_conversion_error", "int() type error: cannot convert to int");
-    }
-    try {
-      return Decimal.from(s);
-    } catch {
-      throw evaluationError("int_conversion_error", "int() type error: cannot convert to int");
-    }
-  });
-  functionOverload("double(number): number", (v) => Decimal.from(v));
-  functionOverload("double(string): number", (v) => {
-    const s = v;
-    if (!s || s !== s.trim())
-      throw evaluationError(
-        "double_conversion_error",
-        "double() type error: cannot convert to double"
-      );
-    try {
-      return Decimal.from(s);
-    } catch {
-      throw evaluationError(
-        "double_conversion_error",
-        "double() type error: cannot convert to double"
-      );
-    }
-  });
-  functionOverload("uint(number): number", (v) => Decimal.from(v));
-  functionOverload("uint(string): number", (v) => {
-    const s = v;
-    if (s !== s.trim() || s.length > 20 || s.includes("0x")) {
-      throw evaluationError("uint_conversion_error", "uint() type error: cannot convert to uint");
-    }
-    try {
-      return Decimal.from(s);
-    } catch {
-      throw evaluationError("uint_conversion_error", "uint() type error: cannot convert to uint");
-    }
-  });
   functionOverload("string(string): string", identity);
   functionOverload("string(bool): string", (v) => `${v}`);
   functionOverload("string(number): string", (v) => Decimal.from(v).toString());
@@ -284,23 +237,55 @@ export function registerFunctions(registry) {
     return new TZDate(result.getTime(), source.timeZone);
   }
   registry.registerType("Date", TZDate);
-  functionOverload("date(string): Date", (v) => {
-    const d = new TZDate(v);
+  const singularUnit = (unit) => unit.replace(/s$/, "");
+  function pickUnit(table, unit, method) {
+    const fn = table[singularUnit(unit)];
+    if (fn) return fn;
+    throw evaluationError("invalid_unit", `${method}(): unknown unit "${unit}" (expected ${objKeys(table).join(" / ")})`);
+  }
+  function checkTimeZone(tz) {
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: tz });
+      return tz;
+    } catch {
+      throw evaluationError("invalid_timezone", `Unknown time zone "${tz}" (expected an IANA name like "Asia/Shanghai" or an offset like "+08:00")`);
+    }
+  }
+  const WALL_CLOCK_STRING = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?$/;
+  function dateFromString(v, tz) {
+    const s = v;
+    let d;
+    const m = tz === void 0 ? null : WALL_CLOCK_STRING.exec(s);
+    if (tz === void 0) {
+      d = new TZDate(s);
+    } else if (m) {
+      const ms = +(m[7] ?? "0").padEnd(3, "0").slice(0, 3);
+      d = new TZDate(+m[1], +m[2] - 1, +m[3], +(m[4] ?? "0"), +(m[5] ?? "0"), +(m[6] ?? "0"), ms, tz);
+    } else {
+      d = new TZDate(s, tz);
+    }
     if (Number.isNaN(d.getTime())) throw evaluationError("invalid_date", `date() requires a valid date string, got "${v}"`);
     return d;
-  });
-  functionOverload("date(number): Date", (v) => {
+  }
+  function dateFromTimestamp(v, tz) {
     const n = toNum(v);
     if (!Number.isFinite(n)) {
       throw evaluationError("invalid_date", `date() requires a finite timestamp, got ${v}`);
     }
     const ms = Math.abs(n) < 1e11 ? n * 1e3 : n;
-    const d = new TZDate(ms);
+    const d = tz === void 0 ? new TZDate(ms) : new TZDate(ms, tz);
     if (Number.isNaN(d.getTime())) {
       throw evaluationError("invalid_date", `date() got an out-of-range timestamp: ${v}`);
     }
     return d;
-  });
+  }
+  functionOverload("date(string): Date", (v) => dateFromString(v));
+  functionOverload("date(number): Date", (v) => dateFromTimestamp(v));
+  functionOverload("date(string, string): Date", (v, tz) => dateFromString(v, checkTimeZone(tz)));
+  functionOverload("date(number, string): Date", (v, tz) => dateFromTimestamp(v, checkTimeZone(tz)));
+  functionOverload("Date.tz(string): Date", (d, tz) => new TZDate(d.getTime(), checkTimeZone(tz)));
+  functionOverload("number(Date): number", (v) => Decimal.from(v.getTime()));
+  functionOverload("string(Date): string", (v) => v.toISOString());
   const RANGE_LIMIT = 1e5;
   function numericRange(startD, endD, stepD) {
     const step = stepD.toNumber();
@@ -324,18 +309,17 @@ export function registerFunctions(registry) {
   functionOverload("range(number, number): list<dyn>", (start, end) => numericRange(start, end, Decimal.from(1)));
   functionOverload("range(number, number, number): list<dyn>", (start, end, step) => numericRange(start, end, step));
   const rangeSteppers = {
-    year: addYears,
-    month: addMonths,
-    day: addDays,
+    second: addSeconds,
+    minute: addMinutes,
     hour: addHours,
-    minute: addMinutes
+    day: addDays,
+    week: addWeeks,
+    month: addMonths,
+    year: addYears
   };
   functionOverload("range(Date, Date, string): list<dyn>", (startV, endV, unitV) => {
     const start = startV;
-    const stepFn = rangeSteppers[unitV];
-    if (!stepFn) {
-      throw evaluationError("invalid_unit", `range(): unknown unit "${unitV}" (expected year / month / day / hour / minute)`);
-    }
+    const stepFn = pickUnit(rangeSteppers, unitV, "range");
     const endMs = endV.getTime();
     const ascending = start.getTime() < endMs;
     const out = [];
@@ -349,90 +333,79 @@ export function registerFunctions(registry) {
     }
     return out;
   });
+  const startOfFns = {
+    minute: startOfMinute,
+    hour: startOfHour,
+    day: startOfDay,
+    week: startOfWeek,
+    month: startOfMonth,
+    year: startOfYear
+  };
+  const endOfFns = {
+    minute: endOfMinute,
+    hour: endOfHour,
+    day: endOfDay,
+    week: endOfWeek,
+    month: endOfMonth,
+    year: endOfYear
+  };
+  const offsetFns = {
+    millisecond: addMilliseconds,
+    second: addSeconds,
+    minute: addMinutes,
+    hour: addHours,
+    day: addDays,
+    week: addWeeks,
+    month: addMonths,
+    year: addYears
+  };
+  const setFns = {
+    millisecond: setMilliseconds,
+    second: setSeconds,
+    minute: setMinutes,
+    hour: setHours,
+    day: setDayOfMonth,
+    month: (d, v) => setMonth(d, v - 1),
+    year: setYear
+  };
+  const diffFns = {
+    millisecond: differenceInMilliseconds,
+    second: differenceInSeconds,
+    minute: differenceInMinutes,
+    hour: differenceInHours,
+    day: differenceInDays,
+    week: differenceInWeeks,
+    month: differenceInMonths,
+    year: differenceInYears
+  };
+  const getFns = {
+    millisecond: (d) => d.getMilliseconds(),
+    second: (d) => d.getSeconds(),
+    minute: (d) => d.getMinutes(),
+    hour: (d) => d.getHours(),
+    day: (d) => d.getDate(),
+    weekday: (d) => (d.getDay() + 6) % 7 + 1,
+    month: (d) => d.getMonth() + 1,
+    year: (d) => d.getFullYear()
+  };
   functionOverload("Date.startOf(string): Date", (d, unit) => {
     const date = d;
-    switch (unit) {
-      case "day":
-        return wrapTZ(startOfDay(date), date);
-      case "week":
-        return wrapTZ(startOfWeek(date), date);
-      case "month":
-        return wrapTZ(startOfMonth(date), date);
-      case "year":
-        return wrapTZ(startOfYear(date), date);
-      default:
-        throw evaluationError("invalid_unit", `startOf(): unknown unit "${unit}"`);
-    }
+    return wrapTZ(pickUnit(startOfFns, unit, "startOf")(date), date);
   });
   functionOverload("Date.endOf(string): Date", (d, unit) => {
     const date = d;
-    switch (unit) {
-      case "day":
-        return wrapTZ(endOfDay(date), date);
-      case "week":
-        return wrapTZ(endOfWeek(date), date);
-      case "month":
-        return wrapTZ(endOfMonth(date), date);
-      case "year":
-        return wrapTZ(endOfYear(date), date);
-      default:
-        throw evaluationError("invalid_unit", `endOf(): unknown unit "${unit}"`);
-    }
+    return wrapTZ(pickUnit(endOfFns, unit, "endOf")(date), date);
   });
   functionOverload("Date.offset(number, string): Date", (d, n, unit) => {
     const date = d;
-    const num = toNum(n);
-    switch (unit.replace(/s$/, "")) {
-      case "day":
-        return wrapTZ(addDays(date, num), date);
-      case "week":
-        return wrapTZ(addWeeks(date, num), date);
-      case "month":
-        return wrapTZ(addMonths(date, num), date);
-      case "year":
-        return wrapTZ(addYears(date, num), date);
-      default:
-        throw evaluationError("invalid_unit", `offset(): unknown unit "${unit}"`);
-    }
-  });
-  functionOverload("Date.diff(Date, string): number", (d, other, unit) => {
-    const left = d;
-    const right = other;
-    switch (unit.replace(/s$/, "")) {
-      case "millisecond":
-        return Decimal.from(differenceInMilliseconds(left, right));
-      case "second":
-        return Decimal.from(differenceInSeconds(left, right));
-      case "minute":
-        return Decimal.from(differenceInMinutes(left, right));
-      case "hour":
-        return Decimal.from(differenceInHours(left, right));
-      case "day":
-        return Decimal.from(differenceInDays(left, right));
-      case "week":
-        return Decimal.from(differenceInWeeks(left, right));
-      case "month":
-        return Decimal.from(differenceInMonths(left, right));
-      case "year":
-        return Decimal.from(differenceInYears(left, right));
-      default:
-        throw evaluationError("invalid_unit", `diff(): unknown unit "${unit}"`);
-    }
+    return wrapTZ(pickUnit(offsetFns, unit, "offset")(date, toNum(n)), date);
   });
+  functionOverload("Date.diff(Date, string): number", (d, other, unit) => Decimal.from(pickUnit(diffFns, unit, "diff")(d, other)));
   functionOverload("Date.set(string, number): Date", (d, field, value) => {
     const date = d;
-    const val = toNum(value);
-    switch (field) {
-      case "day":
-        return wrapTZ(setDayOfMonth(date, val), date);
-      case "month":
-        return wrapTZ(setMonth(date, val - 1), date);
-      case "year":
-        return wrapTZ(setYear(date, val), date);
-      default:
-        throw evaluationError("invalid_field", `set(): unknown field "${field}"`);
-    }
+    return wrapTZ(pickUnit(setFns, field, "set")(date, toNum(value)), date);
   });
+  functionOverload("Date.get(string): number", (d, field) => Decimal.from(pickUnit(getFns, field, "get")(d)));
   functionOverload("Date.format(string): string", (d, fmt) => formatDate(d, fmt));
   registry.registerType("File", File);
   registry.registerType("URL", URL);

package/dist/runtime/vendor/cel-js/lib/macros.js

@@ -1,7 +1,7 @@
 import { Effect, Option } from "effect";
 import { evaluationError, parseError } from "./errors.js";
 import { OPERATORS as OPS } from "./operators.js";
-import { optionalOf } from "./optional.js";
+import { optionalOf, ensureOptional, bindOptionalValueType } from "./optional.js";
 const identity = (x) => x;
 function assertIdentifier(node, message) {
   if (node.op === "id") return node.args;
@@ -34,9 +34,10 @@ function createMapExpander(hasFilter) {
   }
   function functorMap(ev, macro, ctx, recv) {
     return Effect.gen(function* () {
-      if (Option.isNone(recv)) return Option.none();
+      const optional = ensureOptional(recv, macro.receiver, `${functionDesc} receiver`);
+      if (Option.isNone(optional)) return Option.none();
       const iterCtx = macro.iterCtx.reuse(ctx);
-      const result = yield* ev.eval(macro.body, iterCtx.setIterValue(recv.value, ev));
+      const result = yield* ev.eval(macro.body, iterCtx.setIterValue(optional.value, ev));
       return Option.some(result);
     });
   }
@@ -44,7 +45,7 @@ function createMapExpander(hasFilter) {
     const recvType = chk.check(macro.receiver, ctx);
     if (recvType.kind === "optional") {
       macro.mode = "optional";
-      const innerType = recvType.valueType ?? chk.getType("dyn");
+      const innerType = bindOptionalValueType(chk, recvType);
       macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, innerType);
       const bodyType = chk.check(macro.body, macro.iterCtx);
       return chk.registry.getOptionalType(bodyType);
@@ -83,10 +84,62 @@ function createMapExpander(hasFilter) {
     };
   };
 }
+function evaluateOptionalPredicate(ev, macro, ctx, optional, label) {
+  return Effect.gen(function* () {
+    const iterCtx = macro.iterCtx.reuse(ctx);
+    const result = yield* ev.eval(macro.body, iterCtx.setIterValue(optional.value, ev));
+    if (typeof result !== "boolean") {
+      throw evaluationError("invalid_condition_type", `${label}, got '${ev.debugRuntimeType(result)}'`, macro.body);
+    }
+    return result;
+  });
+}
+function checkOptionalPredicate(chk, macro, ctx, recvType, label) {
+  macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, bindOptionalValueType(chk, recvType));
+  const bodyType = chk.check(macro.body, macro.iterCtx);
+  if (!bodyType.isDynOrBool() && bodyType.kind !== "param") {
+    throw chk.createError("invalid_condition_type", `${label}, got '${bodyType}'`, macro.body);
+  }
+}
 function createFilterExpander() {
   const functionDesc = "filter(var, predicate)";
   const invalidMsg = `${functionDesc} invalid predicate iteration variable`;
   const label = `${functionDesc} predicate must return bool`;
+  const invalidReceiver = `${functionDesc} receiver`;
+  function typeCheck(chk, macro, ctx) {
+    const recvType = chk.check(macro.receiver, ctx);
+    if (recvType.kind === "optional") {
+      macro.mode = "optional";
+      checkOptionalPredicate(chk, macro, ctx, recvType, label);
+      return recvType;
+    }
+    if (recvType.kind === "dyn") {
+      macro.mode = "dyn";
+      macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, chk.getType("dyn"));
+      chk.check(macro.comprehension, ctx);
+      return chk.getType("dyn");
+    }
+    macro.mode = "list";
+    return chk.check(macro.comprehension, ctx);
+  }
+  function filterOptional(ev, macro, ctx, recv) {
+    return Effect.gen(function* () {
+      const optional = ensureOptional(recv, macro.receiver, invalidReceiver);
+      if (Option.isNone(optional)) return optional;
+      const keep = yield* evaluateOptionalPredicate(ev, macro, ctx, optional, label);
+      return keep ? optional : Option.none();
+    });
+  }
+  function evaluate(ev, macro, ctx) {
+    if (macro.mode === "list") return ev.eval(macro.comprehension, ctx);
+    if (macro.mode === "optional") {
+      return Effect.flatMap(ev.eval(macro.receiver, ctx), (recv) => filterOptional(ev, macro, ctx, recv));
+    }
+    return Effect.flatMap(
+      ev.eval(macro.receiver, ctx),
+      (recv) => Option.isOption(recv) ? filterOptional(ev, macro, ctx, recv) : ev.eval(macro.comprehension, ctx)
+    );
+  }
   return (opts) => {
     const { args, receiver, ast: callAst } = opts;
     const iterVarName = assertIdentifier(args[0], invalidMsg);
@@ -95,35 +148,89 @@ function createFilterExpander() {
     const appendItem = callAst.clone(OPS.accuPush, callAst.clone(OPS.id, iterVarName));
     const step = predicate.clone(OPS.ternary, [predicate, appendItem, accuValue]);
     return {
-      callAst: callAst.clone(OPS.comprehension, {
+      ast: callAst,
+      receiver,
+      iterVarName,
+      body: predicate,
+      comprehension: callAst.clone(OPS.comprehension, {
         errorsAreFatal: true,
         iterable: receiver,
         iterVarName,
         init: callAst.clone(OPS.list, []),
         step,
         result: identity
-      })
+      }),
+      iterCtx: void 0,
+      mode: "list",
+      typeCheck,
+      evaluate
     };
   };
 }
 function createQuantifierExpander(opts) {
   const invalidMsg = `${opts.name}(var, predicate) invalid predicate iteration variable`;
   const label = `${opts.name}(var, predicate) predicate must return bool`;
+  const invalidReceiver = `${opts.name}(var, predicate) receiver`;
+  const optionalBranch = opts.optional;
+  function typeCheck(chk, macro, ctx) {
+    const recvType = chk.check(macro.receiver, ctx);
+    if (recvType.kind === "optional") {
+      macro.mode = "optional";
+      checkOptionalPredicate(chk, macro, ctx, recvType, label);
+      return chk.getType("bool");
+    }
+    if (recvType.kind === "dyn") {
+      macro.mode = "dyn";
+      macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, chk.getType("dyn"));
+      chk.check(macro.comprehension, ctx);
+      return chk.getType("bool");
+    }
+    macro.mode = "list";
+    return chk.check(macro.comprehension, ctx);
+  }
+  function foldOptional(ev, macro, ctx, recv) {
+    return Effect.gen(function* () {
+      const optional = ensureOptional(recv, macro.receiver, invalidReceiver);
+      if (Option.isNone(optional)) return optionalBranch.onNone;
+      return yield* evaluateOptionalPredicate(ev, macro, ctx, optional, label);
+    });
+  }
+  function evaluate(ev, macro, ctx) {
+    if (macro.mode === "list") return ev.eval(macro.comprehension, ctx);
+    if (macro.mode === "optional") {
+      return Effect.flatMap(ev.eval(macro.receiver, ctx), (recv) => foldOptional(ev, macro, ctx, recv));
+    }
+    return Effect.flatMap(
+      ev.eval(macro.receiver, ctx),
+      (recv) => Option.isOption(recv) ? foldOptional(ev, macro, ctx, recv) : ev.eval(macro.comprehension, ctx)
+    );
+  }
   return (callOpts) => {
     const { args, receiver, ast: callAst } = callOpts;
+    const iterVarName = assertIdentifier(args[0], invalidMsg);
     const predicate = args[1].setMeta("label", label);
     const transform = opts.transform({ args, ast: callAst, predicate, opts });
+    const comprehension = callAst.clone(OPS.comprehension, {
+      kind: "quantifier",
+      errorsAreFatal: opts.errorsAreFatal || false,
+      iterable: receiver,
+      iterVarName,
+      init: transform.init,
+      condition: transform.condition,
+      step: transform.step,
+      result: transform.result || identity
+    });
+    if (!optionalBranch) return { callAst: comprehension };
     return {
-      callAst: callAst.clone(OPS.comprehension, {
-        kind: "quantifier",
-        errorsAreFatal: opts.errorsAreFatal || false,
-        iterable: receiver,
-        iterVarName: assertIdentifier(args[0], invalidMsg),
-        init: transform.init,
-        condition: transform.condition,
-        step: transform.step,
-        result: transform.result || identity
-      })
+      ast: callAst,
+      receiver,
+      iterVarName,
+      body: predicate,
+      comprehension,
+      iterCtx: void 0,
+      mode: "list",
+      typeCheck,
+      evaluate
     };
   };
 }
@@ -231,6 +338,7 @@ export function registerMacros(registry) {
     "list.all(ast, ast): bool",
     createQuantifierExpander({
       name: "all",
+      optional: { onNone: true },
       transform({ ast: callAst, predicate }) {
         return {
           init: callAst.clone(OPS.value, true),
@@ -248,6 +356,7 @@ export function registerMacros(registry) {
     "list.exists(ast, ast): bool",
     createQuantifierExpander({
       name: "exists",
+      optional: { onNone: false },
       condition(accu) {
         return !accu;
       },

package/dist/runtime/vendor/cel-js/lib/math-builtins.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from './registry.js.js';
+export declare function registerMathBuiltins(registry: Registry): void;

package/dist/runtime/vendor/cel-js/lib/math-builtins.js

@@ -0,0 +1,39 @@
+import { evaluationError } from "./errors.js";
+import { Decimal } from "./decimal.js";
+class MathNamespace {
+  brand = "math";
+}
+const MATH_INSTANCE = new MathNamespace();
+function toDecimal(v) {
+  return Decimal.from(v);
+}
+function extremum(name, values) {
+  if (values.length === 0) {
+    throw evaluationError("empty_list", `math.${name}(): an empty list has no ${name === "min" ? "minimum" : "maximum"}`);
+  }
+  let best = toDecimal(values[0]);
+  for (let i = 1; i < values.length; i++) {
+    const v = toDecimal(values[i]);
+    if (name === "min" ? v.lt(best) : v.gt(best)) best = v;
+  }
+  return best;
+}
+export function registerMathBuiltins(registry) {
+  registry.registerType("math", MathNamespace);
+  registry.registerVariable({
+    name: "math",
+    type: "math",
+    value: MATH_INSTANCE,
+    description: "\u6570\u5B66\u51FD\u6570"
+  });
+  const overload = (sig, handler) => registry.registerFunctionOverload(sig, handler);
+  overload("math.trunc(number): number", (_r, v) => toDecimal(v).trunc());
+  overload("math.floor(number): number", (_r, v) => toDecimal(v).floor());
+  overload("math.ceil(number): number", (_r, v) => toDecimal(v).ceil());
+  overload("math.round(number): number", (_r, v) => toDecimal(v).round());
+  overload("math.abs(number): number", (_r, v) => toDecimal(v).abs());
+  overload("math.min(number, number): number", (_r, a, b) => extremum("min", [a, b]));
+  overload("math.max(number, number): number", (_r, a, b) => extremum("max", [a, b]));
+  overload("math.min(list<number>): number", (_r, values) => extremum("min", values));
+  overload("math.max(list<number>): number", (_r, values) => extremum("max", values));
+}

package/dist/runtime/vendor/cel-js/lib/optional.d.ts

@@ -1,5 +1,9 @@
 import { Option } from 'effect';
+import type { IContextBase, ITypeCheckerBase, IASTNode, ITypeDeclaration } from './types.js.js';
 import type { Registry } from './registry.js.js';
 export declare function optionalOf(value: unknown): Option.None<{} | null> | Option.Some<{} | null>;
 export declare function optionalValue(opt: Option.Option<unknown>): unknown;
+export declare function ensureOptional(value: unknown, ast: IASTNode, description: string): Option.Option<unknown>;
+export declare function ensureOptionalType(checker: ITypeCheckerBase, node: IASTNode, ctx: IContextBase, description: string): ITypeDeclaration;
+export declare function bindOptionalValueType(checker: ITypeCheckerBase, type: ITypeDeclaration): ITypeDeclaration;
 export declare function register(registry: Registry): void;