typebox 1.0.31 → 1.0.33

package/build/esm/type/script/token/internal/char.d.mts

@@ -0,0 +1,73 @@
+export type TAlpha = [
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z'
+];
+export declare const Alpha: TAlpha;
+export type TZero = typeof Zero;
+export type TNonZero = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];
+export type TDigit = [TZero, ...TNonZero];
+export declare const Zero = "0";
+export declare const NonZero: TNonZero;
+export declare const Digit: TDigit;
+export declare const WhiteSpace = " ";
+export declare const NewLine = "\n";
+export declare const UnderScore = "_";
+export declare const Dot = ".";
+export declare const DollarSign = "$";
+export declare const Hyphen = "-";
+export type TWhiteSpace = typeof WhiteSpace;
+export type TNewLine = typeof NewLine;
+export type TUnderScore = typeof UnderScore;
+export type TDot = typeof Dot;
+export type TDollarSign = typeof DollarSign;
+export type THyphen = typeof Hyphen;

package/build/esm/type/script/token/internal/result.d.mts

@@ -0,0 +1,2 @@
+/** Checks the value is a Tuple-2 [string, string] result */
+export declare function IsResult(value: unknown): value is [string, string];

package/build/esm/type/script/token/internal/take.d.mts

@@ -0,0 +1,6 @@
+type TTakeVariant<Variant extends string, Input extends string> = (Input extends `${Variant}${infer Rest extends string}` ? [Variant, Rest] : []);
+/** Takes one of the given variants or fail */
+export type TTake<Variants extends string[], Input extends string> = (Variants extends [infer ValueLeft extends string, ...infer ValueRight extends string[]] ? TTakeVariant<ValueLeft, Input> extends [infer Take extends string, infer Rest extends string] ? [Take, Rest] : TTake<ValueRight, Input> : []);
+/** Takes one of the given variants or fail */
+export declare function Take<Variants extends string[], Input extends string>(variants: [...Variants], input: Input): TTake<Variants, Input>;
+export {};

package/build/esm/type/script/token/until.d.mts

@@ -0,0 +1,6 @@
+type TIsEnd<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsEnd<Right, Input> : false);
+/** Match Input until but not including End. No match if End not found. */
+export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (Input extends `` ? [] : TIsEnd<End, Input> extends true ? [Result, Input] : Input extends `${infer Left extends string}${infer Right extends string}` ? TUntil<End, Right, `${Result}${Left}`> : []);
+/** Match Input until but not including End. No match if End not found. */
+export declare function Until<End extends string[], Input extends string>(end: [...End], input: Input, result?: string): TUntil<End, Input>;
+export {};

package/build/esm/type/types/object.d.mts

@@ -0,0 +1,20 @@
+import { type StaticDirection } from './static.mjs';
+import { type TSchema, type TObjectOptions } from './schema.mjs';
+import { type TProperties, type TRequiredArray, type StaticProperties } from './properties.mjs';
+export type StaticObject<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, _This extends TProperties, Properties extends TProperties, Result = keyof Properties extends never ? object : StaticProperties<Stack, Direction, Context, Properties, Properties>> = Result;
+/** Represents an Object type. */
+export interface TObject<Properties extends TProperties = TProperties> extends TSchema {
+    '~kind': 'Object';
+    type: 'object';
+    properties: Properties;
+    required: TRequiredArray<Properties>;
+}
+/** Creates an Object type. */
+declare function _Object_<Properties extends TProperties>(properties: Properties, options?: TObjectOptions): TObject<Properties>;
+/** `[Json]` Creates an Object type */
+export declare var Object: typeof _Object_;
+/** Returns true if the given value is TObject. */
+export declare function IsObject(value: unknown): value is TObject;
+/** Extracts options from a TObject. */
+export declare function ObjectOptions(type: TObject): TObjectOptions;
+export {};

package/build/esm/type/types/object.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+import { RequiredArray } from './properties.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Object type. */
+function _Object_(properties, options = {}) {
+    const requiredKeys = RequiredArray(properties);
+    const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
+    return Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
+}
+/** `[Json]` Creates an Object type */
+export var Object = _Object_; // Required for CommonJS ES Interop
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TObject. */
+export function IsObject(value) {
+    return IsKind(value, 'Object');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TObject. */
+export function ObjectOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'properties', 'required']);
+}

package/build/esm/type/types/schema.d.mts

@@ -0,0 +1,199 @@
+export interface TSchema {
+}
+export declare function IsKind<Kind extends string>(value: unknown, kind: Kind): value is {
+    ['~kind']: Kind;
+};
+export declare function IsSchema(value: unknown): value is TSchema;
+export interface TSchemaOptions {
+    /**
+     * Allows for additional, unlisted properties to be included, typically for extensibility.
+     */
+    [key: PropertyKey]: unknown;
+    /**
+     * Specifies the URI of a JSON Schema that the current schema adheres to.
+     */
+    $schema?: string;
+    /**
+     * A URI that serves as a unique identifier for the schema.
+     */
+    $id?: string;
+    /**
+     * A short explanation about the purpose of the data described by the schema.
+     */
+    title?: string;
+    /**
+     * A detailed explanation of the data described by the schema.
+     */
+    description?: string;
+    /**
+     * A default value for the data, used when no value is provided.
+     */
+    default?: unknown;
+    /**
+     * Provides one or more examples of valid data conforming to the schema.
+     */
+    examples?: unknown;
+    /**
+     * Indicates that the data should only be readable and not modified.
+     */
+    readOnly?: boolean;
+    /**
+     * Indicates that the data should only be writable and not read back.
+     */
+    writeOnly?: boolean;
+    /**
+     * A schema to apply conditionally: if the data validates against this schema, 'then' applies.
+     */
+    if?: TSchema;
+    /**
+     * A schema to apply if the data validates against the 'if' schema.
+     */
+    then?: TSchema;
+    /**
+     * A schema to apply if the data does not validate against the 'if' schema.
+     */
+    else?: TSchema;
+}
+export interface TObjectOptions extends TSchemaOptions {
+    /**
+     * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.
+     */
+    additionalProperties?: TSchema | boolean;
+    /**
+     * The minimum number of properties required in the object.
+     */
+    minProperties?: number;
+    /**
+     * The maximum number of properties allowed in the object.
+     */
+    maxProperties?: number;
+    /**
+     * Defines conditional requirements for properties.
+     */
+    dependencies?: Record<string, boolean | TSchema | string[]>;
+    /**
+     * Specifies properties that *must* be present if a given property is present.
+     */
+    dependentRequired?: Record<string, string[]>;
+    /**
+     * Defines schemas that apply if a specific property is present.
+     */
+    dependentSchemas?: Record<string, TSchema>;
+    /**
+     * Maps regular expressions to schemas properties matching a pattern must validate against the schema.
+     */
+    patternProperties?: Record<string, TSchema>;
+    /**
+     * A schema that all property names within the object must validate against.
+     */
+    propertyNames?: TSchema;
+}
+export interface TArrayOptions extends TSchemaOptions {
+    /**
+     * The minimum number of items allowed in the array.
+     */
+    minItems?: number;
+    /**
+     * The maximum number of items allowed in the array.
+     */
+    maxItems?: number;
+    /**
+     * A schema that at least one item in the array must validate against.
+     */
+    contains?: TSchema;
+    /**
+     * The minimum number of array items that must validate against the `contains` schema.
+     */
+    minContains?: number;
+    /**
+     * The maximum number of array items that may validate against the `contains` schema.
+     */
+    maxContains?: number;
+    /**
+     * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.
+     */
+    prefixItems?: TSchema[];
+    /**
+     * If `true`, all items in the array must be unique.
+     */
+    uniqueItems?: boolean;
+}
+export interface TTupleOptions extends TArrayOptions {
+    /**
+     * A schema to apply to any items in the array that were not validated by `prefixItems` or `items`. If `false`, no additional items are allowed.
+     */
+    unevaluatedItems?: TSchema | boolean;
+}
+export interface TIntersectOptions extends TSchemaOptions {
+    /**
+     * A schema to apply to any properties in the object that were not validated by other keywords like `properties`, `patternProperties`, or `additionalProperties`. If `false`, no additional properties are allowed.
+     */
+    unevaluatedProperties?: TSchema | boolean;
+}
+export interface TNumberOptions extends TSchemaOptions {
+    /**
+     * Specifies an exclusive upper limit for the number (number must be less than this value).
+     */
+    exclusiveMaximum?: number | bigint;
+    /**
+     * Specifies an exclusive lower limit for the number (number must be greater than this value).
+     */
+    exclusiveMinimum?: number | bigint;
+    /**
+     * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).
+     */
+    maximum?: number | bigint;
+    /**
+     * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).
+     */
+    minimum?: number | bigint;
+    /**
+     * Specifies that the number must be a multiple of this value.
+     */
+    multipleOf?: number | bigint;
+}
+export type TFormat = 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | ({} & string);
+export interface TStringOptions extends TSchemaOptions {
+    /**
+     * Specifies the expected string format.
+     *
+     * Common values include:
+     * - `base64` – Base64-encoded string.
+     * - `date-time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time format.
+     * - `date` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date (YYYY-MM-DD).
+     * - `duration` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) duration format.
+     * - `email` – RFC 5321/5322 compliant email address.
+     * - `hostname` – RFC 1034/1035 compliant host name.
+     * - `idn-email` – Internationalized email address.
+     * - `idn-hostname` – Internationalized host name.
+     * - `ipv4` – IPv4 address.
+     * - `ipv6` – IPv6 address.
+     * - `iri` / `iri-reference` – Internationalized Resource Identifier.
+     * - `json-pointer` / `json-pointer-uri-fragment` – JSON Pointer format.
+     * - `json-string` – String containing valid JSON.
+     * - `regex` – Regular expression syntax.
+     * - `relative-json-pointer` – Relative JSON Pointer format.
+     * - `time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time (HH:MM:SS).
+     * - `uri-reference` / `uri-template` – URI reference or template.
+     * - `url` – Web URL format.
+     * - `uuid` – RFC 4122 UUID string.
+     *
+     * May also be a custom format string.
+     */
+    format?: TFormat;
+    /**
+     * Specifies the minimum number of characters allowed in the string.
+     * Must be a non-negative integer.
+     */
+    minLength?: number;
+    /**
+     * Specifies the maximum number of characters allowed in the string.
+     * Must be a non-negative integer.
+     */
+    maxLength?: number;
+    /**
+     * Specifies a regular expression pattern that the string value must match.
+     * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.
+     */
+    pattern?: string | RegExp;
+}

package/build/esm/value/clone/clone.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
+ */
+export declare function Clone<Value extends unknown>(value: Value): Value;

package/build/esm/value/convert/try/try-result.d.mts

@@ -0,0 +1,8 @@
+export type TResult<Value extends unknown = unknown> = TOk<Value> | TFail;
+export type TFail = undefined;
+export type TOk<Value extends unknown = unknown> = {
+    value: Value;
+};
+export declare function IsOk<Result extends TResult>(value: Result): value is Exclude<Result, TFail>;
+export declare function Ok<Value extends unknown>(value: Value): TOk<Value>;
+export declare function Fail(): undefined;

package/build/esm/value/equal/equal.d.mts

@@ -0,0 +1,2 @@
+/** Returns true if left and right values are structurally equal */
+export declare function Equal(left: unknown, right: unknown): boolean;

package/build/esm/value/hash/hash.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Computes a unique 64-bit hash of the specified value and returns the hex string representation. This
+ * function internally uses a non-cryptographic FNV1A64 algorithm for hashing. Hashing is implemented
+ * via structural traversal of the value.
+ */
+export declare function Hash(value: unknown): string;

package/build/esm/value/mutate/error.d.mts

@@ -0,0 +1,3 @@
+export declare class MutateError extends Error {
+    constructor(message: string);
+}

package/build/esm/value/mutate/mutate.d.mts

@@ -0,0 +1,9 @@
+export type TMutable = {
+    [key: string]: unknown;
+} | unknown[];
+/**
+ * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
+ * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
+ * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
+ */
+export declare function Mutate(current: TMutable, next: TMutable): void;

package/build/esm/value/pointer/pointer.d.mts

@@ -0,0 +1,17 @@
+type ObjectLike = Record<PropertyKey, any>;
+/** Transforms a pointer into navigable key components */
+export declare function Format(pointer: string): IterableIterator<string>;
+/**
+ * Sets the value at the given pointer and returns the updated value. If the pointer
+ * path does not exist, the path will be created.
+ */
+export declare function Set(value: ObjectLike, pointer: string, update: unknown): ObjectLike;
+/**
+ * Deletes a value at the given pointer and returns the updated value.
+ */
+export declare function Delete(value: ObjectLike, pointer: string): ObjectLike;
+/** Returns true if a property or element exists at the given pointer */
+export declare function Has(value: ObjectLike, pointer: string): boolean;
+/** Gets the value at the given pointer or undefined if not exists. */
+export declare function Get(value: ObjectLike, pointer: string): unknown | undefined;
+export {};

package/compile/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/compile/index.js",
+  "types": "../build/cjs/compile/index.d.ts"
+}

package/error/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/error/index.js",
+  "types": "../build/cjs/error/index.d.ts"
+}

package/format/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/format/index.js",
+  "types": "../build/cjs/format/index.d.ts"
+}

package/guard/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/guard/index.js",
+  "types": "../build/cjs/guard/index.d.ts"
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -12,75 +12,112 @@
     "type": "git",
     "url": "https://github.com/sinclairzx81/typebox"
   },
-  "type": "module",
-  "types": "./build/index.d.mts",
-  "module": "./build/index.mjs",
+  "type": "commonjs",
+  "types": "./build/cjs/index.d.ts",
+  "main": "./build/cjs/index.js",
+  "module": "./build/esm/index.mjs",
   "exports": {
     "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
+      "require": {
+        "default": "./build/cjs/guard/index.js"
+      },
+      "import": {
+        "default": "./build/esm/guard/index.mjs"
+      }
     },
     "./schema": {
-      "import": "./build/schema/index.mjs",
-      "default": "./build/schema/index.mjs"
+      "require": {
+        "default": "./build/cjs/schema/index.js"
+      },
+      "import": {
+        "default": "./build/esm/schema/index.mjs"
+      }
     },
     "./value": {
-      "import": "./build/value/index.mjs",
-      "default": "./build/value/index.mjs"
+      "require": {
+        "default": "./build/cjs/value/index.js"
+      },
+      "import": {
+        "default": "./build/esm/value/index.mjs"
+      }
     },
     "./format": {
-      "import": "./build/format/index.mjs",
-      "default": "./build/format/index.mjs"
+      "require": {
+        "default": "./build/cjs/format/index.js"
+      },
+      "import": {
+        "default": "./build/esm/format/index.mjs"
+      }
     },
     "./type": {
-      "import": "./build/type/index.mjs",
-      "default": "./build/type/index.mjs"
+      "require": {
+        "default": "./build/cjs/type/index.js"
+      },
+      "import": {
+        "default": "./build/esm/type/index.mjs"
+      }
     },
     "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
+      "require": {
+        "default": "./build/cjs/error/index.js"
+      },
+      "import": {
+        "default": "./build/esm/error/index.mjs"
+      }
     },
     "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
+      "require": {
+        "default": "./build/cjs/system/index.js"
+      },
+      "import": {
+        "default": "./build/esm/system/index.mjs"
+      }
     },
     "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
+      "require": {
+        "default": "./build/cjs/compile/index.js"
+      },
+      "import": {
+        "default": "./build/esm/compile/index.mjs"
+      }
     },
     ".": {
-      "import": "./build/index.mjs",
-      "default": "./build/index.mjs"
+      "require": {
+        "default": "./build/cjs/index.js"
+      },
+      "import": {
+        "default": "./build/esm/index.mjs"
+      }
     }
   },
   "typesVersions": {
     "*": {
       "guard": [
-        "./build/guard/index.d.mts"
+        "./build/esm/guard/index.d.mts"
       ],
       "schema": [
-        "./build/schema/index.d.mts"
+        "./build/esm/schema/index.d.mts"
       ],
       "value": [
-        "./build/value/index.d.mts"
+        "./build/esm/value/index.d.mts"
       ],
       "format": [
-        "./build/format/index.d.mts"
+        "./build/esm/format/index.d.mts"
       ],
       "type": [
-        "./build/type/index.d.mts"
+        "./build/esm/type/index.d.mts"
       ],
       "error": [
-        "./build/error/index.d.mts"
+        "./build/esm/error/index.d.mts"
       ],
       "system": [
-        "./build/system/index.d.mts"
+        "./build/esm/system/index.d.mts"
       ],
       "compile": [
-        "./build/compile/index.d.mts"
+        "./build/esm/compile/index.d.mts"
       ],
       ".": [
-        "./build/./index.d.mts"
+        "./build/esm/index.d.mts"
       ]
     }
   }

package/schema/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/schema/index.js",
+  "types": "../build/cjs/schema/index.d.ts"
+}

package/system/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/system/index.js",
+  "types": "../build/cjs/system/index.d.ts"
+}

package/type/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/type/index.js",
+  "types": "../build/cjs/type/index.d.ts"
+}

package/value/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/value/index.js",
+  "types": "../build/cjs/value/index.d.ts"
+}

package/build/type/engine/object/from-intersect.d.mts

@@ -1,14 +0,0 @@
-import { Memory } from '../../../system/memory/index.mjs';
-import { type TSchema } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
-type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, LeftProperties extends TProperties = {
-    [Key in LeftKeys]: Left[Key];
-}, RightProperties extends TProperties = {
-    [Key in RightKeys]: Right[Key];
-}, Result extends TProperties = Memory.TAssign<LeftProperties, RightProperties>> = Result;
-export type TFromIntersect<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, TCollapseIntersectProperties<Result, TFromType<Left>>> : {
-    [Key in keyof Result]: Result[Key];
-});
-export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;
-export {};

package/build/type/engine/object/from-intersect.mjs

@@ -1,17 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../../system/memory/index.mjs';
-import { Guard } from '../../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
-function CollapseIntersectProperties(left, right) {
-    const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));
-    const rightKeys = Guard.Keys(right).filter((key) => !Guard.HasPropertyKey(left, key));
-    const leftProperties = leftKeys.reduce((result, key) => Memory.Assign(result, { [key]: left[key] }), {});
-    const rightProperties = rightKeys.reduce((result, key) => Memory.Assign(result, { [key]: right[key] }), {});
-    const result = Memory.Assign(leftProperties, rightProperties);
-    return result;
-}
-export function FromIntersect(types) {
-    return types.reduce((result, left) => {
-        return CollapseIntersectProperties(result, FromType(left));
-    }, {});
-}

package/build/type/engine/object/from-union.d.mts

@@ -1,12 +0,0 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
-import { type TSchema } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
-import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-import { type TFromType } from './from-type.mjs';
-type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
-    [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]>;
-}> = Result;
-type TReduceVariants<Types extends TSchema[], Result extends TProperties> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TCollapseUnionProperties<Result, TFromType<Left>>> : Result);
-export type TFromUnion<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TFromType<Left>> : TUnreachable);
-export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;
-export {};