@peninsula-med/beisen-ehr-plugin 1.0.6 → 1.1.1

package/dist/index.cjs.js

@@ -2,9 +2,3456 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fs = require('fs');
-var path = require('path');
-var os = require('os');
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator$2(value) {
+    return IsObject$2(value) && !IsArray$2(value) && !IsUint8Array$2(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an array */
+function IsArray$2(value) {
+    return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt$2(value) {
+    return typeof value === 'bigint';
+}
+/** Returns true if this value is a boolean */
+function IsBoolean$2(value) {
+    return typeof value === 'boolean';
+}
+/** Returns true if this value is a Date object */
+function IsDate$2(value) {
+    return value instanceof globalThis.Date;
+}
+/** Returns true if this value is a function */
+function IsFunction$2(value) {
+    return typeof value === 'function';
+}
+/** Returns true if this value is an iterator */
+function IsIterator$2(value) {
+    return IsObject$2(value) && !IsArray$2(value) && !IsUint8Array$2(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+function IsNull$2(value) {
+    return value === null;
+}
+/** Returns true if this value is number */
+function IsNumber$2(value) {
+    return typeof value === 'number';
+}
+/** Returns true if this value is an object */
+function IsObject$2(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Returns true if this value is RegExp */
+function IsRegExp$2(value) {
+    return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is string */
+function IsString$2(value) {
+    return typeof value === 'string';
+}
+/** Returns true if this value is symbol */
+function IsSymbol$2(value) {
+    return typeof value === 'symbol';
+}
+/** Returns true if this value is a Uint8Array */
+function IsUint8Array$2(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if this value is undefined */
+function IsUndefined$2(value) {
+    return value === undefined;
+}
+
+function ArrayType(value) {
+    return value.map((value) => Visit$2(value));
+}
+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$2(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Visit$2(value[key]);
+    }
+    return result;
+}
+// prettier-ignore
+function Visit$2(value) {
+    return (IsArray$2(value) ? ArrayType(value) :
+        IsDate$2(value) ? DateType(value) :
+            IsUint8Array$2(value) ? Uint8ArrayType(value) :
+                IsRegExp$2(value) ? RegExpType(value) :
+                    IsObject$2(value) ? ObjectType(value) :
+                        value);
+}
+/** Clones a value */
+function Clone(value) {
+    return Visit$2(value);
+}
+
+/** Clones a Rest */
+function CloneRest(schemas) {
+    return schemas.map((schema) => CloneType(schema));
+}
+/** Clones a Type */
+function CloneType(schema, options = {}) {
+    return { ...Clone(schema), ...options };
+}
+
+/** The base Error type thrown for all TypeBox exceptions  */
+class TypeBoxError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+
+/** Symbol key applied to transform types */
+const TransformKind = Symbol.for('TypeBox.Transform');
+/** Symbol key applied to readonly types */
+const ReadonlyKind = Symbol.for('TypeBox.Readonly');
+/** Symbol key applied to optional types */
+const OptionalKind = Symbol.for('TypeBox.Optional');
+/** Symbol key applied to types */
+const Hint = Symbol.for('TypeBox.Hint');
+/** Symbol key applied to types */
+const Kind = Symbol.for('TypeBox.Kind');
+
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+function IsReadonly(value) {
+    return IsObject$2(value) && value[ReadonlyKind] === 'Readonly';
+}
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+function IsOptional$1(value) {
+    return IsObject$2(value) && value[OptionalKind] === 'Optional';
+}
+/** `[Kind-Only]` Returns true if the given value is TAny */
+function IsAny$1(value) {
+    return IsKindOf$1(value, 'Any');
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+function IsArray$1(value) {
+    return IsKindOf$1(value, 'Array');
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator$1(value) {
+    return IsKindOf$1(value, 'AsyncIterator');
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+function IsBigInt$1(value) {
+    return IsKindOf$1(value, 'BigInt');
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+function IsBoolean$1(value) {
+    return IsKindOf$1(value, 'Boolean');
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+function IsConstructor$1(value) {
+    return IsKindOf$1(value, 'Constructor');
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+function IsDate$1(value) {
+    return IsKindOf$1(value, 'Date');
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+function IsFunction$1(value) {
+    return IsKindOf$1(value, 'Function');
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsInteger$1(value) {
+    return IsKindOf$1(value, 'Integer');
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+function IsIntersect$1(value) {
+    return IsKindOf$1(value, 'Intersect');
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+function IsIterator$1(value) {
+    return IsKindOf$1(value, 'Iterator');
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+function IsKindOf$1(value, kind) {
+    return IsObject$2(value) && Kind in value && value[Kind] === kind;
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+function IsLiteral$1(value) {
+    return IsKindOf$1(value, 'Literal');
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+function IsMappedKey$1(value) {
+    return IsKindOf$1(value, 'MappedKey');
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+function IsMappedResult$1(value) {
+    return IsKindOf$1(value, 'MappedResult');
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+function IsNever$1(value) {
+    return IsKindOf$1(value, 'Never');
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+function IsNot$1(value) {
+    return IsKindOf$1(value, 'Not');
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+function IsNull$1(value) {
+    return IsKindOf$1(value, 'Null');
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+function IsNumber$1(value) {
+    return IsKindOf$1(value, 'Number');
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+function IsObject$1(value) {
+    return IsKindOf$1(value, 'Object');
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+function IsPromise$1(value) {
+    return IsKindOf$1(value, 'Promise');
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+function IsRecord$1(value) {
+    return IsKindOf$1(value, 'Record');
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+function IsRef$1(value) {
+    return IsKindOf$1(value, 'Ref');
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+function IsRegExp$1(value) {
+    return IsKindOf$1(value, 'RegExp');
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+function IsString$1(value) {
+    return IsKindOf$1(value, 'String');
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+function IsSymbol$1(value) {
+    return IsKindOf$1(value, 'Symbol');
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral$1(value) {
+    return IsKindOf$1(value, 'TemplateLiteral');
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+function IsThis$1(value) {
+    return IsKindOf$1(value, 'This');
+}
+/** `[Kind-Only]` Returns true of this value is TTransform */
+function IsTransform$1(value) {
+    return IsObject$2(value) && TransformKind in value;
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+function IsTuple$1(value) {
+    return IsKindOf$1(value, 'Tuple');
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+function IsUndefined$1(value) {
+    return IsKindOf$1(value, 'Undefined');
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+function IsUnion$1(value) {
+    return IsKindOf$1(value, 'Union');
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+function IsUint8Array$1(value) {
+    return IsKindOf$1(value, 'Uint8Array');
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+function IsUnknown$1(value) {
+    return IsKindOf$1(value, 'Unknown');
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+function IsUnsafe$1(value) {
+    return IsKindOf$1(value, 'Unsafe');
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+function IsVoid$1(value) {
+    return IsKindOf$1(value, 'Void');
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+function IsKind$1(value) {
+    return IsObject$2(value) && Kind in value && IsString$2(value[Kind]);
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+function IsSchema$1(value) {
+    // prettier-ignore
+    return (IsAny$1(value) ||
+        IsArray$1(value) ||
+        IsBoolean$1(value) ||
+        IsBigInt$1(value) ||
+        IsAsyncIterator$1(value) ||
+        IsConstructor$1(value) ||
+        IsDate$1(value) ||
+        IsFunction$1(value) ||
+        IsInteger$1(value) ||
+        IsIntersect$1(value) ||
+        IsIterator$1(value) ||
+        IsLiteral$1(value) ||
+        IsMappedKey$1(value) ||
+        IsMappedResult$1(value) ||
+        IsNever$1(value) ||
+        IsNot$1(value) ||
+        IsNull$1(value) ||
+        IsNumber$1(value) ||
+        IsObject$1(value) ||
+        IsPromise$1(value) ||
+        IsRecord$1(value) ||
+        IsRef$1(value) ||
+        IsRegExp$1(value) ||
+        IsString$1(value) ||
+        IsSymbol$1(value) ||
+        IsTemplateLiteral$1(value) ||
+        IsThis$1(value) ||
+        IsTuple$1(value) ||
+        IsUndefined$1(value) ||
+        IsUnion$1(value) ||
+        IsUint8Array$1(value) ||
+        IsUnknown$1(value) ||
+        IsUnsafe$1(value) ||
+        IsVoid$1(value) ||
+        IsKind$1(value));
+}
+
+const KnownTypes = [
+    'Any',
+    'Array',
+    'AsyncIterator',
+    'BigInt',
+    'Boolean',
+    '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$2(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) || IsSchema(value);
+}
+function IsOptionalBigInt(value) {
+    return IsUndefined$2(value) || IsBigInt$2(value);
+}
+function IsOptionalNumber(value) {
+    return IsUndefined$2(value) || IsNumber$2(value);
+}
+function IsOptionalBoolean(value) {
+    return IsUndefined$2(value) || IsBoolean$2(value);
+}
+function IsOptionalString(value) {
+    return IsUndefined$2(value) || IsString$2(value);
+}
+function IsOptionalPattern(value) {
+    return IsUndefined$2(value) || (IsString$2(value) && IsControlCharacterFree(value) && IsPattern(value));
+}
+function IsOptionalFormat(value) {
+    return IsUndefined$2(value) || (IsString$2(value) && IsControlCharacterFree(value));
+}
+function IsOptionalSchema(value) {
+    return IsUndefined$2(value) || IsSchema(value);
+}
+/** Returns true if this value has a Optional symbol */
+function IsOptional(value) {
+    return IsObject$2(value) && value[OptionalKind] === 'Optional';
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
+function IsAny(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Any') &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TArray */
+function IsArray(value) {
+    return (IsKindOf(value, 'Array') &&
+        value.type === 'array' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.items) &&
+        IsOptionalNumber(value.minItems) &&
+        IsOptionalNumber(value.maxItems) &&
+        IsOptionalBoolean(value.uniqueItems) &&
+        IsOptionalSchema(value.contains) &&
+        IsOptionalNumber(value.minContains) &&
+        IsOptionalNumber(value.maxContains));
+}
+/** Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'AsyncIterator') &&
+        value.type === 'AsyncIterator' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.items));
+}
+/** Returns true if the given value is TBigInt */
+function IsBigInt(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'BigInt') &&
+        value.type === 'bigint' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalBigInt(value.exclusiveMaximum) &&
+        IsOptionalBigInt(value.exclusiveMinimum) &&
+        IsOptionalBigInt(value.maximum) &&
+        IsOptionalBigInt(value.minimum) &&
+        IsOptionalBigInt(value.multipleOf));
+}
+/** Returns true if the given value is TBoolean */
+function IsBoolean(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Boolean') &&
+        value.type === 'boolean' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TConstructor */
+function IsConstructor(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Constructor') &&
+        value.type === 'Constructor' &&
+        IsOptionalString(value.$id) &&
+        IsArray$2(value.parameters) &&
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
+}
+/** Returns true if the given value is TDate */
+function IsDate(value) {
+    return (IsKindOf(value, 'Date') &&
+        value.type === 'Date' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
+        IsOptionalNumber(value.exclusiveMinimumTimestamp) &&
+        IsOptionalNumber(value.maximumTimestamp) &&
+        IsOptionalNumber(value.minimumTimestamp) &&
+        IsOptionalNumber(value.multipleOfTimestamp));
+}
+/** Returns true if the given value is TFunction */
+function IsFunction(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Function') &&
+        value.type === 'Function' &&
+        IsOptionalString(value.$id) &&
+        IsArray$2(value.parameters) &&
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
+}
+/** Returns true if the given value is TInteger */
+function IsInteger(value) {
+    return (IsKindOf(value, 'Integer') &&
+        value.type === 'integer' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximum) &&
+        IsOptionalNumber(value.exclusiveMinimum) &&
+        IsOptionalNumber(value.maximum) &&
+        IsOptionalNumber(value.minimum) &&
+        IsOptionalNumber(value.multipleOf));
+}
+/** Returns true if the given schema is TProperties */
+function IsProperties(value) {
+    // prettier-ignore
+    return (IsObject$2(value) &&
+        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema)));
+}
+/** Returns true if the given value is TIntersect */
+function IsIntersect(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Intersect') &&
+        (IsString$2(value.type) && value.type !== 'object' ? false : true) &&
+        IsArray$2(value.allOf) &&
+        value.allOf.every(schema => IsSchema(schema) && !IsTransform(schema)) &&
+        IsOptionalString(value.type) &&
+        (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TIterator */
+function IsIterator(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Iterator') &&
+        value.type === 'Iterator' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.items));
+}
+/** Returns true if the given value is a TKind with the given name. */
+function IsKindOf(value, kind) {
+    return IsObject$2(value) && Kind in value && value[Kind] === kind;
+}
+/** Returns true if the given value is TLiteral<string> */
+function IsLiteralString(value) {
+    return IsLiteral(value) && IsString$2(value.const);
+}
+/** Returns true if the given value is TLiteral<number> */
+function IsLiteralNumber(value) {
+    return IsLiteral(value) && IsNumber$2(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean> */
+function IsLiteralBoolean(value) {
+    return IsLiteral(value) && IsBoolean$2(value.const);
+}
+/** Returns true if the given value is TLiteral */
+function IsLiteral(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Literal') &&
+        IsOptionalString(value.$id) && IsLiteralValue(value.const));
+}
+/** Returns true if the given value is a TLiteralValue */
+function IsLiteralValue(value) {
+    return IsBoolean$2(value) || IsNumber$2(value) || IsString$2(value);
+}
+/** Returns true if the given value is a TMappedKey */
+function IsMappedKey(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'MappedKey') &&
+        IsArray$2(value.keys) &&
+        value.keys.every(key => IsNumber$2(key) || IsString$2(key)));
+}
+/** Returns true if the given value is TMappedResult */
+function IsMappedResult(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'MappedResult') &&
+        IsProperties(value.properties));
+}
+/** Returns true if the given value is TNever */
+function IsNever(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Never') &&
+        IsObject$2(value.not) &&
+        Object.getOwnPropertyNames(value.not).length === 0);
+}
+/** Returns true if the given value is TNot */
+function IsNot(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Not') &&
+        IsSchema(value.not));
+}
+/** Returns true if the given value is TNull */
+function IsNull(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Null') &&
+        value.type === 'null' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TNumber */
+function IsNumber(value) {
+    return (IsKindOf(value, 'Number') &&
+        value.type === 'number' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximum) &&
+        IsOptionalNumber(value.exclusiveMinimum) &&
+        IsOptionalNumber(value.maximum) &&
+        IsOptionalNumber(value.minimum) &&
+        IsOptionalNumber(value.multipleOf));
+}
+/** Returns true if the given value is TObject */
+function IsObject(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Object') &&
+        value.type === 'object' &&
+        IsOptionalString(value.$id) &&
+        IsProperties(value.properties) &&
+        IsAdditionalProperties(value.additionalProperties) &&
+        IsOptionalNumber(value.minProperties) &&
+        IsOptionalNumber(value.maxProperties));
+}
+/** Returns true if the given value is TPromise */
+function IsPromise(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Promise') &&
+        value.type === 'Promise' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.item));
+}
+/** Returns true if the given value is TRecord */
+function IsRecord(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Record') &&
+        value.type === 'object' &&
+        IsOptionalString(value.$id) &&
+        IsAdditionalProperties(value.additionalProperties) &&
+        IsObject$2(value.patternProperties) &&
+        ((schema) => {
+            const keys = Object.getOwnPropertyNames(schema.patternProperties);
+            return (keys.length === 1 &&
+                IsPattern(keys[0]) &&
+                IsObject$2(schema.patternProperties) &&
+                IsSchema(schema.patternProperties[keys[0]]));
+        })(value));
+}
+/** Returns true if the given value is TRef */
+function IsRef(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Ref') &&
+        IsOptionalString(value.$id) &&
+        IsString$2(value.$ref));
+}
+/** Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'RegExp') &&
+        IsOptionalString(value.$id) &&
+        IsString$2(value.source) &&
+        IsString$2(value.flags) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalNumber(value.minLength));
+}
+/** Returns true if the given value is TString */
+function IsString(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'String') &&
+        value.type === 'string' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.minLength) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalPattern(value.pattern) &&
+        IsOptionalFormat(value.format));
+}
+/** Returns true if the given value is TSymbol */
+function IsSymbol(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Symbol') &&
+        value.type === 'symbol' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'TemplateLiteral') &&
+        value.type === 'string' &&
+        IsString$2(value.pattern) &&
+        value.pattern[0] === '^' &&
+        value.pattern[value.pattern.length - 1] === '$');
+}
+/** Returns true if the given value is TThis */
+function IsThis(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'This') &&
+        IsOptionalString(value.$id) &&
+        IsString$2(value.$ref));
+}
+/** Returns true of this value is TTransform */
+function IsTransform(value) {
+    return IsObject$2(value) && TransformKind in value;
+}
+/** Returns true if the given value is TTuple */
+function IsTuple(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Tuple') &&
+        value.type === 'array' &&
+        IsOptionalString(value.$id) &&
+        IsNumber$2(value.minItems) &&
+        IsNumber$2(value.maxItems) &&
+        value.minItems === value.maxItems &&
+        (( // empty
+        IsUndefined$2(value.items) &&
+            IsUndefined$2(value.additionalItems) &&
+            value.minItems === 0) || (IsArray$2(value.items) &&
+            value.items.every(schema => IsSchema(schema)))));
+}
+/** Returns true if the given value is TUndefined */
+function IsUndefined(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Undefined') &&
+        value.type === 'undefined' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TUnion */
+function IsUnion(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Union') &&
+        IsOptionalString(value.$id) &&
+        IsObject$2(value) &&
+        IsArray$2(value.anyOf) &&
+        value.anyOf.every(schema => IsSchema(schema)));
+}
+/** Returns true if the given value is TUint8Array */
+function IsUint8Array(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Uint8Array') &&
+        value.type === 'Uint8Array' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.minByteLength) &&
+        IsOptionalNumber(value.maxByteLength));
+}
+/** Returns true if the given value is TUnknown */
+function IsUnknown(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Unknown') &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is a raw TUnsafe */
+function IsUnsafe(value) {
+    return IsKindOf(value, 'Unsafe');
+}
+/** Returns true if the given value is TVoid */
+function IsVoid(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Void') &&
+        value.type === 'void' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TKind */
+function IsKind(value) {
+    return IsObject$2(value) && Kind in value && IsString$2(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+/** Returns true if the given value is TSchema */
+function IsSchema(value) {
+    // prettier-ignore
+    return (IsObject$2(value)) && (IsAny(value) ||
+        IsArray(value) ||
+        IsBoolean(value) ||
+        IsBigInt(value) ||
+        IsAsyncIterator(value) ||
+        IsConstructor(value) ||
+        IsDate(value) ||
+        IsFunction(value) ||
+        IsInteger(value) ||
+        IsIntersect(value) ||
+        IsIterator(value) ||
+        IsLiteral(value) ||
+        IsMappedKey(value) ||
+        IsMappedResult(value) ||
+        IsNever(value) ||
+        IsNot(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsObject(value) ||
+        IsPromise(value) ||
+        IsRecord(value) ||
+        IsRef(value) ||
+        IsRegExp(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsTemplateLiteral(value) ||
+        IsThis(value) ||
+        IsTuple(value) ||
+        IsUndefined(value) ||
+        IsUnion(value) ||
+        IsUint8Array(value) ||
+        IsUnknown(value) ||
+        IsUnsafe(value) ||
+        IsVoid(value) ||
+        IsKind(value));
+}
+
+const PatternBoolean = '(true|false)';
+const PatternNumber = '(0|[1-9][0-9]*)';
+const PatternString = '(.*)';
+const PatternNever = '(?!.*)';
+const PatternNumberExact = `^${PatternNumber}$`;
+const PatternStringExact = `^${PatternString}$`;
+const PatternNeverExact = `^${PatternNever}$`;
+
+/** Returns true if element right is in the set of left */
+// prettier-ignore
+function SetIncludes(T, S) {
+    return T.includes(S);
+}
+/** Returns a distinct set of elements */
+function SetDistinct(T) {
+    return [...new Set(T)];
+}
+/** Returns the Intersect of the given sets */
+function SetIntersect(T, S) {
+    return T.filter((L) => S.includes(L));
+}
+// prettier-ignore
+function SetIntersectManyResolve(T, Init) {
+    return T.reduce((Acc, L) => {
+        return SetIntersect(Acc, L);
+    }, Init);
+}
+// prettier-ignore
+function SetIntersectMany(T) {
+    return (T.length === 1
+        ? T[0]
+        // Use left to initialize the accumulator for resolve
+        : T.length > 1
+            ? SetIntersectManyResolve(T.slice(1), T[0])
+            : []);
+}
+/** Returns the Union of multiple sets */
+function SetUnionMany(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...L);
+    return Acc;
+}
+
+/** `[Json]` Creates an Any type */
+function Any(options = {}) {
+    return { ...options, [Kind]: 'Any' };
+}
+
+/** `[Json]` Creates an Array type */
+function Array$1(schema, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Array',
+        type: 'array',
+        items: CloneType(schema),
+    };
+}
+
+/** `[JavaScript]` Creates a AsyncIterator type */
+function AsyncIterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'AsyncIterator',
+        type: 'AsyncIterator',
+        items: CloneType(items),
+    };
+}
+
+function DiscardKey(value, key) {
+    const { [key]: _, ...rest } = value;
+    return rest;
+}
+function Discard(value, keys) {
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+
+/** `[Json]` Creates a Never type */
+function Never(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Never',
+        not: {},
+    };
+}
+
+// prettier-ignore
+function MappedResult(properties) {
+    return {
+        [Kind]: 'MappedResult',
+        properties
+    };
+}
+
+/** `[JavaScript]` Creates a Constructor type */
+function Constructor(parameters, returns, options) {
+    return {
+        ...options,
+        [Kind]: 'Constructor',
+        type: 'Constructor',
+        parameters: CloneRest(parameters),
+        returns: CloneType(returns),
+    };
+}
+
+/** `[JavaScript]` Creates a Function type */
+function Function(parameters, returns, options) {
+    return {
+        ...options,
+        [Kind]: 'Function',
+        type: 'Function',
+        parameters: CloneRest(parameters),
+        returns: CloneType(returns),
+    };
+}
+
+function UnionCreate(T, options) {
+    return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) };
+}
+
+// prettier-ignore
+function IsUnionOptional(T) {
+    return T.some(L => IsOptional$1(L));
+}
+// prettier-ignore
+function RemoveOptionalFromRest$1(T) {
+    return T.map(L => IsOptional$1(L) ? RemoveOptionalFromType$1(L) : L);
+}
+// prettier-ignore
+function RemoveOptionalFromType$1(T) {
+    return (Discard(T, [OptionalKind]));
+}
+// prettier-ignore
+function ResolveUnion(T, options) {
+    return (IsUnionOptional(T)
+        ? Optional(UnionCreate(RemoveOptionalFromRest$1(T), options))
+        : UnionCreate(RemoveOptionalFromRest$1(T), options));
+}
+/** `[Json]` Creates an evaluated Union type */
+function UnionEvaluated(T, options = {}) {
+    // prettier-ignore
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            ResolveUnion(T, options));
+}
+
+/** `[Json]` Creates a Union type */
+function Union(T, options = {}) {
+    // prettier-ignore
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            UnionCreate(T, options));
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
+class TemplateLiteralParserError extends TypeBoxError {
+}
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
+// prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
+function IsNonEscaped(pattern, index, char) {
+    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+    return IsNonEscaped(pattern, index, '(');
+}
+function IsCloseParen(pattern, index) {
+    return IsNonEscaped(pattern, index, ')');
+}
+function IsSeparator(pattern, index) {
+    return IsNonEscaped(pattern, index, '|');
+}
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
+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;
+}
+// prettier-ignore
+function InGroup(pattern) {
+    return pattern.slice(1, pattern.length - 1);
+}
+// prettier-ignore
+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;
+}
+// prettier-ignore
+function IsPrecedenceAnd(pattern) {
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+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 range = pattern.slice(start, index);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            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 };
+}
+// prettier-ignore
+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(pattern, index) {
+        for (let scan = index; scan < pattern.length; scan++) {
+            if (IsOpenParen(pattern, scan))
+                return [index, scan];
+        }
+        return [index, pattern.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 });
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
+/** Parses a pattern and returns an expression tree */
+function TemplateLiteralParse(pattern) {
+    // prettier-ignore
+    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+        IsPrecedenceOr(pattern) ? Or(pattern) :
+            IsPrecedenceAnd(pattern) ? And(pattern) :
+                { type: 'const', const: Unescape(pattern) });
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
+/** Parses a pattern and strips forward and trailing ^ and $ */
+function TemplateLiteralParseExact(pattern) {
+    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralFiniteError
+// ------------------------------------------------------------------
+class TemplateLiteralFiniteError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// IsTemplateLiteralFiniteCheck
+// ------------------------------------------------------------------
+// prettier-ignore
+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]*');
+}
+// prettier-ignore
+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');
+}
+// prettier-ignore
+function IsStringExpression(expression) {
+    return expression.type === 'const' && expression.const === '.*';
+}
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
+// prettier-ignore
+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`); })());
+}
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+function IsTemplateLiteralFinite(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+class TemplateLiteralGenerateError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
+// ------------------------------------------------------------------
+// prettier-ignore
+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}`;
+        }
+    }
+}
+// prettier-ignore
+function* GenerateAnd(expression) {
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+// prettier-ignore
+function* GenerateOr(expression) {
+    for (const expr of expression.expr)
+        yield* TemplateLiteralExpressionGenerate(expr);
+}
+// prettier-ignore
+function* GenerateConst(expression) {
+    return yield expression.const;
+}
+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');
+                })();
+}
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+function TemplateLiteralGenerate(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    // prettier-ignore
+    return (IsTemplateLiteralExpressionFinite(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}
+
+/** `[Json]` Creates a Literal type */
+function Literal(value, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Literal',
+        const: value,
+        type: typeof value,
+    };
+}
+
+/** `[Json]` Creates a Boolean type */
+function Boolean(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Boolean',
+        type: 'boolean',
+    };
+}
+
+/** `[JavaScript]` Creates a BigInt type */
+function BigInt(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'BigInt',
+        type: 'bigint',
+    };
+}
+
+/** `[Json]` Creates a Number type */
+function Number(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Number',
+        type: 'number',
+    };
+}
+
+/** `[Json]` Creates a String type */
+function String(options = {}) {
+    return { ...options, [Kind]: 'String', type: 'string' };
+}
+
+// ------------------------------------------------------------------
+// SyntaxParsers
+// ------------------------------------------------------------------
+// prettier-ignore
+function* FromUnion$8(syntax) {
+    const trim = syntax.trim().replace(/"|'/g, '');
+    return (trim === 'boolean' ? yield Boolean() :
+        trim === 'number' ? yield Number() :
+            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));
+                    })());
+}
+// prettier-ignore
+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$8(syntax.slice(2, i));
+            const R = FromSyntax(syntax.slice(i + 1));
+            return yield* [...L, ...R];
+        }
+    }
+    yield Literal(syntax);
+}
+// prettier-ignore
+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);
+}
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
+function TemplateLiteralSyntax(syntax) {
+    return [...FromSyntax(syntax)];
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
+class TemplateLiteralPatternError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
+function Escape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// prettier-ignore
+function Visit$1(schema, acc) {
+    return (IsTemplateLiteral$1(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+        IsUnion$1(schema) ? `(${schema.anyOf.map((schema) => Visit$1(schema, acc)).join('|')})` :
+            IsNumber$1(schema) ? `${acc}${PatternNumber}` :
+                IsInteger$1(schema) ? `${acc}${PatternNumber}` :
+                    IsBigInt$1(schema) ? `${acc}${PatternNumber}` :
+                        IsString$1(schema) ? `${acc}${PatternString}` :
+                            IsLiteral$1(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                IsBoolean$1(schema) ? `${acc}${PatternBoolean}` :
+                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`); })());
+}
+function TemplateLiteralPattern(kinds) {
+    return `^${kinds.map((schema) => Visit$1(schema, '')).join('')}\$`;
+}
+
+/** Returns a Union from the given TemplateLiteral */
+function TemplateLiteralToUnion(schema) {
+    const R = TemplateLiteralGenerate(schema);
+    const L = R.map((S) => Literal(S));
+    return UnionEvaluated(L);
+}
+
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
+function TemplateLiteral(unresolved, options = {}) {
+    const pattern = IsString$2(unresolved)
+        ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved))
+        : TemplateLiteralPattern(unresolved);
+    return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern };
+}
+
+// prettier-ignore
+function FromTemplateLiteral$2(T) {
+    const R = TemplateLiteralGenerate(T);
+    return R.map(S => S.toString());
+}
+// prettier-ignore
+function FromUnion$7(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexPropertyKeys(L));
+    return Acc;
+}
+// prettier-ignore
+function FromLiteral$1(T) {
+    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
+function IndexPropertyKeys(T) {
+    return [...new Set((IsTemplateLiteral$1(T) ? FromTemplateLiteral$2(T) :
+            IsUnion$1(T) ? FromUnion$7(T.anyOf) :
+                IsLiteral$1(T) ? FromLiteral$1(T.const) :
+                    IsNumber$1(T) ? ['[number]'] :
+                        IsInteger$1(T) ? ['[number]'] :
+                            []))];
+}
+
+// prettier-ignore
+function FromProperties$i(T, P, options) {
+    const Acc = {};
+    for (const K2 of Object.getOwnPropertyNames(P)) {
+        Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options);
+    }
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$b(T, R, options) {
+    return FromProperties$i(T, R.properties, options);
+}
+// prettier-ignore
+function IndexFromMappedResult(T, R, options) {
+    const P = FromMappedResult$b(T, R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function FromRest$7(T, K) {
+    return T.map(L => IndexFromPropertyKey(L, K));
+}
+// prettier-ignore
+function FromIntersectRest(T) {
+    return T.filter(L => !IsNever$1(L));
+}
+// prettier-ignore
+function FromIntersect$6(T, K) {
+    return (IntersectEvaluated(FromIntersectRest(FromRest$7(T, K))));
+}
+// prettier-ignore
+function FromUnionRest(T) {
+    return (T.some(L => IsNever$1(L))
+        ? []
+        : T);
+}
+// prettier-ignore
+function FromUnion$6(T, K) {
+    return (UnionEvaluated(FromUnionRest(FromRest$7(T, K))));
+}
+// prettier-ignore
+function FromTuple$3(T, K) {
+    return (K in T ? T[K] :
+        K === '[number]' ? UnionEvaluated(T) :
+            Never());
+}
+// prettier-ignore
+function FromArray$4(T, K) {
+    return (K === '[number]'
+        ? T
+        : Never());
+}
+// prettier-ignore
+function FromProperty$1(T, K) {
+    return (K in T ? T[K] : Never());
+}
+// prettier-ignore
+function IndexFromPropertyKey(T, K) {
+    return (IsIntersect$1(T) ? FromIntersect$6(T.allOf, K) :
+        IsUnion$1(T) ? FromUnion$6(T.anyOf, K) :
+            IsTuple$1(T) ? FromTuple$3(T.items ?? [], K) :
+                IsArray$1(T) ? FromArray$4(T.items, K) :
+                    IsObject$1(T) ? FromProperty$1(T.properties, K) :
+                        Never());
+}
+// prettier-ignore
+function IndexFromPropertyKeys(T, K) {
+    return K.map(L => IndexFromPropertyKey(T, L));
+}
+// prettier-ignore
+function FromSchema(T, K) {
+    return (UnionEvaluated(IndexFromPropertyKeys(T, K)));
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
+function Index(T, K, options = {}) {
+    // prettier-ignore
+    return (IsMappedResult$1(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
+        IsMappedKey$1(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
+            IsSchema$1(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
+                CloneType(FromSchema(T, K), options));
+}
+
+// prettier-ignore
+function MappedIndexPropertyKey(T, K, options) {
+    return { [K]: Index(T, [K], options) };
+}
+// prettier-ignore
+function MappedIndexPropertyKeys(T, K, options) {
+    return K.reduce((Acc, L) => {
+        return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIndexProperties(T, K, options) {
+    return MappedIndexPropertyKeys(T, K.keys, options);
+}
+// prettier-ignore
+function IndexFromMappedKey(T, K, options) {
+    const P = MappedIndexProperties(T, K, options);
+    return MappedResult(P);
+}
+
+/** `[JavaScript]` Creates an Iterator type */
+function Iterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Iterator',
+        type: 'Iterator',
+        items: CloneType(items),
+    };
+}
+
+/** `[Json]` Creates an Object type */
+function _Object(properties, options = {}) {
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+    const optionalKeys = propertyKeys.filter((key) => IsOptional$1(properties[key]));
+    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+    const clonedAdditionalProperties = IsSchema$1(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
+    const clonedProperties = {};
+    for (const key of propertyKeys)
+        clonedProperties[key] = CloneType(properties[key]);
+    return (requiredKeys.length > 0
+        ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
+        : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties });
+}
+/** `[Json]` Creates an Object type */
+const Object$1 = _Object;
+
+/** `[JavaScript]` Creates a Promise type */
+function Promise$1(item, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Promise',
+        type: 'Promise',
+        item: CloneType(item),
+    };
+}
+
+function RemoveReadonly(schema) {
+    return Discard(CloneType(schema), [ReadonlyKind]);
+}
+function AddReadonly(schema) {
+    return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' };
+}
+// prettier-ignore
+function ReadonlyWithFlag(schema, F) {
+    return (F === false
+        ? RemoveReadonly(schema)
+        : AddReadonly(schema));
+}
+/** `[Json]` Creates a Readonly property */
+function Readonly(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult$1(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+
+// prettier-ignore
+function FromProperties$h(K, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Readonly(K[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$a(R, F) {
+    return FromProperties$h(R.properties, F);
+}
+// prettier-ignore
+function ReadonlyFromMappedResult(R, F) {
+    const P = FromMappedResult$a(R, F);
+    return MappedResult(P);
+}
+
+/** `[Json]` Creates a Tuple type */
+function Tuple(items, options = {}) {
+    // return TupleResolver.Resolve(T)
+    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    // prettier-ignore
+    return (items.length > 0 ?
+        { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
+        { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems });
+}
+
+// prettier-ignore
+function FromMappedResult$9(K, P) {
+    return (K in P
+        ? FromSchemaType(K, P[K])
+        : MappedResult(P));
+}
+// prettier-ignore
+function MappedKeyToKnownMappedResultProperties(K) {
+    return { [K]: Literal(K) };
+}
+// prettier-ignore
+function MappedKeyToUnknownMappedResultProperties(P) {
+    const Acc = {};
+    for (const L of P)
+        Acc[L] = Literal(L);
+    return Acc;
+}
+// prettier-ignore
+function MappedKeyToMappedResultProperties(K, P) {
+    return (SetIncludes(P, K)
+        ? MappedKeyToKnownMappedResultProperties(K)
+        : MappedKeyToUnknownMappedResultProperties(P));
+}
+// prettier-ignore
+function FromMappedKey$3(K, P) {
+    const R = MappedKeyToMappedResultProperties(K, P);
+    return FromMappedResult$9(K, R);
+}
+// prettier-ignore
+function FromRest$6(K, T) {
+    return T.map(L => FromSchemaType(K, L));
+}
+// prettier-ignore
+function FromProperties$g(K, T) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K2] = FromSchemaType(K, T[K2]);
+    return Acc;
+}
+// prettier-ignore
+function FromSchemaType(K, T) {
+    return (
+    // unevaluated modifier types
+    IsOptional$1(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
+        IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) :
+            // unevaluated mapped types
+            IsMappedResult$1(T) ? FromMappedResult$9(K, T.properties) :
+                IsMappedKey$1(T) ? FromMappedKey$3(K, T.keys) :
+                    // unevaluated types
+                    IsConstructor$1(T) ? Constructor(FromRest$6(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        IsFunction$1(T) ? Function(FromRest$6(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            IsAsyncIterator$1(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
+                                IsIterator$1(T) ? Iterator(FromSchemaType(K, T.items)) :
+                                    IsIntersect$1(T) ? Intersect(FromRest$6(K, T.allOf)) :
+                                        IsUnion$1(T) ? Union(FromRest$6(K, T.anyOf)) :
+                                            IsTuple$1(T) ? Tuple(FromRest$6(K, T.items ?? [])) :
+                                                IsObject$1(T) ? Object$1(FromProperties$g(K, T.properties)) :
+                                                    IsArray$1(T) ? Array$1(FromSchemaType(K, T.items)) :
+                                                        IsPromise$1(T) ? Promise$1(FromSchemaType(K, T.item)) :
+                                                            T);
+}
+// prettier-ignore
+function MappedFunctionReturnType(K, T) {
+    const Acc = {};
+    for (const L of K)
+        Acc[L] = FromSchemaType(L, T);
+    return Acc;
+}
+/** `[Json]` Creates a Mapped object type */
+function Mapped(key, map, options = {}) {
+    const K = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
+    const RT = map({ [Kind]: 'MappedKey', keys: K });
+    const R = MappedFunctionReturnType(K, RT);
+    return CloneType(Object$1(R), options);
+}
+
+function RemoveOptional(schema) {
+    return Discard(CloneType(schema), [OptionalKind]);
+}
+function AddOptional(schema) {
+    return { ...CloneType(schema), [OptionalKind]: 'Optional' };
+}
+// prettier-ignore
+function OptionalWithFlag(schema, F) {
+    return (F === false
+        ? RemoveOptional(schema)
+        : AddOptional(schema));
+}
+/** `[Json]` Creates a Optional property */
+function Optional(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult$1(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+
+// prettier-ignore
+function FromProperties$f(P, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Optional(P[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$8(R, F) {
+    return FromProperties$f(R.properties, F);
+}
+// prettier-ignore
+function OptionalFromMappedResult(R, F) {
+    const P = FromMappedResult$8(R, F);
+    return MappedResult(P);
+}
+
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntersectCreate(T, options) {
+    const allObjects = T.every((schema) => IsObject$1(schema));
+    const clonedUnevaluatedProperties = IsSchema$1(options.unevaluatedProperties)
+        ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
+        : {};
+    return ((options.unevaluatedProperties === false || IsSchema$1(options.unevaluatedProperties) || allObjects
+        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
+        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
+}
+
+// prettier-ignore
+function IsIntersectOptional(T) {
+    return T.every(L => IsOptional$1(L));
+}
+// prettier-ignore
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+// prettier-ignore
+function RemoveOptionalFromRest(T) {
+    return T.map(L => IsOptional$1(L) ? RemoveOptionalFromType(L) : L);
+}
+// prettier-ignore
+function ResolveIntersect(T, options) {
+    return (IsIntersectOptional(T)
+        ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
+        : IntersectCreate(RemoveOptionalFromRest(T), options));
+}
+/** `[Json]` Creates an evaluated Intersect type */
+function IntersectEvaluated(T, options = {}) {
+    if (T.length === 0)
+        return Never(options);
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransform$1(schema)))
+        throw new Error('Cannot intersect transform types');
+    return ResolveIntersect(T, options);
+}
+
+/** `[Json]` Creates an evaluated Intersect type */
+function Intersect(T, options = {}) {
+    if (T.length === 0)
+        return Never(options);
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransform$1(schema)))
+        throw new Error('Cannot intersect transform types');
+    return IntersectCreate(T, options);
+}
+
+// prettier-ignore
+function FromRest$5(T) {
+    return T.map(L => AwaitedResolve(L));
+}
+// prettier-ignore
+function FromIntersect$5(T) {
+    return Intersect(FromRest$5(T));
+}
+// prettier-ignore
+function FromUnion$5(T) {
+    return Union(FromRest$5(T));
+}
+// prettier-ignore
+function FromPromise$2(T) {
+    return AwaitedResolve(T);
+}
+// ----------------------------------------------------------------
+// AwaitedResolve
+// ----------------------------------------------------------------
+// prettier-ignore
+function AwaitedResolve(T) {
+    return (IsIntersect$1(T) ? FromIntersect$5(T.allOf) :
+        IsUnion$1(T) ? FromUnion$5(T.anyOf) :
+            IsPromise$1(T) ? FromPromise$2(T.item) :
+                T);
+}
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+function Awaited(T, options = {}) {
+    return CloneType(AwaitedResolve(T), options);
+}
+
+// prettier-ignore
+function FromRest$4(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(KeyOfPropertyKeys(L));
+    return Acc;
+}
+// prettier-ignore
+function FromIntersect$4(T) {
+    const C = FromRest$4(T);
+    const R = SetUnionMany(C);
+    return R;
+}
+// prettier-ignore
+function FromUnion$4(T) {
+    const C = FromRest$4(T);
+    const R = SetIntersectMany(C);
+    return R;
+}
+// prettier-ignore
+function FromTuple$2(T) {
+    return T.map((_, I) => I.toString());
+}
+// prettier-ignore
+function FromArray$3(_) {
+    return (['[number]']);
+}
+// prettier-ignore
+function FromProperties$e(T) {
+    return (globalThis.Object.getOwnPropertyNames(T));
+}
+// ------------------------------------------------------------------
+// FromPatternProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPatternProperties(patternProperties) {
+    return [];
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+// prettier-ignore
+function KeyOfPropertyKeys(T) {
+    return (IsIntersect$1(T) ? FromIntersect$4(T.allOf) :
+        IsUnion$1(T) ? FromUnion$4(T.anyOf) :
+            IsTuple$1(T) ? FromTuple$2(T.items ?? []) :
+                IsArray$1(T) ? FromArray$3(T.items) :
+                    IsObject$1(T) ? FromProperties$e(T.properties) :
+                        IsRecord$1(T) ? FromPatternProperties(T.patternProperties) :
+                            []);
+}
+
+// prettier-ignore
+function KeyOfPropertyKeysToRest(T) {
+    return T.map(L => L === '[number]' ? Number() : Literal(L));
+}
+/** `[Json]` Creates a KeyOf type */
+function KeyOf(T, options = {}) {
+    if (IsMappedResult$1(T)) {
+        return KeyOfFromMappedResult(T, options);
+    }
+    else {
+        const K = KeyOfPropertyKeys(T);
+        const S = KeyOfPropertyKeysToRest(K);
+        const U = UnionEvaluated(S);
+        return CloneType(U, options);
+    }
+}
+
+// prettier-ignore
+function FromProperties$d(K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = KeyOf(K[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$7(R, options) {
+    return FromProperties$d(R.properties, options);
+}
+// prettier-ignore
+function KeyOfFromMappedResult(R, options) {
+    const P = FromMappedResult$7(R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function CompositeKeys(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...KeyOfPropertyKeys(L));
+    return SetDistinct(Acc);
+}
+// prettier-ignore
+function FilterNever(T) {
+    return T.filter(L => !IsNever$1(L));
+}
+// prettier-ignore
+function CompositeProperty(T, K) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexFromPropertyKeys(L, [K]));
+    return FilterNever(Acc);
+}
+// prettier-ignore
+function CompositeProperties(T, K) {
+    const Acc = {};
+    for (const L of K) {
+        Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+    }
+    return Acc;
+}
+// prettier-ignore
+function Composite(T, options = {}) {
+    const K = CompositeKeys(T);
+    const P = CompositeProperties(T, K);
+    const R = Object$1(P, options);
+    return R;
+}
+
+/** `[JavaScript]` Creates a Date type */
+function Date$1(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Date',
+        type: 'Date',
+    };
+}
+
+/** `[Json]` Creates a Null type */
+function Null(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Null',
+        type: 'null',
+    };
+}
+
+/** `[JavaScript]` Creates a Symbol type */
+function Symbol$1(options) {
+    return { ...options, [Kind]: 'Symbol', type: 'symbol' };
+}
+
+/** `[JavaScript]` Creates a Undefined type */
+function Undefined(options = {}) {
+    return { ...options, [Kind]: 'Undefined', type: 'undefined' };
+}
+
+/** `[JavaScript]` Creates a Uint8Array type */
+function Uint8Array$1(options = {}) {
+    return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' };
+}
+
+/** `[Json]` Creates an Unknown type */
+function Unknown(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Unknown',
+    };
+}
+
+// prettier-ignore
+function FromArray$2(T) {
+    return T.map(L => FromValue(L, false));
+}
+// prettier-ignore
+function FromProperties$c(value) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(value))
+        Acc[K] = Readonly(FromValue(value[K], false));
+    return Acc;
+}
+function ConditionalReadonly(T, root) {
+    return (root === true ? T : Readonly(T));
+}
+// prettier-ignore
+function FromValue(value, root) {
+    return (IsAsyncIterator$2(value) ? ConditionalReadonly(Any(), root) :
+        IsIterator$2(value) ? ConditionalReadonly(Any(), root) :
+            IsArray$2(value) ? Readonly(Tuple(FromArray$2(value))) :
+                IsUint8Array$2(value) ? Uint8Array$1() :
+                    IsDate$2(value) ? Date$1() :
+                        IsObject$2(value) ? ConditionalReadonly(Object$1(FromProperties$c(value)), root) :
+                            IsFunction$2(value) ? ConditionalReadonly(Function([], Unknown()), root) :
+                                IsUndefined$2(value) ? Undefined() :
+                                    IsNull$2(value) ? Null() :
+                                        IsSymbol$2(value) ? Symbol$1() :
+                                            IsBigInt$2(value) ? BigInt() :
+                                                IsNumber$2(value) ? Literal(value) :
+                                                    IsBoolean$2(value) ? Literal(value) :
+                                                        IsString$2(value) ? Literal(value) :
+                                                            Object$1({}));
+}
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+function Const(T, options = {}) {
+    return CloneType(FromValue(T, true), options);
+}
+
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+function ConstructorParameters(schema, options = {}) {
+    return Tuple(CloneRest(schema.parameters), { ...options });
+}
+
+function FromRest$3(schema, references) {
+    return schema.map((schema) => Deref(schema, references));
+}
+// prettier-ignore
+function FromProperties$b(properties, references) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
+        Acc[K] = Deref(properties[K], references);
+    }
+    return Acc;
+}
+// prettier-ignore
+function FromConstructor$1(schema, references) {
+    schema.parameters = FromRest$3(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
+}
+// prettier-ignore
+function FromFunction$1(schema, references) {
+    schema.parameters = FromRest$3(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
+}
+// prettier-ignore
+function FromIntersect$3(schema, references) {
+    schema.allOf = FromRest$3(schema.allOf, references);
+    return schema;
+}
+// prettier-ignore
+function FromUnion$3(schema, references) {
+    schema.anyOf = FromRest$3(schema.anyOf, references);
+    return schema;
+}
+// prettier-ignore
+function FromTuple$1(schema, references) {
+    if (IsUndefined$2(schema.items))
+        return schema;
+    schema.items = FromRest$3(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromArray$1(schema, references) {
+    schema.items = Deref(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromObject$1(schema, references) {
+    schema.properties = FromProperties$b(schema.properties, references);
+    return schema;
+}
+// prettier-ignore
+function FromPromise$1(schema, references) {
+    schema.item = Deref(schema.item, references);
+    return schema;
+}
+// prettier-ignore
+function FromAsyncIterator$1(schema, references) {
+    schema.items = Deref(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromIterator$1(schema, references) {
+    schema.items = Deref(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromRef(schema, references) {
+    const target = references.find(remote => remote.$id === schema.$ref);
+    if (target === undefined)
+        throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
+    const discard = Discard(target, ['$id']);
+    return Deref(discard, references);
+}
+// prettier-ignore
+function DerefResolve(schema, references) {
+    return (IsConstructor$1(schema) ? FromConstructor$1(schema, references) :
+        IsFunction$1(schema) ? FromFunction$1(schema, references) :
+            IsIntersect$1(schema) ? FromIntersect$3(schema, references) :
+                IsUnion$1(schema) ? FromUnion$3(schema, references) :
+                    IsTuple$1(schema) ? FromTuple$1(schema, references) :
+                        IsArray$1(schema) ? FromArray$1(schema, references) :
+                            IsObject$1(schema) ? FromObject$1(schema, references) :
+                                IsPromise$1(schema) ? FromPromise$1(schema, references) :
+                                    IsAsyncIterator$1(schema) ? FromAsyncIterator$1(schema, references) :
+                                        IsIterator$1(schema) ? FromIterator$1(schema, references) :
+                                            IsRef$1(schema) ? FromRef(schema, references) :
+                                                schema);
+}
+// ------------------------------------------------------------------
+// TDeref
+// ------------------------------------------------------------------
+/** `[Json]` Creates a dereferenced type */
+function Deref(schema, references) {
+    return DerefResolve(CloneType(schema), CloneRest(references));
+}
+
+/** `[Json]` Creates a Enum type */
+function Enum(item, options = {}) {
+    if (IsUndefined$2(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' });
+}
+
+class ExtendsResolverError extends TypeBoxError {
+}
+var ExtendsResult;
+(function (ExtendsResult) {
+    ExtendsResult[ExtendsResult["Union"] = 0] = "Union";
+    ExtendsResult[ExtendsResult["True"] = 1] = "True";
+    ExtendsResult[ExtendsResult["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+// ------------------------------------------------------------------
+// IntoBooleanResult
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntoBooleanResult(result) {
+    return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+// ------------------------------------------------------------------
+// Throw
+// ------------------------------------------------------------------
+// prettier-ignore
+function Throw(message) {
+    throw new ExtendsResolverError(message);
+}
+// ------------------------------------------------------------------
+// StructuralRight
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsStructuralRight(right) {
+    return (IsNever(right) ||
+        IsIntersect(right) ||
+        IsUnion(right) ||
+        IsUnknown(right) ||
+        IsAny(right));
+}
+// prettier-ignore
+function StructuralRight(left, right) {
+    return (IsNever(right) ? FromNeverRight() :
+        IsIntersect(right) ? FromIntersectRight(left, right) :
+            IsUnion(right) ? FromUnionRight(left, right) :
+                IsUnknown(right) ? FromUnknownRight() :
+                    IsAny(right) ? FromAnyRight() :
+                        Throw('StructuralRight'));
+}
+// ------------------------------------------------------------------
+// Any
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromAnyRight(left, right) {
+    return ExtendsResult.True;
+}
+// prettier-ignore
+function FromAny(left, right) {
+    return (IsIntersect(right) ? FromIntersectRight(left, right) :
+        (IsUnion(right) && right.anyOf.some((schema) => IsAny(schema) || IsUnknown(schema))) ? ExtendsResult.True :
+            IsUnion(right) ? ExtendsResult.Union :
+                IsUnknown(right) ? ExtendsResult.True :
+                    IsAny(right) ? ExtendsResult.True :
+                        ExtendsResult.Union);
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromArrayRight(left, right) {
+    return (IsUnknown(left) ? ExtendsResult.False :
+        IsAny(left) ? ExtendsResult.Union :
+            IsNever(left) ? ExtendsResult.True :
+                ExtendsResult.False);
+}
+// prettier-ignore
+function FromArray(left, right) {
+    return (IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            !IsArray(right) ? ExtendsResult.False :
+                IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromAsyncIterator(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        !IsAsyncIterator(right) ? ExtendsResult.False :
+            IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromBigInt(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsBigInt(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromBooleanRight(left, right) {
+    return (IsLiteralBoolean(left) ? ExtendsResult.True :
+        IsBoolean(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromBoolean(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsBoolean(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromConstructor(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            !IsConstructor(right) ? ExtendsResult.False :
+                left.parameters.length > right.parameters.length ? ExtendsResult.False :
+                    (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
+                        IntoBooleanResult(Visit(left.returns, right.returns)));
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromDate(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsDate(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromFunction(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            !IsFunction(right) ? ExtendsResult.False :
+                left.parameters.length > right.parameters.length ? ExtendsResult.False :
+                    (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
+                        IntoBooleanResult(Visit(left.returns, right.returns)));
+}
+// ------------------------------------------------------------------
+// Integer
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIntegerRight(left, right) {
+    return (IsLiteral(left) && IsNumber$2(left.const) ? ExtendsResult.True :
+        IsNumber(left) || IsInteger(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromInteger(left, right) {
+    return (IsInteger(right) || IsNumber(right) ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            IsObject(right) ? FromObjectRight(left, right) :
+                IsRecord(right) ? FromRecordRight(left, right) :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIntersectRight(left, right) {
+    return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// prettier-ignore
+function FromIntersect$2(left, right) {
+    return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIterator(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        !IsIterator(right) ? ExtendsResult.False :
+            IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromLiteral(left, right) {
+    return (IsLiteral(right) && right.const === left.const ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            IsObject(right) ? FromObjectRight(left, right) :
+                IsRecord(right) ? FromRecordRight(left, right) :
+                    IsString(right) ? FromStringRight(left) :
+                        IsNumber(right) ? FromNumberRight(left) :
+                            IsInteger(right) ? FromIntegerRight(left) :
+                                IsBoolean(right) ? FromBooleanRight(left) :
+                                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Never
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNeverRight(left, right) {
+    return ExtendsResult.False;
+}
+// prettier-ignore
+function FromNever(left, right) {
+    return ExtendsResult.True;
+}
+// ------------------------------------------------------------------
+// Not
+// ------------------------------------------------------------------
+// prettier-ignore
+function UnwrapTNot(schema) {
+    let [current, depth] = [schema, 0];
+    while (true) {
+        if (!IsNot(current))
+            break;
+        current = current.not;
+        depth += 1;
+    }
+    return depth % 2 === 0 ? current : Unknown();
+}
+// prettier-ignore
+function FromNot(left, right) {
+    // TypeScript has no concept of negated types, and attempts to correctly check the negated
+    // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
+    // the type. Instead we unwrap to either unknown or T and continue evaluating.
+    // prettier-ignore
+    return (IsNot(left) ? Visit(UnwrapTNot(left), right) :
+        IsNot(right) ? Visit(left, UnwrapTNot(right)) :
+            Throw('Invalid fallthrough for Not'));
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNull(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsNull(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNumberRight(left, right) {
+    return (IsLiteralNumber(left) ? ExtendsResult.True :
+        IsNumber(left) || IsInteger(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromNumber(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsInteger(right) || IsNumber(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsObjectPropertyCount(schema, count) {
+    return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+// prettier-ignore
+function IsObjectStringLike(schema) {
+    return IsObjectArrayLike(schema);
+}
+// prettier-ignore
+function IsObjectSymbolLike(schema) {
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((IsString(schema.properties.description.anyOf[0]) &&
+        IsUndefined(schema.properties.description.anyOf[1])) || (IsString(schema.properties.description.anyOf[1]) &&
+        IsUndefined(schema.properties.description.anyOf[0]))));
+}
+// prettier-ignore
+function IsObjectNumberLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectBooleanLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectBigIntLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectDateLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectUint8ArrayLike(schema) {
+    return IsObjectArrayLike(schema);
+}
+// prettier-ignore
+function IsObjectFunctionLike(schema) {
+    const length = Number();
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True);
+}
+// prettier-ignore
+function IsObjectConstructorLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectArrayLike(schema) {
+    const length = Number();
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True);
+}
+// prettier-ignore
+function IsObjectPromiseLike(schema) {
+    const then = Function([Any()], Any());
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === ExtendsResult.True);
+}
+// ------------------------------------------------------------------
+// Property
+// ------------------------------------------------------------------
+// prettier-ignore
+function Property(left, right) {
+    return (Visit(left, right) === ExtendsResult.False ? ExtendsResult.False :
+        IsOptional(left) && !IsOptional(right) ? ExtendsResult.False :
+            ExtendsResult.True);
+}
+// prettier-ignore
+function FromObjectRight(left, right) {
+    return (IsUnknown(left) ? ExtendsResult.False :
+        IsAny(left) ? ExtendsResult.Union : (IsNever(left) ||
+            (IsLiteralString(left) && IsObjectStringLike(right)) ||
+            (IsLiteralNumber(left) && IsObjectNumberLike(right)) ||
+            (IsLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
+            (IsSymbol(left) && IsObjectSymbolLike(right)) ||
+            (IsBigInt(left) && IsObjectBigIntLike(right)) ||
+            (IsString(left) && IsObjectStringLike(right)) ||
+            (IsSymbol(left) && IsObjectSymbolLike(right)) ||
+            (IsNumber(left) && IsObjectNumberLike(right)) ||
+            (IsInteger(left) && IsObjectNumberLike(right)) ||
+            (IsBoolean(left) && IsObjectBooleanLike(right)) ||
+            (IsUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
+            (IsDate(left) && IsObjectDateLike(right)) ||
+            (IsConstructor(left) && IsObjectConstructorLike(right)) ||
+            (IsFunction(left) && IsObjectFunctionLike(right))) ? ExtendsResult.True :
+            (IsRecord(left) && IsString(RecordKey(left))) ? (() => {
+                // When expressing a Record with literal key values, the Record is converted into a Object with
+                // the Hint assigned as `Record`. This is used to invert the extends logic.
+                return right[Hint] === 'Record' ? ExtendsResult.True : ExtendsResult.False;
+            })() :
+                (IsRecord(left) && IsNumber(RecordKey(left))) ? (() => {
+                    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+                })() :
+                    ExtendsResult.False);
+}
+// prettier-ignore
+function FromObject(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsRecord(right) ? FromRecordRight(left, right) :
+            !IsObject(right) ? ExtendsResult.False :
+                (() => {
+                    for (const key of Object.getOwnPropertyNames(right.properties)) {
+                        if (!(key in left.properties) && !IsOptional(right.properties[key])) {
+                            return ExtendsResult.False;
+                        }
+                        if (IsOptional(right.properties[key])) {
+                            return ExtendsResult.True;
+                        }
+                        if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+                            return ExtendsResult.False;
+                        }
+                    }
+                    return ExtendsResult.True;
+                })());
+}
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPromise(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True :
+            !IsPromise(right) ? ExtendsResult.False :
+                IntoBooleanResult(Visit(left.item, right.item)));
+}
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordKey(schema) {
+    return (PatternNumberExact in schema.patternProperties ? Number() :
+        PatternStringExact in schema.patternProperties ? String() :
+            Throw('Unknown record key pattern'));
+}
+// prettier-ignore
+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'));
+}
+// prettier-ignore
+function FromRecordRight(left, right) {
+    const [Key, Value] = [RecordKey(right), RecordValue(right)];
+    return ((IsLiteralString(left) && IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True) ? ExtendsResult.True :
+        IsUint8Array(left) && IsNumber(Key) ? Visit(left, Value) :
+            IsString(left) && IsNumber(Key) ? Visit(left, Value) :
+                IsArray(left) && IsNumber(Key) ? Visit(left, Value) :
+                    IsObject(left) ? (() => {
+                        for (const key of Object.getOwnPropertyNames(left.properties)) {
+                            if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+                                return ExtendsResult.False;
+                            }
+                        }
+                        return ExtendsResult.True;
+                    })() :
+                        ExtendsResult.False);
+}
+// prettier-ignore
+function FromRecord(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            !IsRecord(right) ? ExtendsResult.False :
+                Visit(RecordValue(left), RecordValue(right)));
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromRegExp(left, right) {
+    // Note: RegExp types evaluate as strings, not RegExp objects.
+    // Here we remap either into string and continue evaluating.
+    const L = IsRegExp(left) ? String() : left;
+    const R = IsRegExp(right) ? String() : right;
+    return Visit(L, R);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromStringRight(left, right) {
+    return (IsLiteral(left) && IsString$2(left.const) ? ExtendsResult.True :
+        IsString(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromString(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsString(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromSymbol(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsSymbol(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// TemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromTemplateLiteral$1(left, right) {
+    // TemplateLiteral types are resolved to either unions for finite expressions or string
+    // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
+    // either type and continue evaluating.
+    return (IsTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) :
+        IsTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) :
+            Throw('Invalid fallthrough for TemplateLiteral'));
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsArrayOfTuple(left, right) {
+    return (IsArray(right) &&
+        left.items !== undefined &&
+        left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True));
+}
+// prettier-ignore
+function FromTupleRight(left, right) {
+    return (IsNever(left) ? ExtendsResult.True :
+        IsUnknown(left) ? ExtendsResult.False :
+            IsAny(left) ? ExtendsResult.Union :
+                ExtendsResult.False);
+}
+// prettier-ignore
+function FromTuple(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+            IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True :
+                !IsTuple(right) ? ExtendsResult.False :
+                    (IsUndefined$2(left.items) && !IsUndefined$2(right.items)) || (!IsUndefined$2(left.items) && IsUndefined$2(right.items)) ? ExtendsResult.False :
+                        (IsUndefined$2(left.items) && !IsUndefined$2(right.items)) ? ExtendsResult.True :
+                            left.items.every((schema, index) => Visit(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True :
+                                ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUint8Array(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsUint8Array(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUndefined(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsVoid(right) ? FromVoidRight(left) :
+                    IsUndefined(right) ? ExtendsResult.True :
+                        ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUnionRight(left, right) {
+    return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// prettier-ignore
+function FromUnion$2(left, right) {
+    return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// ------------------------------------------------------------------
+// Unknown
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUnknownRight(left, right) {
+    return ExtendsResult.True;
+}
+// prettier-ignore
+function FromUnknown(left, right) {
+    return (IsNever(right) ? FromNeverRight() :
+        IsIntersect(right) ? FromIntersectRight(left, right) :
+            IsUnion(right) ? FromUnionRight(left, right) :
+                IsAny(right) ? FromAnyRight() :
+                    IsString(right) ? FromStringRight(left) :
+                        IsNumber(right) ? FromNumberRight(left) :
+                            IsInteger(right) ? FromIntegerRight(left) :
+                                IsBoolean(right) ? FromBooleanRight(left) :
+                                    IsArray(right) ? FromArrayRight(left) :
+                                        IsTuple(right) ? FromTupleRight(left) :
+                                            IsObject(right) ? FromObjectRight(left, right) :
+                                                IsUnknown(right) ? ExtendsResult.True :
+                                                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Void
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromVoidRight(left, right) {
+    return (IsUndefined(left) ? ExtendsResult.True :
+        IsUndefined(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromVoid(left, right) {
+    return (IsIntersect(right) ? FromIntersectRight(left, right) :
+        IsUnion(right) ? FromUnionRight(left, right) :
+            IsUnknown(right) ? FromUnknownRight() :
+                IsAny(right) ? FromAnyRight() :
+                    IsObject(right) ? FromObjectRight(left, right) :
+                        IsVoid(right) ? ExtendsResult.True :
+                            ExtendsResult.False);
+}
+// prettier-ignore
+function Visit(left, right) {
+    return (
+    // resolvable
+    (IsTemplateLiteral(left) || IsTemplateLiteral(right)) ? FromTemplateLiteral$1(left, right) :
+        (IsRegExp(left) || IsRegExp(right)) ? FromRegExp(left, right) :
+            (IsNot(left) || IsNot(right)) ? FromNot(left, right) :
+                // standard
+                IsAny(left) ? FromAny(left, right) :
+                    IsArray(left) ? FromArray(left, right) :
+                        IsBigInt(left) ? FromBigInt(left, right) :
+                            IsBoolean(left) ? FromBoolean(left, right) :
+                                IsAsyncIterator(left) ? FromAsyncIterator(left, right) :
+                                    IsConstructor(left) ? FromConstructor(left, right) :
+                                        IsDate(left) ? FromDate(left, right) :
+                                            IsFunction(left) ? FromFunction(left, right) :
+                                                IsInteger(left) ? FromInteger(left, right) :
+                                                    IsIntersect(left) ? FromIntersect$2(left, right) :
+                                                        IsIterator(left) ? FromIterator(left, right) :
+                                                            IsLiteral(left) ? FromLiteral(left, right) :
+                                                                IsNever(left) ? FromNever() :
+                                                                    IsNull(left) ? FromNull(left, right) :
+                                                                        IsNumber(left) ? FromNumber(left, right) :
+                                                                            IsObject(left) ? FromObject(left, right) :
+                                                                                IsRecord(left) ? FromRecord(left, right) :
+                                                                                    IsString(left) ? FromString(left, right) :
+                                                                                        IsSymbol(left) ? FromSymbol(left, right) :
+                                                                                            IsTuple(left) ? FromTuple(left, right) :
+                                                                                                IsPromise(left) ? FromPromise(left, right) :
+                                                                                                    IsUint8Array(left) ? FromUint8Array(left, right) :
+                                                                                                        IsUndefined(left) ? FromUndefined(left, right) :
+                                                                                                            IsUnion(left) ? FromUnion$2(left, right) :
+                                                                                                                IsUnknown(left) ? FromUnknown(left, right) :
+                                                                                                                    IsVoid(left) ? FromVoid(left, right) :
+                                                                                                                        Throw(`Unknown left type operand '${left[Kind]}'`));
+}
+function ExtendsCheck(left, right) {
+    return Visit(left, right);
+}
+
+// prettier-ignore
+function FromProperties$a(P, Right, True, False, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extends(P[K2], Right, True, False, options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$6(Left, Right, True, False, options) {
+    return FromProperties$a(Left.properties, Right, True, False, options);
+}
+// prettier-ignore
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+    const P = FromMappedResult$6(Left, Right, True, False, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function ExtendsResolve(left, right, trueType, falseType) {
+    const R = ExtendsCheck(left, right);
+    return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
+        R === ExtendsResult.True ? trueType :
+            falseType);
+}
+/** `[Json]` Creates a Conditional type */
+function Extends(L, R, T, F, options = {}) {
+    // prettier-ignore
+    return (IsMappedResult$1(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
+        IsMappedKey$1(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
+            CloneType(ExtendsResolve(L, R, T, F), options));
+}
+
+// prettier-ignore
+function FromPropertyKey$2(K, U, L, R, options) {
+    return {
+        [K]: Extends(Literal(K), U, L, R, options)
+    };
+}
+// prettier-ignore
+function FromPropertyKeys$2(K, U, L, R, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey$2(LK, U, L, R, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey$2(K, U, L, R, options) {
+    return FromPropertyKeys$2(K.keys, U, L, R, options);
+}
+// prettier-ignore
+function ExtendsFromMappedKey(T, U, L, R, options) {
+    const P = FromMappedKey$2(T, U, L, R, options);
+    return MappedResult(P);
+}
+
+function ExcludeFromTemplateLiteral(L, R) {
+    return Exclude(TemplateLiteralToUnion(L), R);
+}
+
+function ExcludeRest(L, R) {
+    const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+    return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+function Exclude(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral$1(L))
+        return CloneType(ExcludeFromTemplateLiteral(L, R), options);
+    if (IsMappedResult$1(L))
+        return CloneType(ExcludeFromMappedResult(L, R), options);
+    // prettier-ignore
+    return CloneType(IsUnion$1(L) ? ExcludeRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}
+
+// prettier-ignore
+function FromProperties$9(P, U) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Exclude(P[K2], U);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$5(R, T) {
+    return FromProperties$9(R.properties, T);
+}
+// prettier-ignore
+function ExcludeFromMappedResult(R, T) {
+    const P = FromMappedResult$5(R, T);
+    return MappedResult(P);
+}
+
+function ExtractFromTemplateLiteral(L, R) {
+    return Extract(TemplateLiteralToUnion(L), R);
+}
+
+function ExtractRest(L, R) {
+    const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+    return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+function Extract(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral$1(L))
+        return CloneType(ExtractFromTemplateLiteral(L, R), options);
+    if (IsMappedResult$1(L))
+        return CloneType(ExtractFromMappedResult(L, R), options);
+    // prettier-ignore
+    return CloneType(IsUnion$1(L) ? ExtractRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+
+// prettier-ignore
+function FromProperties$8(P, T) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extract(P[K2], T);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$4(R, T) {
+    return FromProperties$8(R.properties, T);
+}
+// prettier-ignore
+function ExtractFromMappedResult(R, T) {
+    const P = FromMappedResult$4(R, T);
+    return MappedResult(P);
+}
+
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+function InstanceType(schema, options = {}) {
+    return CloneType(schema.returns, options);
+}
+
+/** `[Json]` Creates an Integer type */
+function Integer(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Integer',
+        type: 'integer',
+    };
+}
+
+// prettier-ignore
+function MappedIntrinsicPropertyKey(K, M, options) {
+    return {
+        [K]: Intrinsic(Literal(K), M, options)
+    };
+}
+// prettier-ignore
+function MappedIntrinsicPropertyKeys(K, M, options) {
+    return K.reduce((Acc, L) => {
+        return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIntrinsicProperties(T, M, options) {
+    return MappedIntrinsicPropertyKeys(T['keys'], M, options);
+}
+// prettier-ignore
+function IntrinsicFromMappedKey(T, M, options) {
+    const P = MappedIntrinsicProperties(T, M, options);
+    return MappedResult(P);
+}
+
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
+function ApplyUncapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toLowerCase(), rest].join('');
+}
+function ApplyCapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toUpperCase(), rest].join('');
+}
+function ApplyUppercase(value) {
+    return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+    return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode, options) {
+    // note: template literals require special runtime handling as they are encoded in string patterns.
+    // This diverges from the mapped type which would otherwise map on the template literal kind.
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    const finite = IsTemplateLiteralExpressionFinite(expression);
+    if (!finite)
+        return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+    const strings = [...TemplateLiteralExpressionGenerate(expression)];
+    const literals = strings.map((value) => Literal(value));
+    const mapped = FromRest$2(literals, mode);
+    const union = Union(mapped);
+    return TemplateLiteral([union], options);
+}
+// prettier-ignore
+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());
+}
+// prettier-ignore
+function FromRest$2(T, M) {
+    return T.map(L => Intrinsic(L, M));
+}
+/** Applies an intrinsic string manipulation to the given type. */
+function Intrinsic(schema, mode, options = {}) {
+    // prettier-ignore
+    return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKey$1(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        // Standard-Inference
+        IsTemplateLiteral$1(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            IsUnion$1(schema) ? Union(FromRest$2(schema.anyOf, mode), options) :
+                IsLiteral$1(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
+                    schema);
+}
+
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+function Capitalize(T, options = {}) {
+    return Intrinsic(T, 'Capitalize', options);
+}
+
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
+function Lowercase(T, options = {}) {
+    return Intrinsic(T, 'Lowercase', options);
+}
+
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+function Uncapitalize(T, options = {}) {
+    return Intrinsic(T, 'Uncapitalize', options);
+}
+
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
+function Uppercase(T, options = {}) {
+    return Intrinsic(T, 'Uppercase', options);
+}
+
+/** `[Json]` Creates a Not type */
+function Not(schema, options) {
+    return {
+        ...options,
+        [Kind]: 'Not',
+        not: CloneType(schema),
+    };
+}
+
+// prettier-ignore
+function FromProperties$7(P, K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Omit(P[K2], K, options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$3(R, K, options) {
+    return FromProperties$7(R.properties, K, options);
+}
+// prettier-ignore
+function OmitFromMappedResult(R, K, options) {
+    const P = FromMappedResult$3(R, K, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function FromIntersect$1(T, K) {
+    return T.map((T) => OmitResolve(T, K));
+}
+// prettier-ignore
+function FromUnion$1(T, K) {
+    return T.map((T) => OmitResolve(T, K));
+}
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromProperty(T, K) {
+    const { [K]: _, ...R } = T;
+    return R;
+}
+// prettier-ignore
+function FromProperties$6(T, K) {
+    return K.reduce((T, K2) => FromProperty(T, K2), T);
+}
+// ------------------------------------------------------------------
+// OmitResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function OmitResolve(T, K) {
+    return (IsIntersect$1(T) ? Intersect(FromIntersect$1(T.allOf, K)) :
+        IsUnion$1(T) ? Union(FromUnion$1(T.anyOf, K)) :
+            IsObject$1(T) ? Object$1(FromProperties$6(T.properties, K)) :
+                Object$1({}));
+}
+function Omit(T, K, options = {}) {
+    // mapped
+    if (IsMappedKey$1(K))
+        return OmitFromMappedKey(T, K, options);
+    if (IsMappedResult$1(T))
+        return OmitFromMappedResult(T, K, options);
+    // non-mapped
+    const I = IsSchema$1(K) ? IndexPropertyKeys(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(OmitResolve(T, I), options);
+    return { ...D, ...R };
+}
+
+// prettier-ignore
+function FromPropertyKey$1(T, K, options) {
+    return {
+        [K]: Omit(T, [K], options)
+    };
+}
+// prettier-ignore
+function FromPropertyKeys$1(T, K, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey$1(T, LK, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey$1(T, K, options) {
+    return FromPropertyKeys$1(T, K.keys, options);
+}
+// prettier-ignore
+function OmitFromMappedKey(T, K, options) {
+    const P = FromMappedKey$1(T, K, options);
+    return MappedResult(P);
+}
+
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+function Parameters(schema, options = {}) {
+    return Tuple(CloneRest(schema.parameters), { ...options });
+}
+
+// prettier-ignore
+function FromRest$1(T) {
+    return T.map(L => PartialResolve(L));
+}
+// prettier-ignore
+function FromProperties$5(T) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = Optional(T[K]);
+    return Acc;
+}
+// ------------------------------------------------------------------
+// PartialResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function PartialResolve(T) {
+    return (IsIntersect$1(T) ? Intersect(FromRest$1(T.allOf)) :
+        IsUnion$1(T) ? Union(FromRest$1(T.anyOf)) :
+            IsObject$1(T) ? Object$1(FromProperties$5(T.properties)) :
+                Object$1({}));
+}
+/** `[Json]` Constructs a type where all properties are optional */
+function Partial(T, options = {}) {
+    if (IsMappedResult$1(T))
+        return PartialFromMappedResult(T, options);
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PartialResolve(T), options);
+    return { ...D, ...R };
+}
+
+// prettier-ignore
+function FromProperties$4(K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Partial(K[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$2(R, options) {
+    return FromProperties$4(R.properties, options);
+}
+// prettier-ignore
+function PartialFromMappedResult(R, options) {
+    const P = FromMappedResult$2(R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function FromProperties$3(P, K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Pick(P[K2], K, options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$1(R, K, options) {
+    return FromProperties$3(R.properties, K, options);
+}
+// prettier-ignore
+function PickFromMappedResult(R, K, options) {
+    const P = FromMappedResult$1(R, K, options);
+    return MappedResult(P);
+}
+
+function FromIntersect(T, K) {
+    return T.map((T) => PickResolve(T, K));
+}
+// prettier-ignore
+function FromUnion(T, K) {
+    return T.map((T) => PickResolve(T, K));
+}
+// prettier-ignore
+function FromProperties$2(T, K) {
+    const Acc = {};
+    for (const K2 of K)
+        if (K2 in T)
+            Acc[K2] = T[K2];
+    return Acc;
+}
+// ------------------------------------------------------------------
+// PickResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function PickResolve(T, K) {
+    return (IsIntersect$1(T) ? Intersect(FromIntersect(T.allOf, K)) :
+        IsUnion$1(T) ? Union(FromUnion(T.anyOf, K)) :
+            IsObject$1(T) ? Object$1(FromProperties$2(T.properties, K)) :
+                Object$1({}));
+}
+function Pick(T, K, options = {}) {
+    // mapped
+    if (IsMappedKey$1(K))
+        return PickFromMappedKey(T, K, options);
+    if (IsMappedResult$1(T))
+        return PickFromMappedResult(T, K, options);
+    // non-mapped
+    const I = IsSchema$1(K) ? IndexPropertyKeys(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PickResolve(T, I), options);
+    return { ...D, ...R };
+}
+
+// prettier-ignore
+function FromPropertyKey(T, K, options) {
+    return {
+        [K]: Pick(T, [K], options)
+    };
+}
+// prettier-ignore
+function FromPropertyKeys(T, K, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(T, LK, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey(T, K, options) {
+    return FromPropertyKeys(T, K.keys, options);
+}
+// prettier-ignore
+function PickFromMappedKey(T, K, options) {
+    const P = FromMappedKey(T, K, options);
+    return MappedResult(P);
+}
+
+/** `[Json]` Creates a Readonly and Optional property */
+function ReadonlyOptional(schema) {
+    return Readonly(Optional(schema));
+}
+
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern, T, options) {
+    return {
+        ...options,
+        [Kind]: 'Record',
+        type: 'object',
+        patternProperties: { [pattern]: CloneType(T) }
+    };
+}
+// ------------------------------------------------------------------
+// RecordCreateFromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromKeys(K, T, options) {
+    const Acc = {};
+    for (const K2 of K)
+        Acc[K2] = CloneType(T);
+    return Object$1(Acc, { ...options, [Hint]: 'Record' });
+}
+// prettier-ignore
+function FromTemplateLiteralKey(K, T, options) {
+    return (IsTemplateLiteralFinite(K)
+        ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
+        : RecordCreateFromPattern(K.pattern, T, options));
+}
+// prettier-ignore
+function FromUnionKey(K, T, options) {
+    return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options);
+}
+// prettier-ignore
+function FromLiteralKey(K, T, options) {
+    return RecordCreateFromKeys([K.toString()], T, options);
+}
+// prettier-ignore
+function FromRegExpKey(K, T, options) {
+    return RecordCreateFromPattern(K.source, T, options);
+}
+// prettier-ignore
+function FromStringKey(K, T, options) {
+    const pattern = IsUndefined$2(K.pattern) ? PatternStringExact : K.pattern;
+    return RecordCreateFromPattern(pattern, T, options);
+}
+// prettier-ignore
+function FromAnyKey(K, T, options) {
+    return RecordCreateFromPattern(PatternStringExact, T, options);
+}
+// prettier-ignore
+function FromNeverKey(K, T, options) {
+    return RecordCreateFromPattern(PatternNeverExact, T, options);
+}
+// prettier-ignore
+function FromIntegerKey(_, T, options) {
+    return RecordCreateFromPattern(PatternNumberExact, T, options);
+}
+// prettier-ignore
+function FromNumberKey(_, T, options) {
+    return RecordCreateFromPattern(PatternNumberExact, T, options);
+}
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
+function Record(K, T, options = {}) {
+    // prettier-ignore
+    return (IsUnion$1(K) ? FromUnionKey(K.anyOf, T, options) :
+        IsTemplateLiteral$1(K) ? FromTemplateLiteralKey(K, T, options) :
+            IsLiteral$1(K) ? FromLiteralKey(K.const, T, options) :
+                IsInteger$1(K) ? FromIntegerKey(K, T, options) :
+                    IsNumber$1(K) ? FromNumberKey(K, T, options) :
+                        IsRegExp$1(K) ? FromRegExpKey(K, T, options) :
+                            IsString$1(K) ? FromStringKey(K, T, options) :
+                                IsAny$1(K) ? FromAnyKey(K, T, options) :
+                                    IsNever$1(K) ? FromNeverKey(K, T, options) :
+                                        Never(options));
+}
+
+// Auto Tracked For Recursive Types without ID's
+let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
+function Recursive(callback, options = {}) {
+    if (IsUndefined$2(options.$id))
+        options.$id = `T${Ordinal++}`;
+    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
+    thisType.$id = options.$id;
+    // prettier-ignore
+    return CloneType({ ...options, [Hint]: 'Recursive', ...thisType });
+}
+
+/** `[Json]` Creates a Ref type. */
+function Ref(unresolved, options = {}) {
+    if (IsString$2(unresolved))
+        return { ...options, [Kind]: 'Ref', $ref: unresolved };
+    if (IsUndefined$2(unresolved.$id))
+        throw new Error('Reference target type must specify an $id');
+    return {
+        ...options,
+        [Kind]: 'Ref',
+        $ref: unresolved.$id,
+    };
+}
+
+/** `[JavaScript]` Creates a RegExp type */
+function RegExp$1(unresolved, options = {}) {
+    const expr = IsString$2(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
+}
+
+// prettier-ignore
+function FromRest(T) {
+    return T.map(L => RequiredResolve(L));
+}
+// prettier-ignore
+function FromProperties$1(T) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = Discard(T[K], [OptionalKind]);
+    return Acc;
+}
+// ------------------------------------------------------------------
+// RequiredResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function RequiredResolve(T) {
+    return (IsIntersect$1(T) ? Intersect(FromRest(T.allOf)) :
+        IsUnion$1(T) ? Union(FromRest(T.anyOf)) :
+            IsObject$1(T) ? Object$1(FromProperties$1(T.properties)) :
+                Object$1({}));
+}
+/** `[Json]` Constructs a type where all properties are required */
+function Required(T, options = {}) {
+    if (IsMappedResult$1(T)) {
+        return RequiredFromMappedResult(T, options);
+    }
+    else {
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(RequiredResolve(T), options);
+        return { ...D, ...R };
+    }
+}
+
+// prettier-ignore
+function FromProperties(P, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Required(P[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
+}
+// prettier-ignore
+function RequiredFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function RestResolve(T) {
+    return (IsIntersect$1(T) ? CloneRest(T.allOf) :
+        IsUnion$1(T) ? CloneRest(T.anyOf) :
+            IsTuple$1(T) ? CloneRest(T.items ?? []) :
+                []);
+}
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+function Rest(T) {
+    return CloneRest(RestResolve(T));
+}
+
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
+function ReturnType(schema, options = {}) {
+    return CloneType(schema.returns, options);
+}
+
+/** `[Json]` Omits compositing symbols from this schema. */
+function Strict(schema) {
+    return JSON.parse(JSON.stringify(schema));
+}
+
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
+class TransformDecodeBuilder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+// prettier-ignore
+class TransformEncodeBuilder {
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    EncodeTransform(encode, schema) {
+        const Encode = (value) => schema[TransformKind].Encode(encode(value));
+        const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+        const Codec = { Encode: Encode, Decode: Decode };
+        return { ...schema, [TransformKind]: Codec };
+    }
+    EncodeSchema(encode, schema) {
+        const Codec = { Decode: this.decode, Encode: encode };
+        return { ...schema, [TransformKind]: Codec };
+    }
+    Encode(encode) {
+        const schema = CloneType(this.schema);
+        return (IsTransform$1(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+    }
+}
+/** `[Json]` Creates a Transform type */
+function Transform(schema) {
+    return new TransformDecodeBuilder(schema);
+}
+
+/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+function Unsafe(options = {}) {
+    return {
+        ...options,
+        [Kind]: options[Kind] ?? 'Unsafe',
+    };
+}
+
+/** `[JavaScript]` Creates a Void type */
+function Void(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Void',
+        type: 'void',
+    };
+}
+
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
+
+var TypeBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Any: Any,
+    Array: Array$1,
+    AsyncIterator: AsyncIterator,
+    Awaited: Awaited,
+    BigInt: BigInt,
+    Boolean: Boolean,
+    Capitalize: Capitalize,
+    Composite: Composite,
+    Const: Const,
+    Constructor: Constructor,
+    ConstructorParameters: ConstructorParameters,
+    Date: Date$1,
+    Deref: Deref,
+    Enum: Enum,
+    Exclude: Exclude,
+    Extends: Extends,
+    Extract: Extract,
+    Function: Function,
+    Index: Index,
+    InstanceType: InstanceType,
+    Integer: Integer,
+    Intersect: Intersect,
+    Iterator: Iterator,
+    KeyOf: KeyOf,
+    Literal: Literal,
+    Lowercase: Lowercase,
+    Mapped: Mapped,
+    Never: Never,
+    Not: Not,
+    Null: Null,
+    Number: Number,
+    Object: Object$1,
+    Omit: Omit,
+    Optional: Optional,
+    Parameters: Parameters,
+    Partial: Partial,
+    Pick: Pick,
+    Promise: Promise$1,
+    Readonly: Readonly,
+    ReadonlyOptional: ReadonlyOptional,
+    Record: Record,
+    Recursive: Recursive,
+    Ref: Ref,
+    RegExp: RegExp$1,
+    Required: Required,
+    Rest: Rest,
+    ReturnType: ReturnType,
+    Strict: Strict,
+    String: String,
+    Symbol: Symbol$1,
+    TemplateLiteral: TemplateLiteral,
+    Transform: Transform,
+    Tuple: Tuple,
+    Uint8Array: Uint8Array$1,
+    Uncapitalize: Uncapitalize,
+    Undefined: Undefined,
+    Union: Union,
+    Unknown: Unknown,
+    Unsafe: Unsafe,
+    Uppercase: Uppercase,
+    Void: Void
+});
+
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+const Type = TypeBuilder;
 
 /**
  * 北森 EHR OpenClaw Plugin
@@ -14,65 +3461,138 @@ var os = require('os');
  */
 // 插件元数据
 const pluginId = 'beisen-ehr-plugin';
-const pluginVersion = '1.0.0';
+const pluginVersion = '1.1.0';
 /**
  * 默认配置
  */
 const defaultConfig = {
     apiUrl: 'https://openapi.italent.cn',
 };
-/**
- * 从配置文件读取配置
- */
-function loadConfig() {
-    try {
-        const homeDir = os.homedir();
-        const configPath = path.join(homeDir, '.openclaw', 'config.json');
-        if (!fs.existsSync(configPath)) {
-            return null;
+// ============ Token 管理 ============
+let cachedToken = null;
+let tokenExpiry = 0;
+async function getAccessToken(config) {
+    // 如果已有有效 Token，直接返回
+    if (cachedToken && Date.now() < tokenExpiry) {
+        return cachedToken;
+    }
+    // 使用 AppKey + AppSecret 获取新 Token（北森官方格式）
+    const tokenUrl = `${config.apiUrl || defaultConfig.apiUrl}/token`;
+    const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            grant_type: "client_credentials",
+            app_key: config.appKey,
+            app_secret: config.appSecret,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`获取 Token 失败：${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    cachedToken = data.accessToken || data.access_token;
+    // Token 有效期通常 2 小时，提前 5 分钟刷新
+    tokenExpiry = Date.now() + (data.expiresIn || data.expires_in || 7200) * 1000 - 5 * 60 * 1000;
+    console.error(`🔑 已获取新 Token，有效期至：${new Date(tokenExpiry).toISOString()}`);
+    return cachedToken;
+}
+// ============ 北森 API 客户端 ============
+class BeisenClient {
+    constructor(config) {
+        this.config = config;
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.config.apiUrl || defaultConfig.apiUrl}${endpoint}`;
+        const token = await getAccessToken(this.config);
+        const headers = {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`,
+            ...(this.config.tenantId && { "tenantId": this.config.tenantId }),
+            ...(options.headers || {}),
+        };
+        console.error(`📡 请求：${options.method || 'GET'} ${url}`);
+        console.error(`🏢 TenantId: ${this.config.tenantId}`);
+        const response = await fetch(url, {
+            ...options,
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`北森 API 错误：${response.status} - ${errorText}`);
         }
-        const content = fs.readFileSync(configPath, 'utf-8');
-        const config = JSON.parse(content);
-        // 尝试读取插件配置（支持两种格式）
-        const pluginConfig = config.plugins?.['beisen-ehr-plugin'] ||
-            config.plugins?.['@peninsula-med/beisen-ehr-plugin'];
-        if (!pluginConfig || !pluginConfig.config) {
-            return null;
+        return response.json();
+    }
+    // 提交加班申请（推送至北森系统并发起审批）
+    async submitOvertime(data) {
+        const overtimeData = {
+            staffId: data.staffId,
+            email: data.email,
+            startDate: data.startDate,
+            stopDate: data.stopDate,
+            compensationType: data.compensationType !== undefined ? data.compensationType : 0,
+        };
+        if (data.properties) {
+            overtimeData.properties = typeof data.properties === 'string' ? data.properties : JSON.stringify(data.properties);
         }
-        return pluginConfig.config;
+        const payload = {
+            attendance_overTime: overtimeData,
+        };
+        return this.request("/AttendanceOpen/api/v1/AttendanceOvertime/PostOverTimeWithApproval", {
+            method: "POST",
+            body: payload,
+        });
     }
-    catch (error) {
-        console.error('❌ 读取配置文件失败:', error.message);
-        return null;
+    // 查询假期余额
+    async getLeaveBalance(staffId, email) {
+        return this.request("/AttendanceOpen/api/v1/LeaveBalance/QueryLeaveBalance", {
+            method: "POST",
+            body: { staffId, email },
+        });
+    }
+    // 查询考勤记录
+    async getAttendanceRecords(startDate, endDate, employeeId) {
+        return this.request("/api/v1/attendance/records", {
+            method: "POST",
+            body: { startDate, endDate, employeeId },
+        });
+    }
+    // 查询审批状态
+    async getApprovalStatus(applicationId) {
+        return this.request(`/api/v1/approval/${applicationId}/status`);
     }
 }
 /**
- * 插件激活函数
- *
- * 当插件被激活时，自动配置 MCP 服务器
+ * 插件注册函数
  */
-async function activate(runtime, config) {
-    console.error(`🏢 北森 EHR 插件已激活 v${pluginVersion}`);
-    // 如果 OpenClaw 没有传入配置，尝试从配置文件读取
-    if (!config) {
-        config = loadConfig();
-    }
-    // 处理空配置情况
+async function register(api) {
+    console.error(`🏢 北森 EHR 插件已加载 v${pluginVersion}`);
+    // 获取插件配置
+    const config = api.config?.plugins?.entries?.['beisen-ehr-plugin']?.config;
     if (!config) {
         console.error('⚠️  插件已安装，但未配置凭证');
         console.error('');
-        console.error('📝 请运行配置向导完成配置：');
-        console.error('');
-        console.error('   npx @peninsula-med/beisen-ehr-configure');
+        console.error('📝 请在 OpenClaw 配置中添加：');
         console.error('');
-        console.error('按提示输入北森凭证即可！');
+        console.error('   plugins: {');
+        console.error('     entries: {');
+        console.error('       "beisen-ehr-plugin": {');
+        console.error('         enabled: true,');
+        console.error('         config: {');
+        console.error('           appKey: "your-app-key",');
+        console.error('           appSecret: "your-app-secret",');
+        console.error('           staffId: "your-staff-id",');
+        console.error('           tenantId: "your-tenant-id",');
+        console.error('           email: "your-email@company.com"');
+        console.error('         }');
+        console.error('       }');
+        console.error('     }');
+        console.error('   }');
         console.error('');
-        console.error('需要凭证？联系北森管理员获取：');
-        console.error('  • App Key');
-        console.error('  • App Secret');
-        console.error('  • Tenant ID');
-        console.error('  • Staff ID');
-        console.error('  • 企业邮箱');
         return;
     }
     // 验证必要配置
@@ -80,48 +3600,166 @@ async function activate(runtime, config) {
     const missingFields = requiredFields.filter(field => !config[field]);
     if (missingFields.length > 0) {
         console.error(`❌ 缺少必要配置：${missingFields.join(', ')}`);
-        console.error('');
-        console.error('📝 请运行配置向导完成配置：');
-        console.error('');
-        console.error('   npx @peninsula-med/beisen-ehr-configure');
-        console.error('');
-        console.error('按提示输入北森凭证即可！');
+        console.error('请补充完整配置后重启 Gateway');
         return;
     }
-    // MCP 服务器配置会自动从 openclaw.plugin.json 加载
-    // 这里只需要验证配置即可
     console.error('✅ 北森 EHR 配置验证通过');
     console.error(`📡 API: ${config.apiUrl || defaultConfig.apiUrl}`);
     console.error(`👤 员工：${config.staffId}`);
     console.error(`🏢 企业：${config.tenantId}`);
+    // 创建 API 客户端
+    const client = new BeisenClient(config);
+    // ============ 注册工具 ============
+    // 工具 1: 提交加班申请
+    api.registerTool({
+        name: 'beisen_submit_overtime',
+        description: '提交加班申请到北森 EHR（推送数据并发起审批）',
+        parameters: Type.Object({
+            startDate: Type.String({ description: '开始时间 (YYYY-MM-DD HH:mm:ss)，如：2020-07-17 22:00:00' }),
+            stopDate: Type.String({ description: '结束时间 (YYYY-MM-DD HH:mm:ss)，如：2020-07-17 23:00:00' }),
+            compensationType: Type.Optional(Type.Number({ description: '补偿类型：0=调休假，1=加班费（默认 0）' })),
+            properties: Type.Optional(Type.String({ description: '自定义字段 JSON 字符串' })),
+        }),
+        async execute(_id, params) {
+            try {
+                const result = await client.submitOvertime({
+                    staffId: config.staffId,
+                    email: config.email,
+                    startDate: params.startDate,
+                    stopDate: params.stopDate,
+                    compensationType: params.compensationType,
+                    properties: params.properties,
+                });
+                if (result.code === "200" || result.code === 200) {
+                    const compTypeText = params.compensationType === 1 ? "加班费" : "调休假";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ 加班申请已提交！\n\n申请详情：\n- 员工 ID: ${config.staffId}\n- 邮箱：${config.email}\n- 开始：${params.startDate}\n- 结束：${params.stopDate}\n- 补偿类型：${compTypeText}\n- 申请 ID: ${result.data || "待返回"}`,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    throw new Error(result.message || `API 返回错误：${result.code}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `❌ 提交失败：${error.message}` }],
+                    isError: true,
+                };
+            }
+        },
+    });
+    // 工具 2: 查询假期余额
+    api.registerTool({
+        name: 'beisen_get_leave_balance',
+        description: '查询假期余额（年假、调休假等）',
+        parameters: Type.Object({}),
+        async execute(_id, _params) {
+            try {
+                const result = await client.getLeaveBalance(config.staffId, config.email);
+                let balanceText = `📊 假期余额查询\n\n员工：${config.email}\n\n`;
+                if (result.data && Array.isArray(result.data)) {
+                    result.data.forEach((item) => {
+                        balanceText += `• ${item.leaveTypeName || item.typeName || '未知假期'}: ${item.balanceDays || item.balance || 0} 天\n`;
+                    });
+                }
+                else if (result.data) {
+                    balanceText += JSON.stringify(result.data, null, 2);
+                }
+                else {
+                    balanceText += "暂无假期数据";
+                }
+                return {
+                    content: [{ type: "text", text: balanceText }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `❌ 查询失败：${error.message}` }],
+                    isError: true,
+                };
+            }
+        },
+    });
+    // 工具 3: 查询考勤记录
+    api.registerTool({
+        name: 'beisen_query_attendance',
+        description: '查询员工考勤记录',
+        parameters: Type.Object({
+            startDate: Type.String({ description: '开始日期 (YYYY-MM-DD)' }),
+            endDate: Type.String({ description: '结束日期 (YYYY-MM-DD)' }),
+        }),
+        async execute(_id, params) {
+            try {
+                const records = await client.getAttendanceRecords(params.startDate, params.endDate, config.staffId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📅 考勤记录 (${params.startDate} ~ ${params.endDate})\n\n${JSON.stringify(records, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `❌ 查询失败：${error.message}` }],
+                    isError: true,
+                };
+            }
+        },
+    });
+    // 工具 4: 查询审批状态
+    api.registerTool({
+        name: 'beisen_get_approval_status',
+        description: '查询审批状态',
+        parameters: Type.Object({
+            applicationId: Type.String({ description: '申请 ID' }),
+        }),
+        async execute(_id, params) {
+            try {
+                const status = await client.getApprovalStatus(params.applicationId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📋 审批状态\n\n申请 ID: ${params.applicationId}\n状态：${status.status || "未知"}\n审批人：${status.approver || "待分配"}\n备注：${status.remark || "无"}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `❌ 查询失败：${error.message}` }],
+                    isError: true,
+                };
+            }
+        },
+    });
+    console.error('✅ 已注册 4 个工具：beisen_submit_overtime, beisen_get_leave_balance, beisen_query_attendance, beisen_get_approval_status');
 }
 /**
  * 插件停用函数
  */
-async function deactivate() {
+async function unregister() {
     console.error('🏢 北森 EHR 插件已停用');
 }
-/**
- * 配置变更回调
- */
-async function onConfigChange(config) {
-    console.error('🔄 北森 EHR 配置已更新');
-    await activate(undefined, config);
-}
 // 导出插件入口
 const plugin = {
     id: pluginId,
     version: pluginVersion,
-    activate,
-    deactivate,
-    onConfigChange,
+    register,
+    unregister,
 };
 
-exports.activate = activate;
-exports.deactivate = deactivate;
 exports.default = plugin;
 exports.defaultConfig = defaultConfig;
-exports.onConfigChange = onConfigChange;
 exports.pluginId = pluginId;
 exports.pluginVersion = pluginVersion;
+exports.register = register;
+exports.unregister = unregister;
 //# sourceMappingURL=index.cjs.js.map