@sinclair/typebox 0.31.27 → 0.32.0-dev-1

package/type/type/json.js

@@ -0,0 +1,255 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+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("../deref/index");
+const index_7 = require("../enum/index");
+const index_8 = require("../exclude/index");
+const index_9 = require("../extends/index");
+const index_10 = require("../extract/index");
+const index_11 = require("../indexed/index");
+const index_12 = require("../integer/index");
+const index_13 = require("../intersect/index");
+const index_14 = require("../intrinsic/index");
+const index_15 = require("../keyof/index");
+const index_16 = require("../literal/index");
+const index_17 = require("../never/index");
+const index_18 = require("../not/index");
+const index_19 = require("../null/index");
+const index_20 = require("../number/index");
+const index_21 = require("../object/index");
+const index_22 = require("../omit/index");
+const index_23 = require("../optional/index");
+const index_24 = require("../partial/index");
+const index_25 = require("../pick/index");
+const index_26 = require("../readonly/index");
+const index_27 = require("../readonly-optional/index");
+const index_28 = require("../record/index");
+const index_29 = require("../recursive/index");
+const index_30 = require("../ref/index");
+const index_31 = require("../required/index");
+const index_32 = require("../rest/index");
+const index_33 = require("../strict/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 {
+    // ------------------------------------------------------------------------
+    // Strict
+    // ------------------------------------------------------------------------
+    /** `[Json]` Omits compositing symbols from this schema */
+    Strict(schema) {
+        return (0, index_33.Strict)(schema);
+    }
+    // ------------------------------------------------------------------------
+    // Modifiers
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates a Readonly and Optional property */
+    ReadonlyOptional(schema) {
+        return (0, index_27.ReadonlyOptional)(schema);
+    }
+    /** `[Json]` Creates a Readonly property */
+    Readonly(schema) {
+        return (0, index_26.Readonly)(schema);
+    }
+    /** `[Json]` Creates an Optional property */
+    Optional(schema) {
+        return (0, index_23.Optional)(schema);
+    }
+    // ------------------------------------------------------------------------
+    // Types
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates an Any type */
+    Any(options = {}) {
+        return (0, index_1.Any)(options);
+    }
+    /** `[Json]` Creates an Array type */
+    Array(schema, options = {}) {
+        return (0, index_2.Array)(schema, 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_14.Capitalize)(schema, options);
+    }
+    /** `[Json]` Creates a Composite object type */
+    Composite(objects, options) {
+        return (0, index_4.Composite)(objects, 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 dereferenced type */
+    Deref(schema, references) {
+        return (0, index_6.Deref)(schema, references);
+    }
+    /** `[Json]` Creates a Enum type */
+    Enum(item, options = {}) {
+        return (0, index_7.Enum)(item, options);
+    }
+    /** `[Json]` Creates a Conditional type */
+    Extends(left, right, trueType, falseType, options = {}) {
+        return (0, index_9.Extends)(left, right, trueType, falseType, options);
+    }
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude(unionType, excludedMembers, options = {}) {
+        return (0, index_8.Exclude)(unionType, excludedMembers, options);
+    }
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract(type, union, options = {}) {
+        return (0, index_10.Extract)(type, union, options);
+    }
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index(schema, unresolved, options = {}) {
+        return (0, index_11.Index)(schema, unresolved, options);
+    }
+    /** `[Json]` Creates an Integer type */
+    Integer(options = {}) {
+        return (0, index_12.Integer)(options);
+    }
+    /** `[Json]` Creates an Intersect type */
+    Intersect(T, options = {}) {
+        return (0, index_13.Intersect)(T, options);
+    }
+    /** `[Json]` Creates a KeyOf type */
+    KeyOf(schema, options = {}) {
+        return (0, index_15.KeyOf)(schema, options);
+    }
+    /** `[Json]` Creates a Literal type */
+    Literal(value, options = {}) {
+        return (0, index_16.Literal)(value, options);
+    }
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+    Lowercase(schema, options = {}) {
+        return (0, index_14.Lowercase)(schema, options);
+    }
+    /** `[Json]` Creates a Never type */
+    Never(options = {}) {
+        return (0, index_17.Never)(options);
+    }
+    /** `[Json]` Creates a Not type */
+    Not(schema, options) {
+        return (0, index_18.Not)(schema, options);
+    }
+    /** `[Json]` Creates a Null type */
+    Null(options = {}) {
+        return (0, index_19.Null)(options);
+    }
+    /** `[Json]` Creates a Number type */
+    Number(options = {}) {
+        return (0, index_20.Number)(options);
+    }
+    /** `[Json]` Creates an Object type */
+    Object(properties, options = {}) {
+        return (0, index_21.Object)(properties, options);
+    }
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
+    Omit(schema, unresolved, options = {}) {
+        return (0, index_22.Omit)(schema, unresolved, options);
+    }
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial(schema, options = {}) {
+        return (0, index_24.Partial)(schema, options);
+    }
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick(schema, unresolved, options = {}) {
+        return (0, index_25.Pick)(schema, unresolved, options);
+    }
+    /** `[Json]` Creates a Record type */
+    Record(key, schema, options = {}) {
+        return (0, index_28.Record)(key, schema);
+    }
+    /** `[Json]` Creates a Recursive type */
+    Recursive(callback, options = {}) {
+        return (0, index_29.Recursive)(callback, options);
+    }
+    /** `[Json]` Creates a Ref type. */
+    Ref(unresolved, options = {}) {
+        return (0, index_30.Ref)(unresolved, options);
+    }
+    /** `[Json]` Constructs a type where all properties are required */
+    Required(schema, options = {}) {
+        return (0, index_31.Required)(schema, options);
+    }
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+    Rest(schema) {
+        return (0, index_32.Rest)(schema);
+    }
+    /** `[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(schema) {
+        return (0, index_36.Transform)(schema);
+    }
+    /** `[Json]` Creates a Tuple type */
+    Tuple(items, options = {}) {
+        return (0, index_37.Tuple)(items, options);
+    }
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+    Uncapitalize(schema, options = {}) {
+        return (0, index_14.Uncapitalize)(schema, options);
+    }
+    /** `[Json]` Creates a Union type */
+    Union(schemas, options = {}) {
+        return (0, index_38.Union)(schemas, 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_14.Uppercase)(schema, options);
+    }
+}
+exports.JsonTypeBuilder = JsonTypeBuilder;

package/type/type/type.d.ts

@@ -0,0 +1,58 @@
+export { Any } from '../any/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 { Deref } from '../deref/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 { 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 { 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 { Strict } from '../strict/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/type/type/type.js

@@ -0,0 +1,153 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strict = exports.ReturnType = 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.Mapped = exports.Literal = exports.KeyOf = exports.Iterator = exports.Uppercase = exports.Lowercase = exports.Uncapitalize = exports.Capitalize = exports.Intersect = exports.Integer = exports.InstanceType = exports.Index = exports.Function = exports.Extract = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = 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 = 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("../array/index");
+Object.defineProperty(exports, "Array", { enumerable: true, get: function () { return index_2.Array; } });
+var index_3 = require("../async-iterator/index");
+Object.defineProperty(exports, "AsyncIterator", { enumerable: true, get: function () { return index_3.AsyncIterator; } });
+var index_4 = require("../awaited/index");
+Object.defineProperty(exports, "Awaited", { enumerable: true, get: function () { return index_4.Awaited; } });
+var index_5 = require("../bigint/index");
+Object.defineProperty(exports, "BigInt", { enumerable: true, get: function () { return index_5.BigInt; } });
+var index_6 = require("../boolean/index");
+Object.defineProperty(exports, "Boolean", { enumerable: true, get: function () { return index_6.Boolean; } });
+var index_7 = require("../composite/index");
+Object.defineProperty(exports, "Composite", { enumerable: true, get: function () { return index_7.Composite; } });
+var index_8 = require("../const/index");
+Object.defineProperty(exports, "Const", { enumerable: true, get: function () { return index_8.Const; } });
+var index_9 = require("../constructor/index");
+Object.defineProperty(exports, "Constructor", { enumerable: true, get: function () { return index_9.Constructor; } });
+var index_10 = require("../constructor-parameters/index");
+Object.defineProperty(exports, "ConstructorParameters", { enumerable: true, get: function () { return index_10.ConstructorParameters; } });
+var index_11 = require("../date/index");
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return index_11.Date; } });
+var index_12 = require("../deref/index");
+Object.defineProperty(exports, "Deref", { enumerable: true, get: function () { return index_12.Deref; } });
+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("../integer/index");
+Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return index_20.Integer; } });
+var index_21 = require("../intersect/index");
+Object.defineProperty(exports, "Intersect", { enumerable: true, get: function () { return index_21.Intersect; } });
+var index_22 = require("../intrinsic/index");
+Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return index_22.Capitalize; } });
+Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return index_22.Uncapitalize; } });
+Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return index_22.Lowercase; } });
+Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function () { return index_22.Uppercase; } });
+var index_23 = require("../iterator/index");
+Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return index_23.Iterator; } });
+var index_24 = require("../keyof/index");
+Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_24.KeyOf; } });
+var index_25 = require("../literal/index");
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_25.Literal; } });
+var index_26 = require("../mapped/index");
+Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return index_26.Mapped; } });
+var index_27 = require("../never/index");
+Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return index_27.Never; } });
+var index_28 = require("../not/index");
+Object.defineProperty(exports, "Not", { enumerable: true, get: function () { return index_28.Not; } });
+var index_29 = require("../null/index");
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return index_29.Null; } });
+var index_30 = require("../number/index");
+Object.defineProperty(exports, "Number", { enumerable: true, get: function () { return index_30.Number; } });
+var index_31 = require("../object/index");
+Object.defineProperty(exports, "Object", { enumerable: true, get: function () { return index_31.Object; } });
+var index_32 = require("../omit/index");
+Object.defineProperty(exports, "Omit", { enumerable: true, get: function () { return index_32.Omit; } });
+var index_33 = require("../optional/index");
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return index_33.Optional; } });
+var index_34 = require("../parameters/index");
+Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_34.Parameters; } });
+var index_35 = require("../partial/index");
+Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return index_35.Partial; } });
+var index_36 = require("../pick/index");
+Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return index_36.Pick; } });
+var index_37 = require("../promise/index");
+Object.defineProperty(exports, "Promise", { enumerable: true, get: function () { return index_37.Promise; } });
+var index_38 = require("../readonly/index");
+Object.defineProperty(exports, "Readonly", { enumerable: true, get: function () { return index_38.Readonly; } });
+var index_39 = require("../readonly-optional/index");
+Object.defineProperty(exports, "ReadonlyOptional", { enumerable: true, get: function () { return index_39.ReadonlyOptional; } });
+var index_40 = require("../record/index");
+Object.defineProperty(exports, "Record", { enumerable: true, get: function () { return index_40.Record; } });
+var index_41 = require("../recursive/index");
+Object.defineProperty(exports, "Recursive", { enumerable: true, get: function () { return index_41.Recursive; } });
+var index_42 = require("../ref/index");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return index_42.Ref; } });
+var index_43 = require("../regexp/index");
+Object.defineProperty(exports, "RegExp", { enumerable: true, get: function () { return index_43.RegExp; } });
+var index_44 = require("../required/index");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return index_44.Required; } });
+var index_45 = require("../rest/index");
+Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_45.Rest; } });
+var index_46 = require("../return-type/index");
+Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_46.ReturnType; } });
+var index_47 = require("../strict/index");
+Object.defineProperty(exports, "Strict", { enumerable: true, get: function () { return index_47.Strict; } });
+var index_48 = require("../string/index");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_48.String; } });
+var index_49 = require("../symbol/index");
+Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_49.Symbol; } });
+var index_50 = require("../template-literal/index");
+Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_50.TemplateLiteral; } });
+var index_51 = require("../transform/index");
+Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_51.Transform; } });
+var index_52 = require("../tuple/index");
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return index_52.Tuple; } });
+var index_53 = require("../uint8array/index");
+Object.defineProperty(exports, "Uint8Array", { enumerable: true, get: function () { return index_53.Uint8Array; } });
+var index_54 = require("../undefined/index");
+Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_54.Undefined; } });
+var index_55 = require("../union/index");
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_55.Union; } });
+var index_56 = require("../unknown/index");
+Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_56.Unknown; } });
+var index_57 = require("../unsafe/index");
+Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_57.Unsafe; } });
+var index_58 = require("../void/index");
+Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_58.Void; } });

package/type/uint8array/index.d.ts

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

package/type/uint8array/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+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/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/type/uint8array/uint8array.js

@@ -0,0 +1,36 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uint8Array = void 0;
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a Uint8Array type */
+function Uint8Array(options = {}) {
+    return { ...options, [index_1.Kind]: 'Uint8Array', type: 'Uint8Array' };
+}
+exports.Uint8Array = Uint8Array;

package/type/undefined/index.d.ts

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

package/type/undefined/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+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/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;