@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/type/type/json.js

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonTypeBuilder = void 0;
+const index_1 = require("../any/index");
+const index_2 = require("../array/index");
+const index_3 = require("../boolean/index");
+const index_4 = require("../composite/index");
+const index_5 = require("../const/index");
+const index_6 = require("../enum/index");
+const index_7 = require("../exclude/index");
+const index_8 = require("../extends/index");
+const index_9 = require("../extract/index");
+const index_10 = require("../indexed/index");
+const index_11 = require("../integer/index");
+const index_12 = require("../intersect/index");
+const index_13 = require("../intrinsic/index");
+const index_14 = require("../keyof/index");
+const index_15 = require("../literal/index");
+const index_16 = require("../mapped/index");
+const index_17 = require("../never/index");
+const index_18 = require("../not/index");
+const index_19 = require("../null/index");
+const index_20 = require("../module/index");
+const index_21 = require("../number/index");
+const index_22 = require("../object/index");
+const index_23 = require("../omit/index");
+const index_24 = require("../optional/index");
+const index_25 = require("../partial/index");
+const index_26 = require("../pick/index");
+const index_27 = require("../readonly/index");
+const index_28 = require("../readonly-optional/index");
+const index_29 = require("../record/index");
+const index_30 = require("../recursive/index");
+const index_31 = require("../ref/index");
+const index_32 = require("../required/index");
+const index_33 = require("../rest/index");
+const index_34 = require("../string/index");
+const index_35 = require("../template-literal/index");
+const index_36 = require("../transform/index");
+const index_37 = require("../tuple/index");
+const index_38 = require("../union/index");
+const index_39 = require("../unknown/index");
+const index_40 = require("../unsafe/index");
+/** Json Type Builder with Static Resolution for TypeScript */
+class JsonTypeBuilder {
+    // ------------------------------------------------------------------------
+    // Modifiers
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates a Readonly and Optional property */
+    ReadonlyOptional(type) {
+        return (0, index_28.ReadonlyOptional)(type);
+    }
+    /** `[Json]` Creates a Readonly property */
+    Readonly(type, enable) {
+        return (0, index_27.Readonly)(type, enable ?? true);
+    }
+    /** `[Json]` Creates a Optional property */
+    Optional(type, enable) {
+        return (0, index_24.Optional)(type, enable ?? true);
+    }
+    // ------------------------------------------------------------------------
+    // Types
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates an Any type */
+    Any(options) {
+        return (0, index_1.Any)(options);
+    }
+    /** `[Json]` Creates an Array type */
+    Array(items, options) {
+        return (0, index_2.Array)(items, options);
+    }
+    /** `[Json]` Creates a Boolean type */
+    Boolean(options) {
+        return (0, index_3.Boolean)(options);
+    }
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
+    Capitalize(schema, options) {
+        return (0, index_13.Capitalize)(schema, options);
+    }
+    /** `[Json]` Creates a Composite object type */
+    Composite(schemas, options) {
+        return (0, index_4.Composite)(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
+    }
+    /** `[JavaScript]` Creates a readonly const type from the given value. */
+    Const(value, options) {
+        return (0, index_5.Const)(value, options);
+    }
+    /** `[Json]` Creates a Enum type */
+    Enum(item, options) {
+        return (0, index_6.Enum)(item, options);
+    }
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude(unionType, excludedMembers, options) {
+        return (0, index_7.Exclude)(unionType, excludedMembers, options);
+    }
+    /** `[Json]` Creates a Conditional type */
+    Extends(L, R, T, F, options) {
+        return (0, index_8.Extends)(L, R, T, F, options);
+    }
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract(type, union, options) {
+        return (0, index_9.Extract)(type, union, options);
+    }
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index(type, key, options) {
+        return (0, index_10.Index)(type, key, options);
+    }
+    /** `[Json]` Creates an Integer type */
+    Integer(options) {
+        return (0, index_11.Integer)(options);
+    }
+    /** `[Json]` Creates an Intersect type */
+    Intersect(types, options) {
+        return (0, index_12.Intersect)(types, options);
+    }
+    /** `[Json]` Creates a KeyOf type */
+    KeyOf(type, options) {
+        return (0, index_14.KeyOf)(type, options);
+    }
+    /** `[Json]` Creates a Literal type */
+    Literal(literalValue, options) {
+        return (0, index_15.Literal)(literalValue, options);
+    }
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+    Lowercase(type, options) {
+        return (0, index_13.Lowercase)(type, options);
+    }
+    /** `[Json]` Creates a Mapped object type */
+    Mapped(key, map, options) {
+        return (0, index_16.Mapped)(key, map, options);
+    }
+    /** `[Json]` Creates a Type Definition Module. */
+    Module(properties) {
+        return (0, index_20.Module)(properties);
+    }
+    /** `[Json]` Creates a Never type */
+    Never(options) {
+        return (0, index_17.Never)(options);
+    }
+    /** `[Json]` Creates a Not type */
+    Not(type, options) {
+        return (0, index_18.Not)(type, options);
+    }
+    /** `[Json]` Creates a Null type */
+    Null(options) {
+        return (0, index_19.Null)(options);
+    }
+    /** `[Json]` Creates a Number type */
+    Number(options) {
+        return (0, index_21.Number)(options);
+    }
+    /** `[Json]` Creates an Object type */
+    Object(properties, options) {
+        return (0, index_22.Object)(properties, options);
+    }
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
+    Omit(schema, selector, options) {
+        return (0, index_23.Omit)(schema, selector, options);
+    }
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial(type, options) {
+        return (0, index_25.Partial)(type, options);
+    }
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick(type, key, options) {
+        return (0, index_26.Pick)(type, key, options);
+    }
+    /** `[Json]` Creates a Record type */
+    Record(key, value, options) {
+        return (0, index_29.Record)(key, value, options);
+    }
+    /** `[Json]` Creates a Recursive type */
+    Recursive(callback, options) {
+        return (0, index_30.Recursive)(callback, options);
+    }
+    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+    Ref(...args) {
+        return (0, index_31.Ref)(args[0], args[1]);
+    }
+    /** `[Json]` Constructs a type where all properties are required */
+    Required(type, options) {
+        return (0, index_32.Required)(type, options);
+    }
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+    Rest(type) {
+        return (0, index_33.Rest)(type);
+    }
+    /** `[Json]` Creates a String type */
+    String(options) {
+        return (0, index_34.String)(options);
+    }
+    /** `[Json]` Creates a TemplateLiteral type */
+    TemplateLiteral(unresolved, options) {
+        return (0, index_35.TemplateLiteral)(unresolved, options);
+    }
+    /** `[Json]` Creates a Transform type */
+    Transform(type) {
+        return (0, index_36.Transform)(type);
+    }
+    /** `[Json]` Creates a Tuple type */
+    Tuple(types, options) {
+        return (0, index_37.Tuple)(types, options);
+    }
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+    Uncapitalize(type, options) {
+        return (0, index_13.Uncapitalize)(type, options);
+    }
+    /** `[Json]` Creates a Union type */
+    Union(types, options) {
+        return (0, index_38.Union)(types, options);
+    }
+    /** `[Json]` Creates an Unknown type */
+    Unknown(options) {
+        return (0, index_39.Unknown)(options);
+    }
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+    Unsafe(options) {
+        return (0, index_40.Unsafe)(options);
+    }
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
+    Uppercase(schema, options) {
+        return (0, index_13.Uppercase)(schema, options);
+    }
+}
+exports.JsonTypeBuilder = JsonTypeBuilder;

package/build/cjs/type/type/type.d.ts

@@ -0,0 +1,59 @@
+export { Any } from '../any/index';
+export { Argument } from '../argument/index';
+export { Array } from '../array/index';
+export { AsyncIterator } from '../async-iterator/index';
+export { Awaited } from '../awaited/index';
+export { BigInt } from '../bigint/index';
+export { Boolean } from '../boolean/index';
+export { Composite } from '../composite/index';
+export { Const } from '../const/index';
+export { Constructor } from '../constructor/index';
+export { ConstructorParameters } from '../constructor-parameters/index';
+export { Date } from '../date/index';
+export { Enum } from '../enum/index';
+export { Exclude } from '../exclude/index';
+export { Extends } from '../extends/index';
+export { Extract } from '../extract/index';
+export { Function } from '../function/index';
+export { Index } from '../indexed/index';
+export { InstanceType } from '../instance-type/index';
+export { Instantiate } from '../instantiate/index';
+export { Integer } from '../integer/index';
+export { Intersect } from '../intersect/index';
+export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index';
+export { Iterator } from '../iterator/index';
+export { KeyOf } from '../keyof/index';
+export { Literal } from '../literal/index';
+export { Mapped } from '../mapped/index';
+export { Module } from '../module/index';
+export { Never } from '../never/index';
+export { Not } from '../not/index';
+export { Null } from '../null/index';
+export { Number } from '../number/index';
+export { Object } from '../object/index';
+export { Omit } from '../omit/index';
+export { Optional } from '../optional/index';
+export { Parameters } from '../parameters/index';
+export { Partial } from '../partial/index';
+export { Pick } from '../pick/index';
+export { Promise } from '../promise/index';
+export { Readonly } from '../readonly/index';
+export { ReadonlyOptional } from '../readonly-optional/index';
+export { Record } from '../record/index';
+export { Recursive } from '../recursive/index';
+export { Ref } from '../ref/index';
+export { RegExp } from '../regexp/index';
+export { Required } from '../required/index';
+export { Rest } from '../rest/index';
+export { ReturnType } from '../return-type/index';
+export { String } from '../string/index';
+export { Symbol } from '../symbol/index';
+export { TemplateLiteral } from '../template-literal/index';
+export { Transform } from '../transform/index';
+export { Tuple } from '../tuple/index';
+export { Uint8Array } from '../uint8array/index';
+export { Undefined } from '../undefined/index';
+export { Union } from '../union/index';
+export { Unknown } from '../unknown/index';
+export { Unsafe } from '../unsafe/index';
+export { Void } from '../void/index';

package/build/cjs/type/type/type.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Module = exports.Mapped = exports.Literal = exports.KeyOf = exports.Iterator = exports.Uppercase = exports.Lowercase = exports.Uncapitalize = exports.Capitalize = exports.Intersect = exports.Integer = exports.Instantiate = exports.InstanceType = exports.Index = exports.Function = exports.Extract = exports.Extends = exports.Exclude = exports.Enum = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Argument = exports.Any = void 0;
+exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.Transform = exports.TemplateLiteral = exports.Symbol = exports.String = exports.ReturnType = void 0;
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
+var index_1 = require("../any/index");
+Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return index_1.Any; } });
+var index_2 = require("../argument/index");
+Object.defineProperty(exports, "Argument", { enumerable: true, get: function () { return index_2.Argument; } });
+var index_3 = require("../array/index");
+Object.defineProperty(exports, "Array", { enumerable: true, get: function () { return index_3.Array; } });
+var index_4 = require("../async-iterator/index");
+Object.defineProperty(exports, "AsyncIterator", { enumerable: true, get: function () { return index_4.AsyncIterator; } });
+var index_5 = require("../awaited/index");
+Object.defineProperty(exports, "Awaited", { enumerable: true, get: function () { return index_5.Awaited; } });
+var index_6 = require("../bigint/index");
+Object.defineProperty(exports, "BigInt", { enumerable: true, get: function () { return index_6.BigInt; } });
+var index_7 = require("../boolean/index");
+Object.defineProperty(exports, "Boolean", { enumerable: true, get: function () { return index_7.Boolean; } });
+var index_8 = require("../composite/index");
+Object.defineProperty(exports, "Composite", { enumerable: true, get: function () { return index_8.Composite; } });
+var index_9 = require("../const/index");
+Object.defineProperty(exports, "Const", { enumerable: true, get: function () { return index_9.Const; } });
+var index_10 = require("../constructor/index");
+Object.defineProperty(exports, "Constructor", { enumerable: true, get: function () { return index_10.Constructor; } });
+var index_11 = require("../constructor-parameters/index");
+Object.defineProperty(exports, "ConstructorParameters", { enumerable: true, get: function () { return index_11.ConstructorParameters; } });
+var index_12 = require("../date/index");
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return index_12.Date; } });
+var index_13 = require("../enum/index");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return index_13.Enum; } });
+var index_14 = require("../exclude/index");
+Object.defineProperty(exports, "Exclude", { enumerable: true, get: function () { return index_14.Exclude; } });
+var index_15 = require("../extends/index");
+Object.defineProperty(exports, "Extends", { enumerable: true, get: function () { return index_15.Extends; } });
+var index_16 = require("../extract/index");
+Object.defineProperty(exports, "Extract", { enumerable: true, get: function () { return index_16.Extract; } });
+var index_17 = require("../function/index");
+Object.defineProperty(exports, "Function", { enumerable: true, get: function () { return index_17.Function; } });
+var index_18 = require("../indexed/index");
+Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_18.Index; } });
+var index_19 = require("../instance-type/index");
+Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return index_19.InstanceType; } });
+var index_20 = require("../instantiate/index");
+Object.defineProperty(exports, "Instantiate", { enumerable: true, get: function () { return index_20.Instantiate; } });
+var index_21 = require("../integer/index");
+Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return index_21.Integer; } });
+var index_22 = require("../intersect/index");
+Object.defineProperty(exports, "Intersect", { enumerable: true, get: function () { return index_22.Intersect; } });
+var index_23 = require("../intrinsic/index");
+Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return index_23.Capitalize; } });
+Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return index_23.Uncapitalize; } });
+Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return index_23.Lowercase; } });
+Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function () { return index_23.Uppercase; } });
+var index_24 = require("../iterator/index");
+Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return index_24.Iterator; } });
+var index_25 = require("../keyof/index");
+Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_25.KeyOf; } });
+var index_26 = require("../literal/index");
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_26.Literal; } });
+var index_27 = require("../mapped/index");
+Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return index_27.Mapped; } });
+var index_28 = require("../module/index");
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return index_28.Module; } });
+var index_29 = require("../never/index");
+Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return index_29.Never; } });
+var index_30 = require("../not/index");
+Object.defineProperty(exports, "Not", { enumerable: true, get: function () { return index_30.Not; } });
+var index_31 = require("../null/index");
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return index_31.Null; } });
+var index_32 = require("../number/index");
+Object.defineProperty(exports, "Number", { enumerable: true, get: function () { return index_32.Number; } });
+var index_33 = require("../object/index");
+Object.defineProperty(exports, "Object", { enumerable: true, get: function () { return index_33.Object; } });
+var index_34 = require("../omit/index");
+Object.defineProperty(exports, "Omit", { enumerable: true, get: function () { return index_34.Omit; } });
+var index_35 = require("../optional/index");
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return index_35.Optional; } });
+var index_36 = require("../parameters/index");
+Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_36.Parameters; } });
+var index_37 = require("../partial/index");
+Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return index_37.Partial; } });
+var index_38 = require("../pick/index");
+Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return index_38.Pick; } });
+var index_39 = require("../promise/index");
+Object.defineProperty(exports, "Promise", { enumerable: true, get: function () { return index_39.Promise; } });
+var index_40 = require("../readonly/index");
+Object.defineProperty(exports, "Readonly", { enumerable: true, get: function () { return index_40.Readonly; } });
+var index_41 = require("../readonly-optional/index");
+Object.defineProperty(exports, "ReadonlyOptional", { enumerable: true, get: function () { return index_41.ReadonlyOptional; } });
+var index_42 = require("../record/index");
+Object.defineProperty(exports, "Record", { enumerable: true, get: function () { return index_42.Record; } });
+var index_43 = require("../recursive/index");
+Object.defineProperty(exports, "Recursive", { enumerable: true, get: function () { return index_43.Recursive; } });
+var index_44 = require("../ref/index");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return index_44.Ref; } });
+var index_45 = require("../regexp/index");
+Object.defineProperty(exports, "RegExp", { enumerable: true, get: function () { return index_45.RegExp; } });
+var index_46 = require("../required/index");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return index_46.Required; } });
+var index_47 = require("../rest/index");
+Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_47.Rest; } });
+var index_48 = require("../return-type/index");
+Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_48.ReturnType; } });
+var index_49 = require("../string/index");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_49.String; } });
+var index_50 = require("../symbol/index");
+Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_50.Symbol; } });
+var index_51 = require("../template-literal/index");
+Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_51.TemplateLiteral; } });
+var index_52 = require("../transform/index");
+Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_52.Transform; } });
+var index_53 = require("../tuple/index");
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return index_53.Tuple; } });
+var index_54 = require("../uint8array/index");
+Object.defineProperty(exports, "Uint8Array", { enumerable: true, get: function () { return index_54.Uint8Array; } });
+var index_55 = require("../undefined/index");
+Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_55.Undefined; } });
+var index_56 = require("../union/index");
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_56.Union; } });
+var index_57 = require("../unknown/index");
+Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_57.Unknown; } });
+var index_58 = require("../unsafe/index");
+Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_58.Unsafe; } });
+var index_59 = require("../void/index");
+Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_59.Void; } });

package/build/cjs/type/uint8array/index.d.ts

@@ -0,0 +1 @@
+export * from './uint8array';

package/build/cjs/type/uint8array/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./uint8array"), exports);

package/build/cjs/type/uint8array/uint8array.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface Uint8ArrayOptions extends SchemaOptions {
+    maxByteLength?: number;
+    minByteLength?: number;
+}
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+    [Kind]: 'Uint8Array';
+    static: Uint8Array;
+    type: 'uint8array';
+}
+/** `[JavaScript]` Creates a Uint8Array type */
+export declare function Uint8Array(options?: Uint8ArrayOptions): TUint8Array;

package/build/cjs/type/uint8array/uint8array.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uint8Array = Uint8Array;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a Uint8Array type */
+function Uint8Array(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Uint8Array', type: 'Uint8Array' }, options);
+}

package/build/cjs/type/undefined/index.d.ts

@@ -0,0 +1 @@
+export * from './undefined';

package/build/cjs/type/undefined/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./undefined"), exports);

package/build/cjs/type/undefined/undefined.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TUndefined extends TSchema {
+    [Kind]: 'Undefined';
+    static: undefined;
+    type: 'undefined';
+}
+/** `[JavaScript]` Creates a Undefined type */
+export declare function Undefined(options?: SchemaOptions): TUndefined;

package/build/cjs/type/undefined/undefined.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Undefined = Undefined;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a Undefined type */
+function Undefined(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Undefined', type: 'undefined' }, options);
+}

package/build/cjs/type/union/index.d.ts

@@ -0,0 +1,3 @@
+export * from './union-evaluated';
+export * from './union-type';
+export * from './union';

package/build/cjs/type/union/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./union-evaluated"), exports);
+__exportStar(require("./union-type"), exports);
+__exportStar(require("./union"), exports);

package/build/cjs/type/union/union-create.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { TUnion } from './union-type';
+export declare function UnionCreate<T extends TSchema[]>(T: [...T], options?: SchemaOptions): TUnion<T>;

package/build/cjs/type/union/union-create.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionCreate = UnionCreate;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+function UnionCreate(T, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Union', anyOf: T }, options);
+}

package/build/cjs/type/union/union-evaluated.d.ts

@@ -0,0 +1,13 @@
+import type { SchemaOptions, TSchema } from '../schema/index';
+import { type TNever } from '../never/index';
+import { type TOptional } from '../optional/index';
+import type { TReadonly } from '../readonly/index';
+import type { TUnion } from './union-type';
+type TIsUnionOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? true : TIsUnionOptional<Right> : false);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TResolveUnion<Types extends TSchema[], Result extends TSchema[] = TRemoveOptionalFromRest<Types>, IsOptional extends boolean = TIsUnionOptional<Types>> = (IsOptional extends true ? TOptional<TUnion<Result>> : TUnion<Result>);
+export type TUnionEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveUnion<Types>);
+/** `[Json]` Creates an evaluated Union type */
+export declare function UnionEvaluated<Types extends TSchema[], Result = TUnionEvaluated<Types>>(T: [...Types], options?: SchemaOptions): Result;
+export {};

package/build/cjs/type/union/union-evaluated.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionEvaluated = UnionEvaluated;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+const index_2 = require("../discard/index");
+const index_3 = require("../never/index");
+const index_4 = require("../optional/index");
+const union_create_1 = require("./union-create");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// prettier-ignore
+function IsUnionOptional(types) {
+    return types.some(type => (0, kind_1.IsOptional)(type));
+}
+// prettier-ignore
+function RemoveOptionalFromRest(types) {
+    return types.map(left => (0, kind_1.IsOptional)(left) ? RemoveOptionalFromType(left) : left);
+}
+// prettier-ignore
+function RemoveOptionalFromType(T) {
+    return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
+}
+// prettier-ignore
+function ResolveUnion(types, options) {
+    const isOptional = IsUnionOptional(types);
+    return (isOptional
+        ? (0, index_4.Optional)((0, union_create_1.UnionCreate)(RemoveOptionalFromRest(types), options))
+        : (0, union_create_1.UnionCreate)(RemoveOptionalFromRest(types), options));
+}
+/** `[Json]` Creates an evaluated Union type */
+function UnionEvaluated(T, options) {
+    // prettier-ignore
+    return (T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
+        T.length === 0 ? (0, index_3.Never)(options) :
+            ResolveUnion(T, options));
+}

package/build/cjs/type/union/union-type.d.ts

@@ -0,0 +1,12 @@
+import type { TSchema } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: UnionStatic<T, this['params']>;
+    anyOf: T;
+}
+export {};

package/build/cjs/type/union/union-type.js

@@ -0,0 +1,4 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../symbols/index");

package/build/cjs/type/union/union.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TNever } from '../never/index';
+import type { TUnion } from './union-type';
+export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
+/** `[Json]` Creates a Union type */
+export declare function Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;