@cydm/pie 1.0.4 → 1.0.6

package/dist/{builtin/extensions/questionnaire/index.js → chunks/chunk-RID3574D.js}

@@ -1,126 +1,74 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export
+} from "./chunk-TG2EQLX2.js";
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
-var value_exports = {};
-__export(value_exports, {
-  HasPropertyKey: () => HasPropertyKey,
-  IsArray: () => IsArray,
-  IsAsyncIterator: () => IsAsyncIterator,
-  IsBigInt: () => IsBigInt,
-  IsBoolean: () => IsBoolean,
-  IsDate: () => IsDate,
-  IsFunction: () => IsFunction,
-  IsIterator: () => IsIterator,
-  IsNull: () => IsNull,
-  IsNumber: () => IsNumber,
-  IsObject: () => IsObject,
-  IsRegExp: () => IsRegExp,
-  IsString: () => IsString,
-  IsSymbol: () => IsSymbol,
-  IsUint8Array: () => IsUint8Array,
-  IsUndefined: () => IsUndefined
-});
-function HasPropertyKey(value, key) {
-  return key in value;
-}
+// ../../node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
 function IsAsyncIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
-}
-function IsArray(value) {
-  return Array.isArray(value);
-}
-function IsBigInt(value) {
-  return typeof value === "bigint";
-}
-function IsBoolean(value) {
-  return typeof value === "boolean";
-}
-function IsDate(value) {
-  return value instanceof globalThis.Date;
-}
-function IsFunction(value) {
-  return typeof value === "function";
+  return IsObject(value) && globalThis.Symbol.asyncIterator in value;
 }
 function IsIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+  return IsObject(value) && globalThis.Symbol.iterator in value;
 }
-function IsNull(value) {
-  return value === null;
+function IsStandardObject(value) {
+  return IsObject(value) && (globalThis.Object.getPrototypeOf(value) === Object.prototype || globalThis.Object.getPrototypeOf(value) === null);
 }
-function IsNumber(value) {
-  return typeof value === "number";
+function IsPromise(value) {
+  return value instanceof globalThis.Promise;
 }
-function IsObject(value) {
-  return typeof value === "object" && value !== null;
+function IsDate(value) {
+  return value instanceof Date && globalThis.Number.isFinite(value.getTime());
 }
-function IsRegExp(value) {
-  return value instanceof globalThis.RegExp;
+function IsMap(value) {
+  return value instanceof globalThis.Map;
 }
-function IsString(value) {
-  return typeof value === "string";
+function IsSet(value) {
+  return value instanceof globalThis.Set;
 }
-function IsSymbol(value) {
-  return typeof value === "symbol";
+function IsTypedArray(value) {
+  return globalThis.ArrayBuffer.isView(value);
 }
 function IsUint8Array(value) {
   return value instanceof globalThis.Uint8Array;
 }
-function IsUndefined(value) {
-  return value === void 0;
+function HasPropertyKey(value, key) {
+  return key in value;
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
-function ArrayType(value) {
-  return value.map((value2) => Visit(value2));
+function IsObject(value) {
+  return value !== null && typeof value === "object";
 }
-function DateType(value) {
-  return new Date(value.getTime());
+function IsArray(value) {
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
 }
-function Uint8ArrayType(value) {
-  return new Uint8Array(value);
+function IsUndefined(value) {
+  return value === void 0;
 }
-function RegExpType(value) {
-  return new RegExp(value.source, value.flags);
+function IsNull(value) {
+  return value === null;
 }
-function ObjectType(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Visit(value[key]);
-  }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Visit(value[key]);
-  }
-  return result;
+function IsBoolean(value) {
+  return typeof value === "boolean";
 }
-function Visit(value) {
-  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
+function IsNumber(value) {
+  return typeof value === "number";
 }
-function Clone(value) {
-  return Visit(value);
+function IsInteger(value) {
+  return globalThis.Number.isInteger(value);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
-function CloneType(schema, options) {
-  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
+function IsBigInt(value) {
+  return typeof value === "bigint";
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
-function IsObject2(value) {
-  return value !== null && typeof value === "object";
+function IsString(value) {
+  return typeof value === "string";
 }
-function IsArray2(value) {
-  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+function IsFunction(value) {
+  return typeof value === "function";
 }
-function IsUndefined2(value) {
-  return value === void 0;
+function IsSymbol(value) {
+  return typeof value === "symbol";
 }
-function IsNumber2(value) {
-  return typeof value === "number";
+function IsValueType(value) {
+  return IsBigInt(value) || IsBoolean(value) || IsNull(value) || IsNumber(value) || IsString(value) || IsSymbol(value) || IsUndefined(value);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/system/policy.mjs
@@ -136,8 +84,8 @@ var TypeSystemPolicy;
   }
   TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
   function IsObjectLike(value) {
-    const isObject = IsObject2(value);
-    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
+    const isObject = IsObject(value);
+    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray(value);
   }
   TypeSystemPolicy2.IsObjectLike = IsObjectLike;
   function IsRecordLike(value) {
@@ -145,16 +93,85 @@ var TypeSystemPolicy;
   }
   TypeSystemPolicy2.IsRecordLike = IsRecordLike;
   function IsNumberLike(value) {
-    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
+    return TypeSystemPolicy2.AllowNaN ? IsNumber(value) : Number.isFinite(value);
   }
   TypeSystemPolicy2.IsNumberLike = IsNumberLike;
   function IsVoidLike(value) {
-    const isUndefined = IsUndefined2(value);
+    const isUndefined = IsUndefined(value);
     return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
   }
   TypeSystemPolicy2.IsVoidLike = IsVoidLike;
 })(TypeSystemPolicy || (TypeSystemPolicy = {}));
 
+// ../../node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+var value_exports = {};
+__export(value_exports, {
+  HasPropertyKey: () => HasPropertyKey2,
+  IsArray: () => IsArray2,
+  IsAsyncIterator: () => IsAsyncIterator2,
+  IsBigInt: () => IsBigInt2,
+  IsBoolean: () => IsBoolean2,
+  IsDate: () => IsDate2,
+  IsFunction: () => IsFunction2,
+  IsIterator: () => IsIterator2,
+  IsNull: () => IsNull2,
+  IsNumber: () => IsNumber2,
+  IsObject: () => IsObject2,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString2,
+  IsSymbol: () => IsSymbol2,
+  IsUint8Array: () => IsUint8Array2,
+  IsUndefined: () => IsUndefined2
+});
+function HasPropertyKey2(value, key) {
+  return key in value;
+}
+function IsAsyncIterator2(value) {
+  return IsObject2(value) && !IsArray2(value) && !IsUint8Array2(value) && Symbol.asyncIterator in value;
+}
+function IsArray2(value) {
+  return Array.isArray(value);
+}
+function IsBigInt2(value) {
+  return typeof value === "bigint";
+}
+function IsBoolean2(value) {
+  return typeof value === "boolean";
+}
+function IsDate2(value) {
+  return value instanceof globalThis.Date;
+}
+function IsFunction2(value) {
+  return typeof value === "function";
+}
+function IsIterator2(value) {
+  return IsObject2(value) && !IsArray2(value) && !IsUint8Array2(value) && Symbol.iterator in value;
+}
+function IsNull2(value) {
+  return value === null;
+}
+function IsNumber2(value) {
+  return typeof value === "number";
+}
+function IsObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString2(value) {
+  return typeof value === "string";
+}
+function IsSymbol2(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array2(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined2(value) {
+  return value === void 0;
+}
+
 // ../../node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
 function ImmutableArray(value) {
   return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
@@ -179,7 +196,37 @@ function ImmutableObject(value) {
   return globalThis.Object.freeze(result);
 }
 function Immutable(value) {
-  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
+  return IsArray2(value) ? ImmutableArray(value) : IsDate2(value) ? ImmutableDate(value) : IsUint8Array2(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject2(value) ? ImmutableObject(value) : value;
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+  return value.map((value2) => Visit(value2));
+}
+function DateType(value) {
+  return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+  return new Uint8Array(value);
+}
+function RegExpType(value) {
+  return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key]);
+  }
+  return result;
+}
+function Visit(value) {
+  return IsArray2(value) ? ArrayType(value) : IsDate2(value) ? DateType(value) : IsUint8Array2(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject2(value) ? ObjectType(value) : value;
+}
+function Clone(value) {
+  return Visit(value);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
@@ -195,6 +242,65 @@ function CreateType(schema, options) {
   }
 }
 
+// ../../node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = Symbol.for("TypeBox.Transform");
+var ReadonlyKind = Symbol.for("TypeBox.Readonly");
+var OptionalKind = Symbol.for("TypeBox.Optional");
+var Hint = Symbol.for("TypeBox.Hint");
+var Kind = Symbol.for("TypeBox.Kind");
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
+function Any(options) {
+  return CreateType({ [Kind]: "Any" }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
+function Array2(items, options) {
+  return CreateType({ [Kind]: "Array", type: "array", items }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
+function Boolean(options) {
+  return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
+function DiscardKey(value, key) {
+  const { [key]: _, ...rest } = value;
+  return rest;
+}
+function Discard(value, keys) {
+  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
+function Never(options) {
+  return CreateType({ [Kind]: "Never", not: {} }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
+function MappedResult(properties) {
+  return CreateType({
+    [Kind]: "MappedResult",
+    properties
+  });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
+function AsyncIterator(items, options) {
+  return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
+function Constructor(parameters, returns, options) {
+  return CreateType({ [Kind]: "Constructor", type: "Constructor", parameters, returns }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
+function Function(parameters, returns, options) {
+  return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
+}
+
 // ../../node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
 var TypeBoxError = class extends Error {
   constructor(message) {
@@ -202,19 +308,22 @@ var TypeBoxError = class extends Error {
   }
 };
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var TransformKind = Symbol.for("TypeBox.Transform");
-var ReadonlyKind = Symbol.for("TypeBox.Readonly");
-var OptionalKind = Symbol.for("TypeBox.Optional");
-var Hint = Symbol.for("TypeBox.Hint");
-var Kind = Symbol.for("TypeBox.Kind");
+// ../../node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
+function Computed(target, parameters, options) {
+  return CreateType({ [Kind]: "Computed", target, parameters }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
+function UnionCreate(T, options) {
+  return CreateType({ [Kind]: "Union", anyOf: T }, options);
+}
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
 function IsReadonly(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+  return IsObject2(value) && value[ReadonlyKind] === "Readonly";
 }
 function IsOptional(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
+  return IsObject2(value) && value[OptionalKind] === "Optional";
 }
 function IsAny(value) {
   return IsKindOf(value, "Any");
@@ -225,13 +334,13 @@ function IsArgument(value) {
 function IsArray3(value) {
   return IsKindOf(value, "Array");
 }
-function IsAsyncIterator2(value) {
+function IsAsyncIterator3(value) {
   return IsKindOf(value, "AsyncIterator");
 }
-function IsBigInt2(value) {
+function IsBigInt3(value) {
   return IsKindOf(value, "BigInt");
 }
-function IsBoolean2(value) {
+function IsBoolean3(value) {
   return IsKindOf(value, "Boolean");
 }
 function IsComputed(value) {
@@ -240,26 +349,26 @@ function IsComputed(value) {
 function IsConstructor(value) {
   return IsKindOf(value, "Constructor");
 }
-function IsDate2(value) {
+function IsDate3(value) {
   return IsKindOf(value, "Date");
 }
-function IsFunction2(value) {
+function IsFunction3(value) {
   return IsKindOf(value, "Function");
 }
-function IsInteger(value) {
+function IsInteger2(value) {
   return IsKindOf(value, "Integer");
 }
 function IsIntersect(value) {
   return IsKindOf(value, "Intersect");
 }
-function IsIterator2(value) {
+function IsIterator3(value) {
   return IsKindOf(value, "Iterator");
 }
 function IsKindOf(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
+  return IsObject2(value) && Kind in value && value[Kind] === kind;
 }
 function IsLiteralValue(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
+  return IsBoolean2(value) || IsNumber2(value) || IsString2(value);
 }
 function IsLiteral(value) {
   return IsKindOf(value, "Literal");
@@ -276,7 +385,7 @@ function IsNever(value) {
 function IsNot(value) {
   return IsKindOf(value, "Not");
 }
-function IsNull2(value) {
+function IsNull3(value) {
   return IsKindOf(value, "Null");
 }
 function IsNumber3(value) {
@@ -285,7 +394,7 @@ function IsNumber3(value) {
 function IsObject3(value) {
   return IsKindOf(value, "Object");
 }
-function IsPromise(value) {
+function IsPromise2(value) {
   return IsKindOf(value, "Promise");
 }
 function IsRecord(value) {
@@ -297,10 +406,10 @@ function IsRef(value) {
 function IsRegExp2(value) {
   return IsKindOf(value, "RegExp");
 }
-function IsString2(value) {
+function IsString3(value) {
   return IsKindOf(value, "String");
 }
-function IsSymbol2(value) {
+function IsSymbol3(value) {
   return IsKindOf(value, "Symbol");
 }
 function IsTemplateLiteral(value) {
@@ -310,7 +419,7 @@ function IsThis(value) {
   return IsKindOf(value, "This");
 }
 function IsTransform(value) {
-  return IsObject(value) && TransformKind in value;
+  return IsObject2(value) && TransformKind in value;
 }
 function IsTuple(value) {
   return IsKindOf(value, "Tuple");
@@ -321,7 +430,7 @@ function IsUndefined3(value) {
 function IsUnion(value) {
   return IsKindOf(value, "Union");
 }
-function IsUint8Array2(value) {
+function IsUint8Array3(value) {
   return IsKindOf(value, "Uint8Array");
 }
 function IsUnknown(value) {
@@ -334,302 +443,272 @@ function IsVoid(value) {
   return IsKindOf(value, "Void");
 }
 function IsKind(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]);
+  return IsObject2(value) && Kind in value && IsString2(value[Kind]);
 }
 function IsSchema(value) {
-  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed(value) || IsConstructor(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect(value) || IsIterator3(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull3(value) || IsNumber3(value) || IsObject3(value) || IsPromise2(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array3(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
-var type_exports = {};
-__export(type_exports, {
-  IsAny: () => IsAny2,
-  IsArgument: () => IsArgument2,
-  IsArray: () => IsArray4,
-  IsAsyncIterator: () => IsAsyncIterator3,
-  IsBigInt: () => IsBigInt3,
-  IsBoolean: () => IsBoolean3,
-  IsComputed: () => IsComputed2,
-  IsConstructor: () => IsConstructor2,
-  IsDate: () => IsDate3,
-  IsFunction: () => IsFunction3,
-  IsImport: () => IsImport,
-  IsInteger: () => IsInteger2,
-  IsIntersect: () => IsIntersect2,
-  IsIterator: () => IsIterator3,
-  IsKind: () => IsKind2,
-  IsKindOf: () => IsKindOf2,
-  IsLiteral: () => IsLiteral2,
-  IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteralNumber: () => IsLiteralNumber,
-  IsLiteralString: () => IsLiteralString,
-  IsLiteralValue: () => IsLiteralValue2,
-  IsMappedKey: () => IsMappedKey2,
-  IsMappedResult: () => IsMappedResult2,
-  IsNever: () => IsNever2,
-  IsNot: () => IsNot2,
-  IsNull: () => IsNull3,
-  IsNumber: () => IsNumber4,
-  IsObject: () => IsObject4,
-  IsOptional: () => IsOptional2,
-  IsPromise: () => IsPromise2,
-  IsProperties: () => IsProperties,
-  IsReadonly: () => IsReadonly2,
-  IsRecord: () => IsRecord2,
-  IsRecursive: () => IsRecursive,
-  IsRef: () => IsRef2,
-  IsRegExp: () => IsRegExp3,
-  IsSchema: () => IsSchema2,
-  IsString: () => IsString3,
-  IsSymbol: () => IsSymbol3,
-  IsTemplateLiteral: () => IsTemplateLiteral2,
-  IsThis: () => IsThis2,
-  IsTransform: () => IsTransform2,
-  IsTuple: () => IsTuple2,
-  IsUint8Array: () => IsUint8Array3,
-  IsUndefined: () => IsUndefined4,
-  IsUnion: () => IsUnion2,
-  IsUnionLiteral: () => IsUnionLiteral,
-  IsUnknown: () => IsUnknown2,
-  IsUnsafe: () => IsUnsafe2,
-  IsVoid: () => IsVoid2,
-  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
-});
-var TypeGuardUnknownTypeError = class extends TypeBoxError {
-};
-var KnownTypes = [
-  "Argument",
-  "Any",
-  "Array",
-  "AsyncIterator",
-  "BigInt",
-  "Boolean",
-  "Computed",
-  "Constructor",
-  "Date",
-  "Enum",
-  "Function",
-  "Integer",
-  "Intersect",
-  "Iterator",
-  "Literal",
-  "MappedKey",
-  "MappedResult",
-  "Not",
-  "Null",
-  "Number",
-  "Object",
-  "Promise",
-  "Record",
-  "Ref",
-  "RegExp",
-  "String",
-  "Symbol",
-  "TemplateLiteral",
-  "This",
-  "Tuple",
-  "Undefined",
-  "Union",
-  "Uint8Array",
-  "Unknown",
-  "Void"
-];
-function IsPattern(value) {
-  try {
-    new RegExp(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function IsControlCharacterFree(value) {
-  if (!IsString(value))
-    return false;
-  for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
-    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
-      return false;
-    }
-  }
-  return true;
-}
-function IsAdditionalProperties(value) {
-  return IsOptionalBoolean(value) || IsSchema2(value);
-}
-function IsOptionalBigInt(value) {
-  return IsUndefined(value) || IsBigInt(value);
-}
-function IsOptionalNumber(value) {
-  return IsUndefined(value) || IsNumber(value);
-}
-function IsOptionalBoolean(value) {
-  return IsUndefined(value) || IsBoolean(value);
-}
-function IsOptionalString(value) {
-  return IsUndefined(value) || IsString(value);
-}
-function IsOptionalPattern(value) {
-  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
-}
-function IsOptionalFormat(value) {
-  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
-}
-function IsOptionalSchema(value) {
-  return IsUndefined(value) || IsSchema2(value);
-}
-function IsReadonly2(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
-}
-function IsOptional2(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
-}
-function IsAny2(value) {
-  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
-}
-function IsArgument2(value) {
-  return IsKindOf2(value, "Argument") && IsNumber(value.index);
-}
-function IsArray4(value) {
-  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+// ../../node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
+function IsUnionOptional(types) {
+  return types.some((type) => IsOptional(type));
 }
-function IsAsyncIterator3(value) {
-  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+function RemoveOptionalFromRest(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
 }
-function IsBigInt3(value) {
-  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+function RemoveOptionalFromType(T) {
+  return Discard(T, [OptionalKind]);
 }
-function IsBoolean3(value) {
-  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+function ResolveUnion(types, options) {
+  const isOptional = IsUnionOptional(types);
+  return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
 }
-function IsComputed2(value) {
-  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
+function UnionEvaluated(T, options) {
+  return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
 }
-function IsConstructor2(value) {
-  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
+function Union(types, options) {
+  return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
 }
-function IsDate3(value) {
-  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
+var TemplateLiteralParserError = class extends TypeBoxError {
+};
+function Unescape(pattern) {
+  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
 }
-function IsFunction3(value) {
-  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+function IsNonEscaped(pattern, index, char) {
+  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
 }
-function IsImport(value) {
-  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+function IsOpenParen(pattern, index) {
+  return IsNonEscaped(pattern, index, "(");
 }
-function IsInteger2(value) {
-  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function IsCloseParen(pattern, index) {
+  return IsNonEscaped(pattern, index, ")");
 }
-function IsProperties(value) {
-  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+function IsSeparator(pattern, index) {
+  return IsNonEscaped(pattern, index, "|");
 }
-function IsIntersect2(value) {
-  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+function IsGroup(pattern) {
+  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+    return false;
+  let count = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (count === 0 && index !== pattern.length - 1)
+      return false;
+  }
+  return true;
 }
-function IsIterator3(value) {
-  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+function InGroup(pattern) {
+  return pattern.slice(1, pattern.length - 1);
 }
-function IsKindOf2(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
+function IsPrecedenceOr(pattern) {
+  let count = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0)
+      return true;
+  }
+  return false;
 }
-function IsLiteralString(value) {
-  return IsLiteral2(value) && IsString(value.const);
+function IsPrecedenceAnd(pattern) {
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      return true;
+  }
+  return false;
 }
-function IsLiteralNumber(value) {
-  return IsLiteral2(value) && IsNumber(value.const);
+function Or(pattern) {
+  let [count, start] = [0, 0];
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0) {
+      const range2 = pattern.slice(start, index);
+      if (range2.length > 0)
+        expressions.push(TemplateLiteralParse(range2));
+      start = index + 1;
+    }
+  }
+  const range = pattern.slice(start);
+  if (range.length > 0)
+    expressions.push(TemplateLiteralParse(range));
+  if (expressions.length === 0)
+    return { type: "const", const: "" };
+  if (expressions.length === 1)
+    return expressions[0];
+  return { type: "or", expr: expressions };
 }
-function IsLiteralBoolean(value) {
-  return IsLiteral2(value) && IsBoolean(value.const);
-}
-function IsLiteral2(value) {
-  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
-}
-function IsLiteralValue2(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
-}
-function IsMappedKey2(value) {
-  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
-}
-function IsMappedResult2(value) {
-  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
-}
-function IsNever2(value) {
-  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
-}
-function IsNot2(value) {
-  return IsKindOf2(value, "Not") && IsSchema2(value.not);
-}
-function IsNull3(value) {
-  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
-}
-function IsNumber4(value) {
-  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function And(pattern) {
+  function Group(value, index) {
+    if (!IsOpenParen(value, index))
+      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+    let count = 0;
+    for (let scan = index; scan < value.length; scan++) {
+      if (IsOpenParen(value, scan))
+        count += 1;
+      if (IsCloseParen(value, scan))
+        count -= 1;
+      if (count === 0)
+        return [index, scan];
+    }
+    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+  }
+  function Range(pattern2, index) {
+    for (let scan = index; scan < pattern2.length; scan++) {
+      if (IsOpenParen(pattern2, scan))
+        return [index, scan];
+    }
+    return [index, pattern2.length];
+  }
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) {
+      const [start, end] = Group(pattern, index);
+      const range = pattern.slice(start, end + 1);
+      expressions.push(TemplateLiteralParse(range));
+      index = end;
+    } else {
+      const [start, end] = Range(pattern, index);
+      const range = pattern.slice(start, end);
+      if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+      index = end - 1;
+    }
+  }
+  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
 }
-function IsObject4(value) {
-  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+function TemplateLiteralParse(pattern) {
+  return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
 }
-function IsPromise2(value) {
-  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+function TemplateLiteralParseExact(pattern) {
+  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }
-function IsRecord2(value) {
-  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
-    const keys = Object.getOwnPropertyNames(schema.patternProperties);
-    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
-  })(value);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
+var TemplateLiteralFiniteError = class extends TypeBoxError {
+};
+function IsNumberExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
 }
-function IsRecursive(value) {
-  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
+function IsBooleanExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
 }
-function IsRef2(value) {
-  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsStringExpression(expression) {
+  return expression.type === "const" && expression.const === ".*";
 }
-function IsRegExp3(value) {
-  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+function IsTemplateLiteralExpressionFinite(expression) {
+  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
+    throw new TemplateLiteralFiniteError(`Unknown expression type`);
+  })();
 }
-function IsString3(value) {
-  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+function IsTemplateLiteralFinite(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression);
 }
-function IsSymbol3(value) {
-  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
+var TemplateLiteralGenerateError = class extends TypeBoxError {
+};
+function* GenerateReduce(buffer) {
+  if (buffer.length === 1)
+    return yield* buffer[0];
+  for (const left of buffer[0]) {
+    for (const right of GenerateReduce(buffer.slice(1))) {
+      yield `${left}${right}`;
+    }
+  }
 }
-function IsTemplateLiteral2(value) {
-  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+function* GenerateAnd(expression) {
+  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
 }
-function IsThis2(value) {
-  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+function* GenerateOr(expression) {
+  for (const expr of expression.expr)
+    yield* TemplateLiteralExpressionGenerate(expr);
 }
-function IsTransform2(value) {
-  return IsObject(value) && TransformKind in value;
+function* GenerateConst(expression) {
+  return yield expression.const;
 }
-function IsTuple2(value) {
-  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && // empty
-  (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
+function* TemplateLiteralExpressionGenerate(expression) {
+  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
+    throw new TemplateLiteralGenerateError("Unknown expression");
+  })();
 }
-function IsUndefined4(value) {
-  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+function TemplateLiteralGenerate(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
 }
-function IsUnionLiteral(value) {
-  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
+function Literal(value, options) {
+  return CreateType({
+    [Kind]: "Literal",
+    const: value,
+    type: typeof value
+  }, options);
 }
-function IsUnion2(value) {
-  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
+function BigInt(options) {
+  return CreateType({ [Kind]: "BigInt", type: "bigint" }, options);
 }
-function IsUint8Array3(value) {
-  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
+function Number2(options) {
+  return CreateType({ [Kind]: "Number", type: "number" }, options);
 }
-function IsUnknown2(value) {
-  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
+function String(options) {
+  return CreateType({ [Kind]: "String", type: "string" }, options);
 }
-function IsUnsafe2(value) {
-  return IsKindOf2(value, "Unsafe");
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
+function* FromUnion(syntax) {
+  const trim = syntax.trim().replace(/"|'/g, "");
+  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String() : yield (() => {
+    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
+  })();
 }
-function IsVoid2(value) {
-  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+function* FromTerminal(syntax) {
+  if (syntax[1] !== "{") {
+    const L = Literal("$");
+    const R = FromSyntax(syntax.slice(1));
+    return yield* [L, ...R];
+  }
+  for (let i = 2; i < syntax.length; i++) {
+    if (syntax[i] === "}") {
+      const L = FromUnion(syntax.slice(2, i));
+      const R = FromSyntax(syntax.slice(i + 1));
+      return yield* [...L, ...R];
+    }
+  }
+  yield Literal(syntax);
 }
-function IsKind2(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+function* FromSyntax(syntax) {
+  for (let i = 0; i < syntax.length; i++) {
+    if (syntax[i] === "$") {
+      const L = Literal(syntax.slice(0, i));
+      const R = FromTerminal(syntax.slice(i));
+      return yield* [L, ...R];
+    }
+  }
+  yield Literal(syntax);
 }
-function IsSchema2(value) {
-  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+function TemplateLiteralSyntax(syntax) {
+  return [...FromSyntax(syntax)];
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
@@ -642,867 +721,809 @@ var PatternNumberExact = `^${PatternNumber}$`;
 var PatternStringExact = `^${PatternString}$`;
 var PatternNeverExact = `^${PatternNever}$`;
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
-function SetIncludes(T, S) {
-  return T.includes(S);
-}
-function SetDistinct(T) {
-  return [...new Set(T)];
-}
-function SetIntersect(T, S) {
-  return T.filter((L) => S.includes(L));
-}
-function SetIntersectManyResolve(T, Init) {
-  return T.reduce((Acc, L) => {
-    return SetIntersect(Acc, L);
-  }, Init);
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
+var TemplateLiteralPatternError = class extends TypeBoxError {
+};
+function Escape(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function SetIntersectMany(T) {
-  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+function Visit2(schema, acc) {
+  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber3(schema) ? `${acc}${PatternNumber}` : IsInteger2(schema) ? `${acc}${PatternNumber}` : IsBigInt3(schema) ? `${acc}${PatternNumber}` : IsString3(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean3(schema) ? `${acc}${PatternBoolean}` : (() => {
+    throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
+  })();
 }
-function SetUnionMany(T) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...L);
-  return Acc;
+function TemplateLiteralPattern(kinds) {
+  return `^${kinds.map((schema) => Visit2(schema, "")).join("")}$`;
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
-function Any(options) {
-  return CreateType({ [Kind]: "Any" }, options);
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
+function TemplateLiteralToUnion(schema) {
+  const R = TemplateLiteralGenerate(schema);
+  const L = R.map((S) => Literal(S));
+  return UnionEvaluated(L);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
-function Array2(items, options) {
-  return CreateType({ [Kind]: "Array", type: "array", items }, options);
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
+function TemplateLiteral(unresolved, options) {
+  const pattern = IsString2(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
+  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
-function Argument(index) {
-  return CreateType({ [Kind]: "Argument", index });
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
+function FromTemplateLiteral(templateLiteral) {
+  const keys = TemplateLiteralGenerate(templateLiteral);
+  return keys.map((key) => key.toString());
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
-function AsyncIterator(items, options) {
-  return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
+function FromUnion2(types) {
+  const result = [];
+  for (const type of types)
+    result.push(...IndexPropertyKeys(type));
+  return result;
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
-function Computed(target, parameters, options) {
-  return CreateType({ [Kind]: "Computed", target, parameters }, options);
+function FromLiteral(literalValue) {
+  return [literalValue.toString()];
+}
+function IndexPropertyKeys(type) {
+  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger2(type) ? ["[number]"] : [])];
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
-function DiscardKey(value, key) {
-  const { [key]: _, ...rest } = value;
-  return rest;
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
+function FromProperties(type, properties, options) {
+  const result = {};
+  for (const K2 of Object.getOwnPropertyNames(properties)) {
+    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+  }
+  return result;
 }
-function Discard(value, keys) {
-  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+function FromMappedResult(type, mappedResult, options) {
+  return FromProperties(type, mappedResult.properties, options);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
-function Never(options) {
-  return CreateType({ [Kind]: "Never", not: {} }, options);
+function IndexFromMappedResult(type, mappedResult, options) {
+  const properties = FromMappedResult(type, mappedResult, options);
+  return MappedResult(properties);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
-function MappedResult(properties) {
-  return CreateType({
-    [Kind]: "MappedResult",
-    properties
-  });
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
+function FromRest(types, key) {
+  return types.map((type) => IndexFromPropertyKey(type, key));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
-function Constructor(parameters, returns, options) {
-  return CreateType({ [Kind]: "Constructor", type: "Constructor", parameters, returns }, options);
+function FromIntersectRest(types) {
+  return types.filter((type) => !IsNever(type));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
-function Function(parameters, returns, options) {
-  return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
+function FromIntersect(types, key) {
+  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
-function UnionCreate(T, options) {
-  return CreateType({ [Kind]: "Union", anyOf: T }, options);
+function FromUnionRest(types) {
+  return types.some((L) => IsNever(L)) ? [] : types;
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
-function IsUnionOptional(types) {
-  return types.some((type) => IsOptional(type));
+function FromUnion3(types, key) {
+  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
 }
-function RemoveOptionalFromRest(types) {
-  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+function FromTuple(types, key) {
+  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
 }
-function RemoveOptionalFromType(T) {
-  return Discard(T, [OptionalKind]);
+function FromArray(type, key) {
+  return key === "[number]" ? type : Never();
 }
-function ResolveUnion(types, options) {
-  const isOptional = IsUnionOptional(types);
-  return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
+function FromProperty(properties, propertyKey) {
+  return propertyKey in properties ? properties[propertyKey] : Never();
 }
-function UnionEvaluated(T, options) {
-  return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
+function IndexFromPropertyKey(type, propertyKey) {
+  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray3(type) ? FromArray(type.items, propertyKey) : IsObject3(type) ? FromProperty(type.properties, propertyKey) : Never();
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
-function Union(types, options) {
-  return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
+function IndexFromPropertyKeys(type, propertyKeys) {
+  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+}
+function FromSchema(type, propertyKeys) {
+  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+}
+function Index(type, key, options) {
+  if (IsRef(type) || IsRef(key)) {
+    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+    if (!IsSchema(type) || !IsSchema(key))
+      throw new TypeBoxError(error);
+    return Computed("Index", [type, key]);
+  }
+  if (IsMappedResult(key))
+    return IndexFromMappedResult(type, key, options);
+  if (IsMappedKey(key))
+    return IndexFromMappedKey(type, key, options);
+  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
-var TemplateLiteralParserError = class extends TypeBoxError {
-};
-function Unescape(pattern) {
-  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
+function MappedIndexPropertyKey(type, key, options) {
+  return { [key]: Index(type, [key], Clone(options)) };
 }
-function IsNonEscaped(pattern, index, char) {
-  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+  }, {});
 }
-function IsOpenParen(pattern, index) {
-  return IsNonEscaped(pattern, index, "(");
+function MappedIndexProperties(type, mappedKey, options) {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
 }
-function IsCloseParen(pattern, index) {
-  return IsNonEscaped(pattern, index, ")");
+function IndexFromMappedKey(type, mappedKey, options) {
+  const properties = MappedIndexProperties(type, mappedKey, options);
+  return MappedResult(properties);
 }
-function IsSeparator(pattern, index) {
-  return IsNonEscaped(pattern, index, "|");
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
+function Iterator(items, options) {
+  return CreateType({ [Kind]: "Iterator", type: "Iterator", items }, options);
 }
-function IsGroup(pattern) {
-  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
-    return false;
-  let count = 0;
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      count += 1;
-    if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (count === 0 && index !== pattern.length - 1)
-      return false;
-  }
-  return true;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
+function RequiredArray(properties) {
+  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
 }
-function InGroup(pattern) {
-  return pattern.slice(1, pattern.length - 1);
+function _Object(properties, options) {
+  const required = RequiredArray(properties);
+  const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
+  return CreateType(schema, options);
 }
-function IsPrecedenceOr(pattern) {
-  let count = 0;
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      count += 1;
-    if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (IsSeparator(pattern, index) && count === 0)
-      return true;
-  }
-  return false;
+var Object2 = _Object;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
+function Promise2(item, options) {
+  return CreateType({ [Kind]: "Promise", type: "Promise", item }, options);
 }
-function IsPrecedenceAnd(pattern) {
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      return true;
-  }
-  return false;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
+function RemoveReadonly(schema) {
+  return CreateType(Discard(schema, [ReadonlyKind]));
 }
-function Or(pattern) {
-  let [count, start] = [0, 0];
-  const expressions = [];
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      count += 1;
-    if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (IsSeparator(pattern, index) && count === 0) {
-      const range2 = pattern.slice(start, index);
-      if (range2.length > 0)
-        expressions.push(TemplateLiteralParse(range2));
-      start = index + 1;
-    }
-  }
-  const range = pattern.slice(start);
-  if (range.length > 0)
-    expressions.push(TemplateLiteralParse(range));
-  if (expressions.length === 0)
-    return { type: "const", const: "" };
-  if (expressions.length === 1)
-    return expressions[0];
-  return { type: "or", expr: expressions };
+function AddReadonly(schema) {
+  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
 }
-function And(pattern) {
-  function Group(value, index) {
-    if (!IsOpenParen(value, index))
-      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
-    let count = 0;
-    for (let scan = index; scan < value.length; scan++) {
-      if (IsOpenParen(value, scan))
-        count += 1;
-      if (IsCloseParen(value, scan))
-        count -= 1;
-      if (count === 0)
-        return [index, scan];
-    }
-    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
-  }
-  function Range(pattern2, index) {
-    for (let scan = index; scan < pattern2.length; scan++) {
-      if (IsOpenParen(pattern2, scan))
-        return [index, scan];
-    }
-    return [index, pattern2.length];
-  }
-  const expressions = [];
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index)) {
-      const [start, end] = Group(pattern, index);
-      const range = pattern.slice(start, end + 1);
-      expressions.push(TemplateLiteralParse(range));
-      index = end;
-    } else {
-      const [start, end] = Range(pattern, index);
-      const range = pattern.slice(start, end);
-      if (range.length > 0)
-        expressions.push(TemplateLiteralParse(range));
-      index = end - 1;
-    }
-  }
-  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+function ReadonlyWithFlag(schema, F) {
+  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
 }
-function TemplateLiteralParse(pattern) {
-  return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
+function Readonly(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
 }
-function TemplateLiteralParseExact(pattern) {
-  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
+function FromProperties2(K, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Readonly(K[K2], F);
+  return Acc;
+}
+function FromMappedResult2(R, F) {
+  return FromProperties2(R.properties, F);
+}
+function ReadonlyFromMappedResult(R, F) {
+  const P = FromMappedResult2(R, F);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
+function Tuple(types, options) {
+  return CreateType(types.length > 0 ? { [Kind]: "Tuple", type: "array", items: types, additionalItems: false, minItems: types.length, maxItems: types.length } : { [Kind]: "Tuple", type: "array", minItems: types.length, maxItems: types.length }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
-var TemplateLiteralFiniteError = class extends TypeBoxError {
-};
-function IsNumberExpression(expression) {
-  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+// ../../node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
+function SetIncludes(T, S) {
+  return T.includes(S);
 }
-function IsBooleanExpression(expression) {
-  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+function SetDistinct(T) {
+  return [...new Set(T)];
 }
-function IsStringExpression(expression) {
-  return expression.type === "const" && expression.const === ".*";
+function SetIntersect(T, S) {
+  return T.filter((L) => S.includes(L));
 }
-function IsTemplateLiteralExpressionFinite(expression) {
-  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
-    throw new TemplateLiteralFiniteError(`Unknown expression type`);
-  })();
+function SetIntersectManyResolve(T, Init) {
+  return T.reduce((Acc, L) => {
+    return SetIntersect(Acc, L);
+  }, Init);
 }
-function IsTemplateLiteralFinite(schema) {
-  const expression = TemplateLiteralParseExact(schema.pattern);
-  return IsTemplateLiteralExpressionFinite(expression);
+function SetIntersectMany(T) {
+  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
-var TemplateLiteralGenerateError = class extends TypeBoxError {
-};
-function* GenerateReduce(buffer) {
-  if (buffer.length === 1)
-    return yield* buffer[0];
-  for (const left of buffer[0]) {
-    for (const right of GenerateReduce(buffer.slice(1))) {
-      yield `${left}${right}`;
-    }
-  }
+function SetUnionMany(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...L);
+  return Acc;
 }
-function* GenerateAnd(expression) {
-  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
+function FromMappedResult3(K, P) {
+  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
 }
-function* GenerateOr(expression) {
-  for (const expr of expression.expr)
-    yield* TemplateLiteralExpressionGenerate(expr);
+function MappedKeyToKnownMappedResultProperties(K) {
+  return { [K]: Literal(K) };
 }
-function* GenerateConst(expression) {
-  return yield expression.const;
+function MappedKeyToUnknownMappedResultProperties(P) {
+  const Acc = {};
+  for (const L of P)
+    Acc[L] = Literal(L);
+  return Acc;
 }
-function* TemplateLiteralExpressionGenerate(expression) {
-  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
-    throw new TemplateLiteralGenerateError("Unknown expression");
-  })();
+function MappedKeyToMappedResultProperties(K, P) {
+  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
 }
-function TemplateLiteralGenerate(schema) {
-  const expression = TemplateLiteralParseExact(schema.pattern);
-  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
+function FromMappedKey(K, P) {
+  const R = MappedKeyToMappedResultProperties(K, P);
+  return FromMappedResult3(K, R);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
-function Literal(value, options) {
-  return CreateType({
-    [Kind]: "Literal",
-    const: value,
-    type: typeof value
-  }, options);
+function FromRest2(K, T) {
+  return T.map((L) => FromSchemaType(K, L));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
-function Boolean(options) {
-  return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
+function FromProperties3(K, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K2] = FromSchemaType(K, T[K2]);
+  return Acc;
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
-function BigInt(options) {
-  return CreateType({ [Kind]: "BigInt", type: "bigint" }, options);
+function FromSchemaType(K, T) {
+  const options = { ...T };
+  return (
+    // unevaluated modifier types
+    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : (
+      // unevaluated mapped types
+      IsMappedResult(T) ? FromMappedResult3(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : (
+        // unevaluated types
+        IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction3(T) ? Function(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator3(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator3(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf), options) : IsUnion(T) ? Union(FromRest2(K, T.anyOf), options) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? []), options) : IsObject3(T) ? Object2(FromProperties3(K, T.properties), options) : IsArray3(T) ? Array2(FromSchemaType(K, T.items), options) : IsPromise2(T) ? Promise2(FromSchemaType(K, T.item), options) : T
+      )
+    )
+  );
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
-function Number2(options) {
-  return CreateType({ [Kind]: "Number", type: "number" }, options);
+function MappedFunctionReturnType(K, T) {
+  const Acc = {};
+  for (const L of K)
+    Acc[L] = FromSchemaType(L, T);
+  return Acc;
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
-function String2(options) {
-  return CreateType({ [Kind]: "String", type: "string" }, options);
+function Mapped(key, map, options) {
+  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const RT = map({ [Kind]: "MappedKey", keys: K });
+  const R = MappedFunctionReturnType(K, RT);
+  return Object2(R, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
-function* FromUnion(syntax) {
-  const trim = syntax.trim().replace(/"|'/g, "");
-  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
-    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
-    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
-  })();
+// ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
+function RemoveOptional(schema) {
+  return CreateType(Discard(schema, [OptionalKind]));
 }
-function* FromTerminal(syntax) {
-  if (syntax[1] !== "{") {
-    const L = Literal("$");
-    const R = FromSyntax(syntax.slice(1));
-    return yield* [L, ...R];
-  }
-  for (let i = 2; i < syntax.length; i++) {
-    if (syntax[i] === "}") {
-      const L = FromUnion(syntax.slice(2, i));
-      const R = FromSyntax(syntax.slice(i + 1));
-      return yield* [...L, ...R];
-    }
-  }
-  yield Literal(syntax);
+function AddOptional(schema) {
+  return CreateType({ ...schema, [OptionalKind]: "Optional" });
 }
-function* FromSyntax(syntax) {
-  for (let i = 0; i < syntax.length; i++) {
-    if (syntax[i] === "$") {
-      const L = Literal(syntax.slice(0, i));
-      const R = FromTerminal(syntax.slice(i));
-      return yield* [L, ...R];
-    }
-  }
-  yield Literal(syntax);
+function OptionalWithFlag(schema, F) {
+  return F === false ? RemoveOptional(schema) : AddOptional(schema);
 }
-function TemplateLiteralSyntax(syntax) {
-  return [...FromSyntax(syntax)];
+function Optional(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
-var TemplateLiteralPatternError = class extends TypeBoxError {
-};
-function Escape(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
+function FromProperties4(P, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Optional(P[K2], F);
+  return Acc;
 }
-function Visit2(schema, acc) {
-  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber3(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt2(schema) ? `${acc}${PatternNumber}` : IsString2(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean2(schema) ? `${acc}${PatternBoolean}` : (() => {
-    throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
-  })();
+function FromMappedResult4(R, F) {
+  return FromProperties4(R.properties, F);
 }
-function TemplateLiteralPattern(kinds) {
-  return `^${kinds.map((schema) => Visit2(schema, "")).join("")}$`;
+function OptionalFromMappedResult(R, F) {
+  const P = FromMappedResult4(R, F);
+  return MappedResult(P);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
-function TemplateLiteralToUnion(schema) {
-  const R = TemplateLiteralGenerate(schema);
-  const L = R.map((S) => Literal(S));
-  return UnionEvaluated(L);
+// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
+function IntersectCreate(T, options = {}) {
+  const allObjects = T.every((schema) => IsObject3(schema));
+  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
+  return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
-function TemplateLiteral(unresolved, options) {
-  const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
-  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
+// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
+function IsIntersectOptional(types) {
+  return types.every((left) => IsOptional(left));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
-function FromTemplateLiteral(templateLiteral) {
-  const keys = TemplateLiteralGenerate(templateLiteral);
-  return keys.map((key) => key.toString());
+function RemoveOptionalFromType2(type) {
+  return Discard(type, [OptionalKind]);
 }
-function FromUnion2(types) {
-  const result = [];
-  for (const type of types)
-    result.push(...IndexPropertyKeys(type));
-  return result;
+function RemoveOptionalFromRest2(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
 }
-function FromLiteral(literalValue) {
-  return [literalValue.toString()];
+function ResolveIntersect(types, options) {
+  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
 }
-function IndexPropertyKeys(type) {
-  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger(type) ? ["[number]"] : [])];
+function IntersectEvaluated(types, options = {}) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return ResolveIntersect(types, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
-function FromProperties(type, properties, options) {
-  const result = {};
-  for (const K2 of Object.getOwnPropertyNames(properties)) {
-    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
-  }
-  return result;
-}
-function FromMappedResult(type, mappedResult, options) {
-  return FromProperties(type, mappedResult.properties, options);
-}
-function IndexFromMappedResult(type, mappedResult, options) {
-  const properties = FromMappedResult(type, mappedResult, options);
-  return MappedResult(properties);
+// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
+function Intersect(types, options) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return IntersectCreate(types, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
-function FromRest(types, key) {
-  return types.map((type) => IndexFromPropertyKey(type, key));
-}
-function FromIntersectRest(types) {
-  return types.filter((type) => !IsNever(type));
-}
-function FromIntersect(types, key) {
-  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
+// ../../node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
+function Ref(...args) {
+  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
+  if (typeof $ref !== "string")
+    throw new TypeBoxError("Ref: $ref must be a string");
+  return CreateType({ [Kind]: "Ref", $ref }, options);
 }
-function FromUnionRest(types) {
-  return types.some((L) => IsNever(L)) ? [] : types;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
+function FromRest3(types) {
+  const result = [];
+  for (const L of types)
+    result.push(KeyOfPropertyKeys(L));
+  return result;
 }
-function FromUnion3(types, key) {
-  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
+function FromIntersect2(types) {
+  const propertyKeysArray = FromRest3(types);
+  const propertyKeys = SetUnionMany(propertyKeysArray);
+  return propertyKeys;
 }
-function FromTuple(types, key) {
-  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
+function FromUnion4(types) {
+  const propertyKeysArray = FromRest3(types);
+  const propertyKeys = SetIntersectMany(propertyKeysArray);
+  return propertyKeys;
 }
-function FromArray(type, key) {
-  return key === "[number]" ? type : Never();
+function FromTuple2(types) {
+  return types.map((_, indexer) => indexer.toString());
 }
-function FromProperty(properties, propertyKey) {
-  return propertyKey in properties ? properties[propertyKey] : Never();
+function FromArray2(_) {
+  return ["[number]"];
 }
-function IndexFromPropertyKey(type, propertyKey) {
-  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray3(type) ? FromArray(type.items, propertyKey) : IsObject3(type) ? FromProperty(type.properties, propertyKey) : Never();
+function FromProperties5(T) {
+  return globalThis.Object.getOwnPropertyNames(T);
 }
-function IndexFromPropertyKeys(type, propertyKeys) {
-  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+function FromPatternProperties(patternProperties) {
+  if (!includePatternProperties)
+    return [];
+  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
+  return patternPropertyKeys.map((key) => {
+    return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+  });
 }
-function FromSchema(type, propertyKeys) {
-  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+function KeyOfPropertyKeys(type) {
+  return IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsTuple(type) ? FromTuple2(type.items ?? []) : IsArray3(type) ? FromArray2(type.items) : IsObject3(type) ? FromProperties5(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
 }
-function Index(type, key, options) {
-  if (IsRef(type) || IsRef(key)) {
-    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
-    if (!IsSchema(type) || !IsSchema(key))
-      throw new TypeBoxError(error);
-    return Computed("Index", [type, key]);
-  }
-  if (IsMappedResult(key))
-    return IndexFromMappedResult(type, key, options);
-  if (IsMappedKey(key))
-    return IndexFromMappedKey(type, key, options);
-  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
+var includePatternProperties = false;
+function KeyOfPattern(schema) {
+  includePatternProperties = true;
+  const keys = KeyOfPropertyKeys(schema);
+  includePatternProperties = false;
+  const pattern = keys.map((key) => `(${key})`);
+  return `^(${pattern.join("|")})$`;
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
-function MappedIndexPropertyKey(type, key, options) {
-  return { [key]: Index(type, [key], Clone(options)) };
+// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
+function FromComputed(target, parameters) {
+  return Computed("KeyOf", [Computed(target, parameters)]);
 }
-function MappedIndexPropertyKeys(type, propertyKeys, options) {
-  return propertyKeys.reduce((result, left) => {
-    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
-  }, {});
+function FromRef($ref) {
+  return Computed("KeyOf", [Ref($ref)]);
 }
-function MappedIndexProperties(type, mappedKey, options) {
-  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+function KeyOfFromType(type, options) {
+  const propertyKeys = KeyOfPropertyKeys(type);
+  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
+  const result = UnionEvaluated(propertyKeyTypes);
+  return CreateType(result, options);
 }
-function IndexFromMappedKey(type, mappedKey, options) {
-  const properties = MappedIndexProperties(type, mappedKey, options);
-  return MappedResult(properties);
+function KeyOfPropertyKeysToRest(propertyKeys) {
+  return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
-function Iterator(items, options) {
-  return CreateType({ [Kind]: "Iterator", type: "Iterator", items }, options);
+function KeyOf(type, options) {
+  return IsComputed(type) ? FromComputed(type.target, type.parameters) : IsRef(type) ? FromRef(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
-function RequiredArray(properties) {
-  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
+// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
+function FromProperties6(properties, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = KeyOf(properties[K2], Clone(options));
+  return result;
 }
-function _Object(properties, options) {
-  const required = RequiredArray(properties);
-  const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
-  return CreateType(schema, options);
+function FromMappedResult5(mappedResult, options) {
+  return FromProperties6(mappedResult.properties, options);
 }
-var Object2 = _Object;
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
-function Promise2(item, options) {
-  return CreateType({ [Kind]: "Promise", type: "Promise", item }, options);
+function KeyOfFromMappedResult(mappedResult, options) {
+  const properties = FromMappedResult5(mappedResult, options);
+  return MappedResult(properties);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
-function RemoveReadonly(schema) {
-  return CreateType(Discard(schema, [ReadonlyKind]));
-}
-function AddReadonly(schema) {
-  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
+// ../../node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
+function CompositeKeys(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...KeyOfPropertyKeys(L));
+  return SetDistinct(Acc);
 }
-function ReadonlyWithFlag(schema, F) {
-  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
+function FilterNever(T) {
+  return T.filter((L) => !IsNever(L));
 }
-function Readonly(schema, enable) {
-  const F = enable ?? true;
-  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+function CompositeProperty(T, K) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...IndexFromPropertyKeys(L, [K]));
+  return FilterNever(Acc);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
-function FromProperties2(K, F) {
+function CompositeProperties(T, K) {
   const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-    Acc[K2] = Readonly(K[K2], F);
+  for (const L of K) {
+    Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+  }
   return Acc;
 }
-function FromMappedResult2(R, F) {
-  return FromProperties2(R.properties, F);
+function Composite(T, options) {
+  const K = CompositeKeys(T);
+  const P = CompositeProperties(T, K);
+  const R = Object2(P, options);
+  return R;
 }
-function ReadonlyFromMappedResult(R, F) {
-  const P = FromMappedResult2(R, F);
-  return MappedResult(P);
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
+function Date2(options) {
+  return CreateType({ [Kind]: "Date", type: "Date" }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
-function Tuple(types, options) {
-  return CreateType(types.length > 0 ? { [Kind]: "Tuple", type: "array", items: types, additionalItems: false, minItems: types.length, maxItems: types.length } : { [Kind]: "Tuple", type: "array", minItems: types.length, maxItems: types.length }, options);
+// ../../node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
+function Null(options) {
+  return CreateType({ [Kind]: "Null", type: "null" }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
-function FromMappedResult3(K, P) {
-  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
+// ../../node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
+function Symbol2(options) {
+  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
 }
-function MappedKeyToKnownMappedResultProperties(K) {
-  return { [K]: Literal(K) };
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
+function Undefined(options) {
+  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
 }
-function MappedKeyToUnknownMappedResultProperties(P) {
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
+function Uint8Array2(options) {
+  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
+function Unknown(options) {
+  return CreateType({ [Kind]: "Unknown" }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
+function FromArray3(T) {
+  return T.map((L) => FromValue(L, false));
+}
+function FromProperties7(value) {
   const Acc = {};
-  for (const L of P)
-    Acc[L] = Literal(L);
+  for (const K of globalThis.Object.getOwnPropertyNames(value))
+    Acc[K] = Readonly(FromValue(value[K], false));
   return Acc;
 }
-function MappedKeyToMappedResultProperties(K, P) {
-  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
+function ConditionalReadonly(T, root) {
+  return root === true ? T : Readonly(T);
 }
-function FromMappedKey(K, P) {
-  const R = MappedKeyToMappedResultProperties(K, P);
-  return FromMappedResult3(K, R);
+function FromValue(value, root) {
+  return IsAsyncIterator2(value) ? ConditionalReadonly(Any(), root) : IsIterator2(value) ? ConditionalReadonly(Any(), root) : IsArray2(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array2(value) ? Uint8Array2() : IsDate2(value) ? Date2() : IsObject2(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction2(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined2(value) ? Undefined() : IsNull2(value) ? Null() : IsSymbol2(value) ? Symbol2() : IsBigInt2(value) ? BigInt() : IsNumber2(value) ? Literal(value) : IsBoolean2(value) ? Literal(value) : IsString2(value) ? Literal(value) : Object2({});
 }
-function FromRest2(K, T) {
-  return T.map((L) => FromSchemaType(K, L));
+function Const(T, options) {
+  return CreateType(FromValue(T, true), options);
 }
-function FromProperties3(K, T) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
-    Acc[K2] = FromSchemaType(K, T[K2]);
-  return Acc;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
+function Enum(item, options) {
+  if (IsUndefined2(item))
+    throw new Error("Enum undefined or empty");
+  const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+  const values2 = [...new Set(values1)];
+  const anyOf = values2.map((value) => Literal(value));
+  return Union(anyOf, { ...options, [Hint]: "Enum" });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
+var type_exports = {};
+__export(type_exports, {
+  IsAny: () => IsAny2,
+  IsArgument: () => IsArgument2,
+  IsArray: () => IsArray4,
+  IsAsyncIterator: () => IsAsyncIterator4,
+  IsBigInt: () => IsBigInt4,
+  IsBoolean: () => IsBoolean4,
+  IsComputed: () => IsComputed2,
+  IsConstructor: () => IsConstructor2,
+  IsDate: () => IsDate4,
+  IsFunction: () => IsFunction4,
+  IsImport: () => IsImport,
+  IsInteger: () => IsInteger3,
+  IsIntersect: () => IsIntersect2,
+  IsIterator: () => IsIterator4,
+  IsKind: () => IsKind2,
+  IsKindOf: () => IsKindOf2,
+  IsLiteral: () => IsLiteral2,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue2,
+  IsMappedKey: () => IsMappedKey2,
+  IsMappedResult: () => IsMappedResult2,
+  IsNever: () => IsNever2,
+  IsNot: () => IsNot2,
+  IsNull: () => IsNull4,
+  IsNumber: () => IsNumber4,
+  IsObject: () => IsObject4,
+  IsOptional: () => IsOptional2,
+  IsPromise: () => IsPromise3,
+  IsProperties: () => IsProperties,
+  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord2,
+  IsRecursive: () => IsRecursive,
+  IsRef: () => IsRef2,
+  IsRegExp: () => IsRegExp3,
+  IsSchema: () => IsSchema2,
+  IsString: () => IsString4,
+  IsSymbol: () => IsSymbol4,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsThis: () => IsThis2,
+  IsTransform: () => IsTransform2,
+  IsTuple: () => IsTuple2,
+  IsUint8Array: () => IsUint8Array4,
+  IsUndefined: () => IsUndefined4,
+  IsUnion: () => IsUnion2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnknown: () => IsUnknown2,
+  IsUnsafe: () => IsUnsafe2,
+  IsVoid: () => IsVoid2,
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
+});
+var TypeGuardUnknownTypeError = class extends TypeBoxError {
+};
+var KnownTypes = [
+  "Argument",
+  "Any",
+  "Array",
+  "AsyncIterator",
+  "BigInt",
+  "Boolean",
+  "Computed",
+  "Constructor",
+  "Date",
+  "Enum",
+  "Function",
+  "Integer",
+  "Intersect",
+  "Iterator",
+  "Literal",
+  "MappedKey",
+  "MappedResult",
+  "Not",
+  "Null",
+  "Number",
+  "Object",
+  "Promise",
+  "Record",
+  "Ref",
+  "RegExp",
+  "String",
+  "Symbol",
+  "TemplateLiteral",
+  "This",
+  "Tuple",
+  "Undefined",
+  "Union",
+  "Uint8Array",
+  "Unknown",
+  "Void"
+];
+function IsPattern(value) {
+  try {
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function FromSchemaType(K, T) {
-  const options = { ...T };
-  return (
-    // unevaluated modifier types
-    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : (
-      // unevaluated mapped types
-      IsMappedResult(T) ? FromMappedResult3(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : (
-        // unevaluated types
-        IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction2(T) ? Function(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator2(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator2(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf), options) : IsUnion(T) ? Union(FromRest2(K, T.anyOf), options) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? []), options) : IsObject3(T) ? Object2(FromProperties3(K, T.properties), options) : IsArray3(T) ? Array2(FromSchemaType(K, T.items), options) : IsPromise(T) ? Promise2(FromSchemaType(K, T.item), options) : T
-      )
-    )
-  );
+function IsControlCharacterFree(value) {
+  if (!IsString2(value))
+    return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+      return false;
+    }
+  }
+  return true;
 }
-function MappedFunctionReturnType(K, T) {
-  const Acc = {};
-  for (const L of K)
-    Acc[L] = FromSchemaType(L, T);
-  return Acc;
+function IsAdditionalProperties(value) {
+  return IsOptionalBoolean(value) || IsSchema2(value);
 }
-function Mapped(key, map, options) {
-  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
-  const RT = map({ [Kind]: "MappedKey", keys: K });
-  const R = MappedFunctionReturnType(K, RT);
-  return Object2(R, options);
+function IsOptionalBigInt(value) {
+  return IsUndefined2(value) || IsBigInt2(value);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
-function RemoveOptional(schema) {
-  return CreateType(Discard(schema, [OptionalKind]));
+function IsOptionalNumber(value) {
+  return IsUndefined2(value) || IsNumber2(value);
 }
-function AddOptional(schema) {
-  return CreateType({ ...schema, [OptionalKind]: "Optional" });
+function IsOptionalBoolean(value) {
+  return IsUndefined2(value) || IsBoolean2(value);
 }
-function OptionalWithFlag(schema, F) {
-  return F === false ? RemoveOptional(schema) : AddOptional(schema);
+function IsOptionalString(value) {
+  return IsUndefined2(value) || IsString2(value);
 }
-function Optional(schema, enable) {
-  const F = enable ?? true;
-  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+function IsOptionalPattern(value) {
+  return IsUndefined2(value) || IsString2(value) && IsControlCharacterFree(value) && IsPattern(value);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
-function FromProperties4(P, F) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Optional(P[K2], F);
-  return Acc;
+function IsOptionalFormat(value) {
+  return IsUndefined2(value) || IsString2(value) && IsControlCharacterFree(value);
 }
-function FromMappedResult4(R, F) {
-  return FromProperties4(R.properties, F);
+function IsOptionalSchema(value) {
+  return IsUndefined2(value) || IsSchema2(value);
 }
-function OptionalFromMappedResult(R, F) {
-  const P = FromMappedResult4(R, F);
-  return MappedResult(P);
+function IsReadonly2(value) {
+  return IsObject2(value) && value[ReadonlyKind] === "Readonly";
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
-function IntersectCreate(T, options = {}) {
-  const allObjects = T.every((schema) => IsObject3(schema));
-  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
-  return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T }, options);
+function IsOptional2(value) {
+  return IsObject2(value) && value[OptionalKind] === "Optional";
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
-function IsIntersectOptional(types) {
-  return types.every((left) => IsOptional(left));
+function IsAny2(value) {
+  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
 }
-function RemoveOptionalFromType2(type) {
-  return Discard(type, [OptionalKind]);
+function IsArgument2(value) {
+  return IsKindOf2(value, "Argument") && IsNumber2(value.index);
 }
-function RemoveOptionalFromRest2(types) {
-  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
+function IsArray4(value) {
+  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
 }
-function ResolveIntersect(types, options) {
-  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
+function IsAsyncIterator4(value) {
+  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
 }
-function IntersectEvaluated(types, options = {}) {
-  if (types.length === 1)
-    return CreateType(types[0], options);
-  if (types.length === 0)
-    return Never(options);
-  if (types.some((schema) => IsTransform(schema)))
-    throw new Error("Cannot intersect transform types");
-  return ResolveIntersect(types, options);
+function IsBigInt4(value) {
+  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
-function Intersect(types, options) {
-  if (types.length === 1)
-    return CreateType(types[0], options);
-  if (types.length === 0)
-    return Never(options);
-  if (types.some((schema) => IsTransform(schema)))
-    throw new Error("Cannot intersect transform types");
-  return IntersectCreate(types, options);
+function IsBoolean4(value) {
+  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
-function Ref(...args) {
-  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
-  if (typeof $ref !== "string")
-    throw new TypeBoxError("Ref: $ref must be a string");
-  return CreateType({ [Kind]: "Ref", $ref }, options);
+function IsComputed2(value) {
+  return IsKindOf2(value, "Computed") && IsString2(value.target) && IsArray2(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
-function FromComputed(target, parameters) {
-  return Computed("Awaited", [Computed(target, parameters)]);
+function IsConstructor2(value) {
+  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray2(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
 }
-function FromRef($ref) {
-  return Computed("Awaited", [Ref($ref)]);
+function IsDate4(value) {
+  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
 }
-function FromIntersect2(types) {
-  return Intersect(FromRest3(types));
+function IsFunction4(value) {
+  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray2(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
 }
-function FromUnion4(types) {
-  return Union(FromRest3(types));
+function IsImport(value) {
+  return IsKindOf2(value, "Import") && HasPropertyKey2(value, "$defs") && IsObject2(value.$defs) && IsProperties(value.$defs) && HasPropertyKey2(value, "$ref") && IsString2(value.$ref) && value.$ref in value.$defs;
 }
-function FromPromise(type) {
-  return Awaited(type);
+function IsInteger3(value) {
+  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
 }
-function FromRest3(types) {
-  return types.map((type) => Awaited(type));
+function IsProperties(value) {
+  return IsObject2(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
 }
-function Awaited(type, options) {
-  return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
+function IsIntersect2(value) {
+  return IsKindOf2(value, "Intersect") && (IsString2(value.type) && value.type !== "object" ? false : true) && IsArray2(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
-function FromRest4(types) {
-  const result = [];
-  for (const L of types)
-    result.push(KeyOfPropertyKeys(L));
-  return result;
+function IsIterator4(value) {
+  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
 }
-function FromIntersect3(types) {
-  const propertyKeysArray = FromRest4(types);
-  const propertyKeys = SetUnionMany(propertyKeysArray);
-  return propertyKeys;
+function IsKindOf2(value, kind) {
+  return IsObject2(value) && Kind in value && value[Kind] === kind;
 }
-function FromUnion5(types) {
-  const propertyKeysArray = FromRest4(types);
-  const propertyKeys = SetIntersectMany(propertyKeysArray);
-  return propertyKeys;
+function IsLiteralString(value) {
+  return IsLiteral2(value) && IsString2(value.const);
 }
-function FromTuple2(types) {
-  return types.map((_, indexer) => indexer.toString());
+function IsLiteralNumber(value) {
+  return IsLiteral2(value) && IsNumber2(value.const);
 }
-function FromArray2(_) {
-  return ["[number]"];
+function IsLiteralBoolean(value) {
+  return IsLiteral2(value) && IsBoolean2(value.const);
 }
-function FromProperties5(T) {
-  return globalThis.Object.getOwnPropertyNames(T);
+function IsLiteral2(value) {
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
 }
-function FromPatternProperties(patternProperties) {
-  if (!includePatternProperties)
-    return [];
-  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
-  return patternPropertyKeys.map((key) => {
-    return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
-  });
+function IsLiteralValue2(value) {
+  return IsBoolean2(value) || IsNumber2(value) || IsString2(value);
 }
-function KeyOfPropertyKeys(type) {
-  return IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion5(type.anyOf) : IsTuple(type) ? FromTuple2(type.items ?? []) : IsArray3(type) ? FromArray2(type.items) : IsObject3(type) ? FromProperties5(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
+function IsMappedKey2(value) {
+  return IsKindOf2(value, "MappedKey") && IsArray2(value.keys) && value.keys.every((key) => IsNumber2(key) || IsString2(key));
 }
-var includePatternProperties = false;
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
-function FromComputed2(target, parameters) {
-  return Computed("KeyOf", [Computed(target, parameters)]);
+function IsMappedResult2(value) {
+  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
 }
-function FromRef2($ref) {
-  return Computed("KeyOf", [Ref($ref)]);
+function IsNever2(value) {
+  return IsKindOf2(value, "Never") && IsObject2(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
 }
-function KeyOfFromType(type, options) {
-  const propertyKeys = KeyOfPropertyKeys(type);
-  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
-  const result = UnionEvaluated(propertyKeyTypes);
-  return CreateType(result, options);
+function IsNot2(value) {
+  return IsKindOf2(value, "Not") && IsSchema2(value.not);
 }
-function KeyOfPropertyKeysToRest(propertyKeys) {
-  return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
+function IsNull4(value) {
+  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
 }
-function KeyOf(type, options) {
-  return IsComputed(type) ? FromComputed2(type.target, type.parameters) : IsRef(type) ? FromRef2(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
+function IsNumber4(value) {
+  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
-function FromProperties6(properties, options) {
-  const result = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
-    result[K2] = KeyOf(properties[K2], Clone(options));
-  return result;
+function IsObject4(value) {
+  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
 }
-function FromMappedResult5(mappedResult, options) {
-  return FromProperties6(mappedResult.properties, options);
+function IsPromise3(value) {
+  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
 }
-function KeyOfFromMappedResult(mappedResult, options) {
-  const properties = FromMappedResult5(mappedResult, options);
-  return MappedResult(properties);
+function IsRecord2(value) {
+  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject2(value.patternProperties) && ((schema) => {
+    const keys = Object.getOwnPropertyNames(schema.patternProperties);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject2(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
+  })(value);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
-function CompositeKeys(T) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...KeyOfPropertyKeys(L));
-  return SetDistinct(Acc);
+function IsRecursive(value) {
+  return IsObject2(value) && Hint in value && value[Hint] === "Recursive";
 }
-function FilterNever(T) {
-  return T.filter((L) => !IsNever(L));
+function IsRef2(value) {
+  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString2(value.$ref);
 }
-function CompositeProperty(T, K) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...IndexFromPropertyKeys(L, [K]));
-  return FilterNever(Acc);
+function IsRegExp3(value) {
+  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString2(value.source) && IsString2(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
 }
-function CompositeProperties(T, K) {
-  const Acc = {};
-  for (const L of K) {
-    Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
-  }
-  return Acc;
+function IsString4(value) {
+  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
 }
-function Composite(T, options) {
-  const K = CompositeKeys(T);
-  const P = CompositeProperties(T, K);
-  const R = Object2(P, options);
-  return R;
+function IsSymbol4(value) {
+  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
-function Date2(options) {
-  return CreateType({ [Kind]: "Date", type: "Date" }, options);
+function IsTemplateLiteral2(value) {
+  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString2(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
-function Null(options) {
-  return CreateType({ [Kind]: "Null", type: "null" }, options);
+function IsThis2(value) {
+  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString2(value.$ref);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
-function Symbol2(options) {
-  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
+function IsTransform2(value) {
+  return IsObject2(value) && TransformKind in value;
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
-function Undefined(options) {
-  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
+function IsTuple2(value) {
+  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber2(value.minItems) && IsNumber2(value.maxItems) && value.minItems === value.maxItems && // empty
+  (IsUndefined2(value.items) && IsUndefined2(value.additionalItems) && value.minItems === 0 || IsArray2(value.items) && value.items.every((schema) => IsSchema2(schema)));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
-function Uint8Array2(options) {
-  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
+function IsUndefined4(value) {
+  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
-function Unknown(options) {
-  return CreateType({ [Kind]: "Unknown" }, options);
+function IsUnionLiteral(value) {
+  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
-function FromArray3(T) {
-  return T.map((L) => FromValue(L, false));
+function IsUnion2(value) {
+  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject2(value) && IsArray2(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
 }
-function FromProperties7(value) {
-  const Acc = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(value))
-    Acc[K] = Readonly(FromValue(value[K], false));
-  return Acc;
+function IsUint8Array4(value) {
+  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
 }
-function ConditionalReadonly(T, root) {
-  return root === true ? T : Readonly(T);
+function IsUnknown2(value) {
+  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
 }
-function FromValue(value, root) {
-  return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) : IsIterator(value) ? ConditionalReadonly(Any(), root) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
+function IsUnsafe2(value) {
+  return IsKindOf2(value, "Unsafe");
 }
-function Const(T, options) {
-  return CreateType(FromValue(T, true), options);
+function IsVoid2(value) {
+  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
-function ConstructorParameters(schema, options) {
-  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
+function IsKind2(value) {
+  return IsObject2(value) && Kind in value && IsString2(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
-function Enum(item, options) {
-  if (IsUndefined(item))
-    throw new Error("Enum undefined or empty");
-  const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
-  const values2 = [...new Set(values1)];
-  const anyOf = values2.map((value) => Literal(value));
-  return Union(anyOf, { ...options, [Hint]: "Enum" });
+function IsSchema2(value) {
+  return IsObject2(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean4(value) || IsBigInt4(value) || IsAsyncIterator4(value) || IsComputed2(value) || IsConstructor2(value) || IsDate4(value) || IsFunction4(value) || IsInteger3(value) || IsIntersect2(value) || IsIterator4(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull4(value) || IsNumber4(value) || IsObject4(value) || IsPromise3(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString4(value) || IsSymbol4(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array4(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.mjs
@@ -1568,7 +1589,7 @@ function FromInteger(left, right) {
 function FromIntersectRight(left, right) {
   return right.allOf.every((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromIntersect4(left, right) {
+function FromIntersect3(left, right) {
   return left.allOf.some((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
 function FromIterator(left, right) {
@@ -1670,11 +1691,11 @@ function FromObject(left, right) {
     return ExtendsResult.True;
   })();
 }
-function FromPromise2(left, right) {
+function FromPromise(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !type_exports.IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.item, right.item));
 }
 function RecordKey(schema) {
-  return PatternNumberExact in schema.patternProperties ? Number2() : PatternStringExact in schema.patternProperties ? String2() : Throw("Unknown record key pattern");
+  return PatternNumberExact in schema.patternProperties ? Number2() : PatternStringExact in schema.patternProperties ? String() : Throw("Unknown record key pattern");
 }
 function RecordValue(schema) {
   return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
@@ -1694,8 +1715,8 @@ function FromRecord(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsRecord(right) ? ExtendsResult.False : Visit3(RecordValue(left), RecordValue(right));
 }
 function FromRegExp(left, right) {
-  const L = type_exports.IsRegExp(left) ? String2() : left;
-  const R = type_exports.IsRegExp(right) ? String2() : right;
+  const L = type_exports.IsRegExp(left) ? String() : left;
+  const R = type_exports.IsRegExp(right) ? String() : right;
   return Visit3(L, R);
 }
 function FromStringRight(left, right) {
@@ -1728,7 +1749,7 @@ function FromUndefined(left, right) {
 function FromUnionRight(left, right) {
   return right.anyOf.some((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromUnion6(left, right) {
+function FromUnion5(left, right) {
   return left.anyOf.every((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
 function FromUnknownRight(left, right) {
@@ -1748,7 +1769,7 @@ function Visit3(left, right) {
     // resolvable
     type_exports.IsTemplateLiteral(left) || type_exports.IsTemplateLiteral(right) ? FromTemplateLiteral2(left, right) : type_exports.IsRegExp(left) || type_exports.IsRegExp(right) ? FromRegExp(left, right) : type_exports.IsNot(left) || type_exports.IsNot(right) ? FromNot(left, right) : (
       // standard
-      type_exports.IsAny(left) ? FromAny(left, right) : type_exports.IsArray(left) ? FromArray4(left, right) : type_exports.IsBigInt(left) ? FromBigInt(left, right) : type_exports.IsBoolean(left) ? FromBoolean(left, right) : type_exports.IsAsyncIterator(left) ? FromAsyncIterator(left, right) : type_exports.IsConstructor(left) ? FromConstructor(left, right) : type_exports.IsDate(left) ? FromDate(left, right) : type_exports.IsFunction(left) ? FromFunction(left, right) : type_exports.IsInteger(left) ? FromInteger(left, right) : type_exports.IsIntersect(left) ? FromIntersect4(left, right) : type_exports.IsIterator(left) ? FromIterator(left, right) : type_exports.IsLiteral(left) ? FromLiteral2(left, right) : type_exports.IsNever(left) ? FromNever(left, right) : type_exports.IsNull(left) ? FromNull(left, right) : type_exports.IsNumber(left) ? FromNumber(left, right) : type_exports.IsObject(left) ? FromObject(left, right) : type_exports.IsRecord(left) ? FromRecord(left, right) : type_exports.IsString(left) ? FromString(left, right) : type_exports.IsSymbol(left) ? FromSymbol(left, right) : type_exports.IsTuple(left) ? FromTuple3(left, right) : type_exports.IsPromise(left) ? FromPromise2(left, right) : type_exports.IsUint8Array(left) ? FromUint8Array(left, right) : type_exports.IsUndefined(left) ? FromUndefined(left, right) : type_exports.IsUnion(left) ? FromUnion6(left, right) : type_exports.IsUnknown(left) ? FromUnknown(left, right) : type_exports.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
+      type_exports.IsAny(left) ? FromAny(left, right) : type_exports.IsArray(left) ? FromArray4(left, right) : type_exports.IsBigInt(left) ? FromBigInt(left, right) : type_exports.IsBoolean(left) ? FromBoolean(left, right) : type_exports.IsAsyncIterator(left) ? FromAsyncIterator(left, right) : type_exports.IsConstructor(left) ? FromConstructor(left, right) : type_exports.IsDate(left) ? FromDate(left, right) : type_exports.IsFunction(left) ? FromFunction(left, right) : type_exports.IsInteger(left) ? FromInteger(left, right) : type_exports.IsIntersect(left) ? FromIntersect3(left, right) : type_exports.IsIterator(left) ? FromIterator(left, right) : type_exports.IsLiteral(left) ? FromLiteral2(left, right) : type_exports.IsNever(left) ? FromNever(left, right) : type_exports.IsNull(left) ? FromNull(left, right) : type_exports.IsNumber(left) ? FromNumber(left, right) : type_exports.IsObject(left) ? FromObject(left, right) : type_exports.IsRecord(left) ? FromRecord(left, right) : type_exports.IsString(left) ? FromString(left, right) : type_exports.IsSymbol(left) ? FromSymbol(left, right) : type_exports.IsTuple(left) ? FromTuple3(left, right) : type_exports.IsPromise(left) ? FromPromise(left, right) : type_exports.IsUint8Array(left) ? FromUint8Array(left, right) : type_exports.IsUndefined(left) ? FromUndefined(left, right) : type_exports.IsUnion(left) ? FromUnion5(left, right) : type_exports.IsUnknown(left) ? FromUnknown(left, right) : type_exports.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
     )
   );
 }
@@ -1805,204 +1826,64 @@ function ExcludeFromTemplateLiteral(L, R) {
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs
-function ExcludeRest(L, R) {
-  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
-  return excluded.length === 1 ? excluded[0] : Union(excluded);
-}
-function Exclude(L, R, options = {}) {
-  if (IsTemplateLiteral(L))
-    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
-  if (IsMappedResult(L))
-    return CreateType(ExcludeFromMappedResult(L, R), options);
-  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
-function FromProperties9(P, U) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Exclude(P[K2], U);
-  return Acc;
-}
-function FromMappedResult7(R, T) {
-  return FromProperties9(R.properties, T);
-}
-function ExcludeFromMappedResult(R, T) {
-  const P = FromMappedResult7(R, T);
-  return MappedResult(P);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
-function ExtractFromTemplateLiteral(L, R) {
-  return Extract(TemplateLiteralToUnion(L), R);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
-function ExtractRest(L, R) {
-  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
-  return extracted.length === 1 ? extracted[0] : Union(extracted);
-}
-function Extract(L, R, options) {
-  if (IsTemplateLiteral(L))
-    return CreateType(ExtractFromTemplateLiteral(L, R), options);
-  if (IsMappedResult(L))
-    return CreateType(ExtractFromMappedResult(L, R), options);
-  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
-function FromProperties10(P, T) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Extract(P[K2], T);
-  return Acc;
-}
-function FromMappedResult8(R, T) {
-  return FromProperties10(R.properties, T);
-}
-function ExtractFromMappedResult(R, T) {
-  const P = FromMappedResult8(R, T);
-  return MappedResult(P);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
-function InstanceType(schema, options) {
-  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
-function ReadonlyOptional(schema) {
-  return Readonly(Optional(schema));
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
-function RecordCreateFromPattern(pattern, T, options) {
-  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
-}
-function RecordCreateFromKeys(K, T, options) {
-  const result = {};
-  for (const K2 of K)
-    result[K2] = T;
-  return Object2(result, { ...options, [Hint]: "Record" });
-}
-function FromTemplateLiteralKey(K, T, options) {
-  return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
-}
-function FromUnionKey(key, type, options) {
-  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
-}
-function FromLiteralKey(key, type, options) {
-  return RecordCreateFromKeys([key.toString()], type, options);
-}
-function FromRegExpKey(key, type, options) {
-  return RecordCreateFromPattern(key.source, type, options);
-}
-function FromStringKey(key, type, options) {
-  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
-  return RecordCreateFromPattern(pattern, type, options);
-}
-function FromAnyKey(_, type, options) {
-  return RecordCreateFromPattern(PatternStringExact, type, options);
-}
-function FromNeverKey(_key, type, options) {
-  return RecordCreateFromPattern(PatternNeverExact, type, options);
-}
-function FromBooleanKey(_key, type, options) {
-  return Object2({ true: type, false: type }, options);
-}
-function FromIntegerKey(_key, type, options) {
-  return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-function FromNumberKey(_, type, options) {
-  return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-function Record(key, type, options = {}) {
-  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean2(key) ? FromBooleanKey(key, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString2(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
-}
-function RecordPattern(record) {
-  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
-}
-function RecordKey2(type) {
-  const pattern = RecordPattern(type);
-  return pattern === PatternStringExact ? String2() : pattern === PatternNumberExact ? Number2() : String2({ pattern });
-}
-function RecordValue2(type) {
-  return type.patternProperties[RecordPattern(type)];
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
-function FromConstructor2(args, type) {
-  type.parameters = FromTypes(args, type.parameters);
-  type.returns = FromType(args, type.returns);
-  return type;
-}
-function FromFunction2(args, type) {
-  type.parameters = FromTypes(args, type.parameters);
-  type.returns = FromType(args, type.returns);
-  return type;
-}
-function FromIntersect5(args, type) {
-  type.allOf = FromTypes(args, type.allOf);
-  return type;
-}
-function FromUnion7(args, type) {
-  type.anyOf = FromTypes(args, type.anyOf);
-  return type;
-}
-function FromTuple4(args, type) {
-  if (IsUndefined(type.items))
-    return type;
-  type.items = FromTypes(args, type.items);
-  return type;
-}
-function FromArray5(args, type) {
-  type.items = FromType(args, type.items);
-  return type;
-}
-function FromAsyncIterator2(args, type) {
-  type.items = FromType(args, type.items);
-  return type;
+function ExcludeRest(L, R) {
+  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+  return excluded.length === 1 ? excluded[0] : Union(excluded);
 }
-function FromIterator2(args, type) {
-  type.items = FromType(args, type.items);
-  return type;
+function Exclude(L, R, options = {}) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CreateType(ExcludeFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
 }
-function FromPromise3(args, type) {
-  type.item = FromType(args, type.item);
-  return type;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
+function FromProperties9(P, U) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Exclude(P[K2], U);
+  return Acc;
 }
-function FromObject2(args, type) {
-  const mappedProperties = FromProperties11(args, type.properties);
-  return { ...type, ...Object2(mappedProperties) };
+function FromMappedResult7(R, T) {
+  return FromProperties9(R.properties, T);
 }
-function FromRecord2(args, type) {
-  const mappedKey = FromType(args, RecordKey2(type));
-  const mappedValue = FromType(args, RecordValue2(type));
-  const result = Record(mappedKey, mappedValue);
-  return { ...type, ...result };
+function ExcludeFromMappedResult(R, T) {
+  const P = FromMappedResult7(R, T);
+  return MappedResult(P);
 }
-function FromArgument(args, argument) {
-  return argument.index in args ? args[argument.index] : Unknown();
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
+function ExtractFromTemplateLiteral(L, R) {
+  return Extract(TemplateLiteralToUnion(L), R);
 }
-function FromProperty2(args, type) {
-  const isReadonly = IsReadonly(type);
-  const isOptional = IsOptional(type);
-  const mapped = FromType(args, type);
-  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
+function ExtractRest(L, R) {
+  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+  return extracted.length === 1 ? extracted[0] : Union(extracted);
 }
-function FromProperties11(args, properties) {
-  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-    return { ...result, [key]: FromProperty2(args, properties[key]) };
-  }, {});
+function Extract(L, R, options) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExtractFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CreateType(ExtractFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
 }
-function FromTypes(args, types) {
-  return types.map((type) => FromType(args, type));
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
+function FromProperties10(P, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extract(P[K2], T);
+  return Acc;
 }
-function FromType(args, type) {
-  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction2(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args, type) : IsIterator2(type) ? FromIterator2(args, type) : IsPromise(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject2(args, type) : IsRecord(type) ? FromRecord2(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+function FromMappedResult8(R, T) {
+  return FromProperties10(R.properties, T);
 }
-function Instantiate(type, args) {
-  return FromType(args, CloneType(type));
+function ExtractFromMappedResult(R, T) {
+  const P = FromMappedResult8(R, T);
+  return MappedResult(P);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
@@ -2052,14 +1933,14 @@ function FromTemplateLiteral3(schema, mode, options) {
     return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
   const strings = [...TemplateLiteralExpressionGenerate(expression)];
   const literals = strings.map((value) => Literal(value));
-  const mapped = FromRest5(literals, mode);
+  const mapped = FromRest4(literals, mode);
   const union = Union(mapped);
   return TemplateLiteral([union], options);
 }
 function FromLiteralValue(value, mode) {
   return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
 }
-function FromRest5(T, M) {
+function FromRest4(T, M) {
   return T.map((L) => Intrinsic(L, M));
 }
 function Intrinsic(schema, mode, options = {}) {
@@ -2067,7 +1948,7 @@ function Intrinsic(schema, mode, options = {}) {
     // Intrinsic-Mapped-Inference
     IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : (
       // Standard-Inference
-      IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion(schema) ? Union(FromRest5(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : (
+      IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion(schema) ? Union(FromRest4(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : (
         // Default Type
         CreateType(schema, options)
       )
@@ -2095,15 +1976,48 @@ function Uppercase(T, options = {}) {
   return Intrinsic(T, "Uppercase", options);
 }
 
+// ../../node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
+function Not(type, options) {
+  return CreateType({ [Kind]: "Not", not: type }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+function CloneType(schema, options) {
+  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
+function FromComputed2(target, parameters) {
+  return Computed("Awaited", [Computed(target, parameters)]);
+}
+function FromRef2($ref) {
+  return Computed("Awaited", [Ref($ref)]);
+}
+function FromIntersect4(types) {
+  return Intersect(FromRest5(types));
+}
+function FromUnion6(types) {
+  return Union(FromRest5(types));
+}
+function FromPromise2(type) {
+  return Awaited(type);
+}
+function FromRest5(types) {
+  return types.map((type) => Awaited(type));
+}
+function Awaited(type, options) {
+  return CreateType(IsComputed(type) ? FromComputed2(type.target, type.parameters) : IsIntersect(type) ? FromIntersect4(type.allOf) : IsUnion(type) ? FromUnion6(type.anyOf) : IsPromise2(type) ? FromPromise2(type.item) : IsRef(type) ? FromRef2(type.$ref) : type, options);
+}
+
 // ../../node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
-function FromProperties12(properties, propertyKeys, options) {
+function FromProperties11(properties, propertyKeys, options) {
   const result = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
     result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
   return result;
 }
 function FromMappedResult9(mappedResult, propertyKeys, options) {
-  return FromProperties12(mappedResult.properties, propertyKeys, options);
+  return FromProperties11(mappedResult.properties, propertyKeys, options);
 }
 function OmitFromMappedResult(mappedResult, propertyKeys, options) {
   const properties = FromMappedResult9(mappedResult, propertyKeys, options);
@@ -2111,22 +2025,22 @@ function OmitFromMappedResult(mappedResult, propertyKeys, options) {
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
-function FromIntersect6(types, propertyKeys) {
+function FromIntersect5(types, propertyKeys) {
   return types.map((type) => OmitResolve(type, propertyKeys));
 }
-function FromUnion8(types, propertyKeys) {
+function FromUnion7(types, propertyKeys) {
   return types.map((type) => OmitResolve(type, propertyKeys));
 }
-function FromProperty3(properties, key) {
+function FromProperty2(properties, key) {
   const { [key]: _, ...R } = properties;
   return R;
 }
-function FromProperties13(properties, propertyKeys) {
-  return propertyKeys.reduce((T, K2) => FromProperty3(T, K2), properties);
+function FromProperties12(properties, propertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty2(T, K2), properties);
 }
-function FromObject3(type, propertyKeys, properties) {
+function FromObject2(type, propertyKeys, properties) {
   const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties13(properties, propertyKeys);
+  const mappedProperties = FromProperties12(properties, propertyKeys);
   return Object2(mappedProperties, options);
 }
 function UnionFromPropertyKeys(propertyKeys) {
@@ -2134,10 +2048,10 @@ function UnionFromPropertyKeys(propertyKeys) {
   return Union(result);
 }
 function OmitResolve(type, propertyKeys) {
-  return IsIntersect(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
+  return IsIntersect(type) ? Intersect(FromIntersect5(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion7(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject2(type, propertyKeys, type.properties) : Object2({});
 }
 function Omit(type, key, options) {
-  const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
+  const typeKey = IsArray2(key) ? UnionFromPropertyKeys(key) : key;
   const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
   const isTypeRef = IsRef(type);
   const isKeyRef = IsRef(key);
@@ -2162,14 +2076,14 @@ function OmitFromMappedKey(type, mappedKey, options) {
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
-function FromProperties14(properties, propertyKeys, options) {
+function FromProperties13(properties, propertyKeys, options) {
   const result = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
     result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
   return result;
 }
 function FromMappedResult10(mappedResult, propertyKeys, options) {
-  return FromProperties14(mappedResult.properties, propertyKeys, options);
+  return FromProperties13(mappedResult.properties, propertyKeys, options);
 }
 function PickFromMappedResult(mappedResult, propertyKeys, options) {
   const properties = FromMappedResult10(mappedResult, propertyKeys, options);
@@ -2177,22 +2091,22 @@ function PickFromMappedResult(mappedResult, propertyKeys, options) {
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
-function FromIntersect7(types, propertyKeys) {
+function FromIntersect6(types, propertyKeys) {
   return types.map((type) => PickResolve(type, propertyKeys));
 }
-function FromUnion9(types, propertyKeys) {
+function FromUnion8(types, propertyKeys) {
   return types.map((type) => PickResolve(type, propertyKeys));
 }
-function FromProperties15(properties, propertyKeys) {
+function FromProperties14(properties, propertyKeys) {
   const result = {};
   for (const K2 of propertyKeys)
     if (K2 in properties)
       result[K2] = properties[K2];
   return result;
 }
-function FromObject4(Type2, keys, properties) {
+function FromObject3(Type2, keys, properties) {
   const options = Discard(Type2, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties15(properties, keys);
+  const mappedProperties = FromProperties14(properties, keys);
   return Object2(mappedProperties, options);
 }
 function UnionFromPropertyKeys2(propertyKeys) {
@@ -2200,10 +2114,10 @@ function UnionFromPropertyKeys2(propertyKeys) {
   return Union(result);
 }
 function PickResolve(type, propertyKeys) {
-  return IsIntersect(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
+  return IsIntersect(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
 }
 function Pick(type, key, options) {
-  const typeKey = IsArray(key) ? UnionFromPropertyKeys2(key) : key;
+  const typeKey = IsArray2(key) ? UnionFromPropertyKeys2(key) : key;
   const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
   const isTypeRef = IsRef(type);
   const isKeyRef = IsRef(key);
@@ -2236,15 +2150,15 @@ function FromComputed3(target, parameters) {
 function FromRef3($ref) {
   return Computed("Partial", [Ref($ref)]);
 }
-function FromProperties16(properties) {
+function FromProperties15(properties) {
   const partialProperties = {};
   for (const K of globalThis.Object.getOwnPropertyNames(properties))
     partialProperties[K] = Optional(properties[K]);
   return partialProperties;
 }
-function FromObject5(type, properties) {
+function FromObject4(type, properties) {
   const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties16(properties);
+  const mappedProperties = FromProperties15(properties);
   return Object2(mappedProperties, options);
 }
 function FromRest6(types) {
@@ -2253,9 +2167,9 @@ function FromRest6(types) {
 function PartialResolve(type) {
   return (
     // Mappable
-    IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject5(type, type.properties) : (
+    IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject4(type, type.properties) : (
       // Intrinsic
-      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
+      IsBigInt3(type) ? type : IsBoolean3(type) ? type : IsInteger2(type) ? type : IsLiteral(type) ? type : IsNull3(type) ? type : IsNumber3(type) ? type : IsString3(type) ? type : IsSymbol3(type) ? type : IsUndefined3(type) ? type : (
         // Passthrough
         Object2({})
       )
@@ -2271,20 +2185,75 @@ function Partial(type, options) {
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
-function FromProperties17(K, options) {
+function FromProperties16(K, options) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(K))
     Acc[K2] = Partial(K[K2], Clone(options));
   return Acc;
 }
 function FromMappedResult11(R, options) {
-  return FromProperties17(R.properties, options);
+  return FromProperties16(R.properties, options);
 }
 function PartialFromMappedResult(R, options) {
   const P = FromMappedResult11(R, options);
   return MappedResult(P);
 }
 
+// ../../node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
+function RecordCreateFromPattern(pattern, T, options) {
+  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
+}
+function RecordCreateFromKeys(K, T, options) {
+  const result = {};
+  for (const K2 of K)
+    result[K2] = T;
+  return Object2(result, { ...options, [Hint]: "Record" });
+}
+function FromTemplateLiteralKey(K, T, options) {
+  return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
+}
+function FromUnionKey(key, type, options) {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
+}
+function FromLiteralKey(key, type, options) {
+  return RecordCreateFromKeys([key.toString()], type, options);
+}
+function FromRegExpKey(key, type, options) {
+  return RecordCreateFromPattern(key.source, type, options);
+}
+function FromStringKey(key, type, options) {
+  const pattern = IsUndefined2(key.pattern) ? PatternStringExact : key.pattern;
+  return RecordCreateFromPattern(pattern, type, options);
+}
+function FromAnyKey(_, type, options) {
+  return RecordCreateFromPattern(PatternStringExact, type, options);
+}
+function FromNeverKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNeverExact, type, options);
+}
+function FromBooleanKey(_key, type, options) {
+  return Object2({ true: type, false: type }, options);
+}
+function FromIntegerKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function FromNumberKey(_, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function Record(key, type, options = {}) {
+  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean3(key) ? FromBooleanKey(key, type, options) : IsInteger2(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString3(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
+}
+function RecordPattern(record) {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+function RecordKey2(type) {
+  const pattern = RecordPattern(type);
+  return pattern === PatternStringExact ? String() : pattern === PatternNumberExact ? Number2() : String({ pattern });
+}
+function RecordValue2(type) {
+  return type.patternProperties[RecordPattern(type)];
+}
+
 // ../../node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
 function FromComputed4(target, parameters) {
   return Computed("Required", [Computed(target, parameters)]);
@@ -2292,15 +2261,15 @@ function FromComputed4(target, parameters) {
 function FromRef4($ref) {
   return Computed("Required", [Ref($ref)]);
 }
-function FromProperties18(properties) {
+function FromProperties17(properties) {
   const requiredProperties = {};
   for (const K of globalThis.Object.getOwnPropertyNames(properties))
     requiredProperties[K] = Discard(properties[K], [OptionalKind]);
   return requiredProperties;
 }
-function FromObject6(type, properties) {
+function FromObject5(type, properties) {
   const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties18(properties);
+  const mappedProperties = FromProperties17(properties);
   return Object2(mappedProperties, options);
 }
 function FromRest7(types) {
@@ -2309,9 +2278,9 @@ function FromRest7(types) {
 function RequiredResolve(type) {
   return (
     // Mappable
-    IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject6(type, type.properties) : (
+    IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject5(type, type.properties) : (
       // Intrinsic
-      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
+      IsBigInt3(type) ? type : IsBoolean3(type) ? type : IsInteger2(type) ? type : IsLiteral(type) ? type : IsNull3(type) ? type : IsNumber3(type) ? type : IsString3(type) ? type : IsSymbol3(type) ? type : IsUndefined3(type) ? type : (
         // Passthrough
         Object2({})
       )
@@ -2327,14 +2296,14 @@ function Required(type, options) {
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
-function FromProperties19(P, options) {
+function FromProperties18(P, options) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(P))
     Acc[K2] = Required(P[K2], options);
   return Acc;
 }
 function FromMappedResult12(R, options) {
-  return FromProperties19(R.properties, options);
+  return FromProperties18(R.properties, options);
 }
 function RequiredFromMappedResult(R, options) {
   const P = FromMappedResult12(R, options);
@@ -2344,11 +2313,11 @@ function RequiredFromMappedResult(R, options) {
 // ../../node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
 function DereferenceParameters(moduleProperties, types) {
   return types.map((type) => {
-    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
+    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType(moduleProperties, type);
   });
 }
 function Dereference(moduleProperties, ref) {
-  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType(moduleProperties, moduleProperties[ref]) : Never();
 }
 function FromAwaited(parameters) {
   return Awaited(parameters[0]);
@@ -2375,31 +2344,31 @@ function FromComputed5(moduleProperties, target, parameters) {
   const dereferenced = DereferenceParameters(moduleProperties, parameters);
   return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
 }
-function FromArray6(moduleProperties, type) {
-  return Array2(FromType2(moduleProperties, type));
+function FromArray5(moduleProperties, type) {
+  return Array2(FromType(moduleProperties, type));
 }
-function FromAsyncIterator3(moduleProperties, type) {
-  return AsyncIterator(FromType2(moduleProperties, type));
+function FromAsyncIterator2(moduleProperties, type) {
+  return AsyncIterator(FromType(moduleProperties, type));
 }
-function FromConstructor3(moduleProperties, parameters, instanceType) {
-  return Constructor(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, instanceType));
+function FromConstructor2(moduleProperties, parameters, instanceType) {
+  return Constructor(FromTypes(moduleProperties, parameters), FromType(moduleProperties, instanceType));
 }
-function FromFunction3(moduleProperties, parameters, returnType) {
-  return Function(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, returnType));
+function FromFunction2(moduleProperties, parameters, returnType) {
+  return Function(FromTypes(moduleProperties, parameters), FromType(moduleProperties, returnType));
 }
-function FromIntersect8(moduleProperties, types) {
-  return Intersect(FromTypes2(moduleProperties, types));
+function FromIntersect7(moduleProperties, types) {
+  return Intersect(FromTypes(moduleProperties, types));
 }
-function FromIterator3(moduleProperties, type) {
-  return Iterator(FromType2(moduleProperties, type));
+function FromIterator2(moduleProperties, type) {
+  return Iterator(FromType(moduleProperties, type));
 }
-function FromObject7(moduleProperties, properties) {
+function FromObject6(moduleProperties, properties) {
   return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
-    return { ...result, [key]: FromType2(moduleProperties, properties[key]) };
+    return { ...result, [key]: FromType(moduleProperties, properties[key]) };
   }, {}));
 }
-function FromRecord3(moduleProperties, type) {
-  const [value, pattern] = [FromType2(moduleProperties, RecordValue2(type)), RecordPattern(type)];
+function FromRecord2(moduleProperties, type) {
+  const [value, pattern] = [FromType(moduleProperties, RecordValue2(type)), RecordPattern(type)];
   const result = CloneType(type);
   result.patternProperties[pattern] = value;
   return result;
@@ -2407,29 +2376,29 @@ function FromRecord3(moduleProperties, type) {
 function FromTransform(moduleProperties, transform) {
   return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
 }
-function FromTuple5(moduleProperties, types) {
-  return Tuple(FromTypes2(moduleProperties, types));
+function FromTuple4(moduleProperties, types) {
+  return Tuple(FromTypes(moduleProperties, types));
 }
-function FromUnion10(moduleProperties, types) {
-  return Union(FromTypes2(moduleProperties, types));
+function FromUnion9(moduleProperties, types) {
+  return Union(FromTypes(moduleProperties, types));
 }
-function FromTypes2(moduleProperties, types) {
-  return types.map((type) => FromType2(moduleProperties, type));
+function FromTypes(moduleProperties, types) {
+  return types.map((type) => FromType(moduleProperties, type));
 }
-function FromType2(moduleProperties, type) {
+function FromType(moduleProperties, type) {
   return (
     // Modifiers
-    IsOptional(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
+    IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
       // Transform
       IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : (
         // Types
-        IsArray3(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator3(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor3(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator3(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject7(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord3(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple5(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion10(moduleProperties, type.anyOf), type) : type
+        IsArray3(type) ? CreateType(FromArray5(moduleProperties, type.items), type) : IsAsyncIterator3(type) ? CreateType(FromAsyncIterator2(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor2(moduleProperties, type.parameters, type.returns), type) : IsFunction3(type) ? CreateType(FromFunction2(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect7(moduleProperties, type.allOf), type) : IsIterator3(type) ? CreateType(FromIterator2(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject6(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord2(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple4(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion9(moduleProperties, type.anyOf), type) : type
       )
     )
   );
 }
 function ComputeType(moduleProperties, key) {
-  return key in moduleProperties ? FromType2(moduleProperties, moduleProperties[key]) : Never();
+  return key in moduleProperties ? FromType(moduleProperties, moduleProperties[key]) : Never();
 }
 function ComputeModuleProperties(moduleProperties) {
   return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
@@ -2460,32 +2429,21 @@ function Module(properties) {
   return new TModule(properties);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
-function Not(type, options) {
-  return CreateType({ [Kind]: "Not", not: type }, options);
-}
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
-function Parameters(schema, options) {
-  return IsFunction2(schema) ? Tuple(schema.parameters, options) : Never();
+// ../../node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
+function ReadonlyOptional(schema) {
+  return Readonly(Optional(schema));
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
 var Ordinal = 0;
 function Recursive(callback, options = {}) {
-  if (IsUndefined(options.$id))
+  if (IsUndefined2(options.$id))
     options.$id = `T${Ordinal++}`;
   const thisType = CloneType(callback({ [Kind]: "This", $ref: `${options.$id}` }));
   thisType.$id = options.$id;
   return CreateType({ [Hint]: "Recursive", ...thisType }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
-function RegExp2(unresolved, options) {
-  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
-}
-
 // ../../node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
 function RestResolve(T) {
   return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
@@ -2494,11 +2452,6 @@ function Rest(T) {
   return RestResolve(T);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
-function ReturnType(schema, options) {
-  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
-}
-
 // ../../node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
 var TransformDecodeBuilder = class {
   constructor(schema) {
@@ -2536,11 +2489,6 @@ function Unsafe(options = {}) {
   return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
-function Void(options) {
-  return CreateType({ [Kind]: "Void", type: "void" }, options);
-}
-
 // ../../node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
 var type_exports2 = {};
 __export(type_exports2, {
@@ -2593,7 +2541,7 @@ __export(type_exports2, {
   Required: () => Required,
   Rest: () => Rest,
   ReturnType: () => ReturnType,
-  String: () => String2,
+  String: () => String,
   Symbol: () => Symbol2,
   TemplateLiteral: () => TemplateLiteral,
   Transform: () => Transform,
@@ -2608,146 +2556,163 @@ __export(type_exports2, {
   Void: () => Void
 });
 
+// ../../node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
+function Argument(index) {
+  return CreateType({ [Kind]: "Argument", index });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
+function ConstructorParameters(schema, options) {
+  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
+function InstanceType(schema, options) {
+  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
+function FromConstructor3(args, type) {
+  type.parameters = FromTypes2(args, type.parameters);
+  type.returns = FromType2(args, type.returns);
+  return type;
+}
+function FromFunction3(args, type) {
+  type.parameters = FromTypes2(args, type.parameters);
+  type.returns = FromType2(args, type.returns);
+  return type;
+}
+function FromIntersect8(args, type) {
+  type.allOf = FromTypes2(args, type.allOf);
+  return type;
+}
+function FromUnion10(args, type) {
+  type.anyOf = FromTypes2(args, type.anyOf);
+  return type;
+}
+function FromTuple5(args, type) {
+  if (IsUndefined2(type.items))
+    return type;
+  type.items = FromTypes2(args, type.items);
+  return type;
+}
+function FromArray6(args, type) {
+  type.items = FromType2(args, type.items);
+  return type;
+}
+function FromAsyncIterator3(args, type) {
+  type.items = FromType2(args, type.items);
+  return type;
+}
+function FromIterator3(args, type) {
+  type.items = FromType2(args, type.items);
+  return type;
+}
+function FromPromise3(args, type) {
+  type.item = FromType2(args, type.item);
+  return type;
+}
+function FromObject7(args, type) {
+  const mappedProperties = FromProperties19(args, type.properties);
+  return { ...type, ...Object2(mappedProperties) };
+}
+function FromRecord3(args, type) {
+  const mappedKey = FromType2(args, RecordKey2(type));
+  const mappedValue = FromType2(args, RecordValue2(type));
+  const result = Record(mappedKey, mappedValue);
+  return { ...type, ...result };
+}
+function FromArgument(args, argument) {
+  return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty3(args, type) {
+  const isReadonly = IsReadonly(type);
+  const isOptional = IsOptional(type);
+  const mapped = FromType2(args, type);
+  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties19(args, properties) {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: FromProperty3(args, properties[key]) };
+  }, {});
+}
+function FromTypes2(args, types) {
+  return types.map((type) => FromType2(args, type));
+}
+function FromType2(args, type) {
+  return IsConstructor(type) ? FromConstructor3(args, type) : IsFunction3(type) ? FromFunction3(args, type) : IsIntersect(type) ? FromIntersect8(args, type) : IsUnion(type) ? FromUnion10(args, type) : IsTuple(type) ? FromTuple5(args, type) : IsArray3(type) ? FromArray6(args, type) : IsAsyncIterator3(type) ? FromAsyncIterator3(args, type) : IsIterator3(type) ? FromIterator3(args, type) : IsPromise2(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject7(args, type) : IsRecord(type) ? FromRecord3(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+}
+function Instantiate(type, args) {
+  return FromType2(args, CloneType(type));
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
+function Parameters(schema, options) {
+  return IsFunction3(schema) ? Tuple(schema.parameters, options) : Never();
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
+function RegExp2(unresolved, options) {
+  const expr = IsString2(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
+function ReturnType(schema, options) {
+  return IsFunction3(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
+}
+
 // ../../node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
 var Type = type_exports2;
 
-// builtin/extensions/questionnaire/index.ts
-var QuestionnaireParams = Type.Object({
-  prompt: Type.String({
-    description: "REQUIRED: The question text to display to the user (e.g., 'What is your favorite color?')"
-  }),
-  options: Type.Array(
-    Type.String({ description: "An option label" }),
-    { description: "REQUIRED: Array of option strings (e.g., ['Red', 'Blue', 'Green']). Must have at least 2 items." }
-  ),
-  allowOther: Type.Optional(Type.Boolean({
-    description: "Whether to show '\u270F\uFE0F Other' option for custom input (default: true)",
-    default: true
-  }))
-});
-function questionnaireExtension(ctx) {
-  ctx.log("Questionnaire extension loaded");
-  ctx.registerTool({
-    name: "questionnaire",
-    label: "Questionnaire",
-    description: `INTERACTIVE QUESTION TOOL - Ask the user a multiple-choice question with optional "Other" input.
-
-WHEN TO USE:
-- Asking the user to choose from multiple options
-- Getting user confirmation (Yes/No)
-- Interactive questionnaires or surveys
-- When you need a definitive answer from the user
-
-FEATURES:
-- Auto "\u270F\uFE0F Other" option (default: true) - user can type custom answer
-- Arrow key navigation (up/down)
-- Letter shortcuts (A, B, C...)
-
-PARAMETERS:
-- prompt: Question text (required)
-- options: Array of options, min 2 items (required)
-- allowOther: Show "Other" option (default: true)
-
-EXAMPLES:
-1. With auto "Other":
-   {"prompt": "Favorite color?", "options": ["Red", "Blue"]}
-   \u2192 Shows: A. Red, B. Blue, C. \u270F\uFE0F Other
-
-2. Yes/No only:
-   {"prompt": "Proceed?", "options": ["Yes", "No"], "allowOther": false}
-
-3. Multiple questions (call tool multiple times):
-   Q1: {"prompt": "Language?", "options": ["Python", "JS"]}
-   Q2: {"prompt": "Framework?", "options": ["React", "Vue"]}`,
-    parameters: QuestionnaireParams,
-    async execute(args) {
-      ctx.log(`[questionnaire] Called with args: ${JSON.stringify(args)}`);
-      const { prompt, options, allowOther = true } = args;
-      if (!prompt || typeof prompt !== "string") {
-        return {
-          content: [{
-            type: "text",
-            text: "Error: 'prompt' parameter is required and must be a string. Example: prompt: 'What is your favorite color?'"
-          }],
-          isError: true
-        };
-      }
-      if (!Array.isArray(options) || options.length < 2) {
-        return {
-          content: [{
-            type: "text",
-            text: "Error: 'options' parameter is required and must be an array with at least 2 items. Example: options: ['Red', 'Blue', 'Green']"
-          }],
-          isError: true
-        };
-      }
-      if (!ctx.hasUI) {
-        const otherText = allowOther ? " / Other" : "";
-        return {
-          content: [{
-            type: "text",
-            text: `${prompt}
-Options: ${options.join(", ")}${otherText}
-
-Please reply with your choice.`
-          }],
-          isError: false
-        };
-      }
-      let displayOptions = [...options];
-      if (allowOther !== false) {
-        displayOptions.push("\u270F\uFE0F Other (type your own)");
-      }
-      const optionLabels = displayOptions.map(
-        (opt, idx) => `${String.fromCharCode(65 + idx)}. ${opt}`
-      );
-      const selection = await ctx.ui.select(prompt, optionLabels);
-      if (selection === void 0) {
-        return {
-          content: [{ type: "text", text: "User cancelled the questionnaire" }],
-          details: { cancelled: true }
-        };
-      }
-      const selectedIndex = optionLabels.indexOf(selection);
-      const selectedValue = displayOptions[selectedIndex];
-      if (selectedValue === "\u270F\uFE0F Other (type your own)") {
-        const customAnswer = await ctx.ui.input(`${prompt} (Other)`, "Please specify...");
-        if (customAnswer === void 0) {
-          return {
-            content: [{ type: "text", text: "User cancelled" }],
-            details: { cancelled: true }
-          };
-        }
-        return {
-          content: [{
-            type: "text",
-            text: `Other: ${customAnswer}`
-          }],
-          details: {
-            prompt,
-            selectedValue: customAnswer,
-            isOther: true,
-            cancelled: false
-          }
-        };
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `${String.fromCharCode(65 + selectedIndex)}. ${selectedValue}`
-        }],
-        details: {
-          prompt,
-          selectedValue,
-          selectedIndex: selectedIndex + 1,
-          isOther: false,
-          cancelled: false
-        }
-      };
-    }
-  });
-  ctx.ui.notify("\u2753 Questionnaire extension loaded", "info");
-}
 export {
-  questionnaireExtension as default
+  IsAsyncIterator,
+  IsIterator,
+  IsStandardObject,
+  IsPromise,
+  IsDate,
+  IsMap,
+  IsSet,
+  IsTypedArray,
+  IsUint8Array,
+  HasPropertyKey,
+  IsObject,
+  IsArray,
+  IsUndefined,
+  IsNull,
+  IsBoolean,
+  IsNumber,
+  IsInteger,
+  IsBigInt,
+  IsString,
+  IsFunction,
+  IsSymbol,
+  IsValueType,
+  TypeSystemPolicy,
+  TypeBoxError,
+  TransformKind,
+  Kind,
+  IsTransform,
+  IsUndefined3 as IsUndefined2,
+  IsKind,
+  IsSchema,
+  IsSchema2,
+  Never,
+  Union,
+  IsTemplateLiteralFinite,
+  TemplateLiteralGenerate,
+  Literal,
+  String,
+  IndexFromPropertyKeys,
+  Object2 as Object,
+  Ref,
+  KeyOfPropertyKeys,
+  KeyOfPattern,
+  Unknown,
+  Type
 };