@sinclair/typebox 0.32.0-dev-15 → 0.32.0-dev-17

package/build/require/type/indexed/indexed-from-mapped-key.js

@@ -1,20 +1,54 @@
 "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.IndexFromMappedKey = void 0;
 const indexed_result_1 = require("./indexed-result");
 const index_1 = require("../mapped/index");
+// prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
+    // todo: propogate options into index result. This type looks like it
+    // could use a clean up, possibly inlining it into indexed.ts to
+    // bring it inline with other mapping types.
     return { [K]: (0, indexed_result_1.IndexResult)(T, [K], options) };
 }
+// prettier-ignore
 function MappedIndexPropertyKeys(T, K, options) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) }
+        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) } // TS 5.4-dev
         : {});
 }
+// 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 (0, index_1.MappedResult)(P);

package/build/require/type/indexed/indexed-property-keys.d.ts

@@ -12,5 +12,6 @@ type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] :
 declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
 export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T>;
 export {};

package/build/require/type/indexed/indexed-property-keys.js

@@ -1,8 +1,40 @@
 "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.IndexPropertyKeys = void 0;
 const index_1 = require("../template-literal/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// prettier-ignore
 function FromTemplateLiteral(T) {
     const E = (0, index_1.TemplateLiteralParseExact)(T.pattern);
     const F = (0, index_1.IsTemplateLiteralFinite)(E);
@@ -13,15 +45,19 @@ function FromTemplateLiteral(T) {
             : []
         : []);
 }
+// prettier-ignore
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [...IndexPropertyKeys(L), ...FromUnion(R)]
         : []);
 }
+// prettier-ignore
 function FromLiteral(T) {
     return ([T.toString()]);
 }
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
 function IndexPropertyKeys(T) {
     return [...new Set(((0, type_1.TTemplateLiteral)(T) ? FromTemplateLiteral(T) :
             (0, type_1.TUnion)(T) ? FromUnion(T.anyOf) :

package/build/require/type/indexed/indexed-result.d.ts

@@ -6,19 +6,19 @@ import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TTuple } from '../tuple/index';
 import { type TArray } from '../array/index';
-import { IntersectResolve } from '../intersect/index';
-import { UnionResolve } from '../union/index';
+import { IntersectEvaluated } from '../intersect/index';
+import { UnionEvaluated } from '../union/index';
 type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
 declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
 type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
 declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
-type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectResolve<FromIntersectRest<FromRest<T, K>>>);
+type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
 type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
 declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
-type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionResolve<FromUnionRest<FromRest<T, K>>>);
+type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
 declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
-type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionResolve<T> : TNever);
+type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
 declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
 type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
 declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
@@ -28,6 +28,6 @@ type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<i
 declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
 type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
 declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
+export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
 export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): TIndexResult<T, K>;
 export {};

package/build/require/type/indexed/indexed-result.js

@@ -1,17 +1,50 @@
 "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.IndexResult = void 0;
 const index_1 = require("../never/index");
 const index_2 = require("../intersect/index");
 const index_3 = require("../union/index");
 const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function FromRest(T, K) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [FromKey(L, K), ...FromRest(R, K)]
         : []);
 }
+// prettier-ignore
 function FromIntersectRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -20,9 +53,11 @@ function FromIntersectRest(T) {
             : [L, ...FromIntersectRest(R)]
         : []);
 }
+// prettier-ignore
 function FromIntersect(T, K) {
-    return ((0, index_2.IntersectResolve)(FromIntersectRest(FromRest(T, K))));
+    return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
 }
+// prettier-ignore
 function FromUnionRest(T, S = T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -31,24 +66,29 @@ function FromUnionRest(T, S = T) {
             : FromUnionRest(R, S)
         : S);
 }
+// prettier-ignore
 function FromUnion(T, K) {
-    return ((0, index_3.UnionResolve)(FromUnionRest(FromRest(T, K))));
+    return ((0, index_3.UnionEvaluated)(FromUnionRest(FromRest(T, K))));
 }
+// prettier-ignore
 function FromTuple(T, K) {
     return (K in T ? T[K] :
-        K === '[number]' ? (0, index_3.UnionResolve)(T) :
+        K === '[number]' ? (0, index_3.UnionEvaluated)(T) :
             (0, index_1.Never)());
 }
+// prettier-ignore
 function FromArray(T, K) {
     return (K === '[number]'
         ? T
         : (0, index_1.Never)());
 }
+// prettier-ignore
 function FromProperty(T, K) {
     return (K in T
         ? T[K]
         : (0, index_1.Never)());
 }
+// prettier-ignore
 function FromKey(T, K) {
     return ((0, type_2.TIntersect)(T) ? FromIntersect(T.allOf, K) :
         (0, type_2.TUnion)(T) ? FromUnion(T.anyOf, K) :
@@ -57,13 +97,15 @@ function FromKey(T, K) {
                     (0, type_2.TObject)(T) ? FromProperty(T.properties, K) :
                         (0, index_1.Never)());
 }
+// prettier-ignore
 function FromKeys(T, K) {
     const [L, ...R] = K;
     return (K.length > 0
         ? [FromKey(T, L), ...FromKeys(T, R)]
         : []);
 }
+// prettier-ignore
 function IndexResult(T, K, options) {
-    return ((0, type_1.CloneType)((0, index_3.UnionResolve)(FromKeys(T, K)), options));
+    return ((0, type_1.CloneType)((0, index_3.UnionEvaluated)(FromKeys(T, K)), options));
 }
 exports.IndexResult = IndexResult;

package/build/require/type/indexed/indexed.d.ts

@@ -4,6 +4,9 @@ import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
 import { TMappedKey } from '../mapped/index';
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = TIndexResult<T, K>;
+/** `[Json]` Returns an indexed mapped key result */
 export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;

package/build/require/type/indexed/indexed.js

@@ -1,14 +1,47 @@
 "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.Index = void 0;
-const type_1 = require("../guard/type");
 const indexed_result_1 = require("./indexed-result");
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
-const type_2 = require("../clone/type");
+const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+const type_2 = require("../guard/type");
+/** `[Json]` Returns an Indexed property type for the given keys */
 function Index(T, K, options = {}) {
-    return ((0, type_1.TMappedKey)(K) ? (0, type_2.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
-        (0, type_1.TSchema)(K) ? (0, indexed_result_1.IndexResult)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K), options) :
+    // prettier-ignore
+    return ((0, type_2.TMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
+        (0, type_2.TSchema)(K) ? (0, indexed_result_1.IndexResult)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K), options) :
             (0, indexed_result_1.IndexResult)(T, K, options));
 }
 exports.Index = Index;

package/build/require/type/instance-type/index.js

@@ -1,4 +1,31 @@
 "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);

package/build/require/type/instance-type/instance-type.d.ts

@@ -1,4 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TConstructor } from '../constructor/index';
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 export declare function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;

package/build/require/type/instance-type/instance-type.js

@@ -1,7 +1,35 @@
 "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.InstanceType = void 0;
 const type_1 = require("../clone/type");
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 function InstanceType(schema, options = {}) {
     return (0, type_1.CloneType)(schema.returns, options);
 }

package/build/require/type/integer/index.js

@@ -1,4 +1,31 @@
 "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);

package/build/require/type/integer/integer.d.ts

@@ -12,4 +12,5 @@ export interface TInteger extends TSchema, IntegerOptions {
     static: number;
     type: 'integer';
 }
+/** `[Json]` Creates an Integer type */
 export declare function Integer(options?: IntegerOptions): TInteger;

package/build/require/type/integer/integer.js

@@ -1,7 +1,35 @@
 "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.Integer = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates an Integer type */
 function Integer(options = {}) {
     return {
         ...options,

package/build/require/type/intersect/index.d.ts

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

package/build/require/type/intersect/index.js

@@ -1,4 +1,31 @@
 "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);
@@ -14,4 +41,6 @@ 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("./intersect-evaluated"), exports);
+__exportStar(require("./intersect-type"), exports);
 __exportStar(require("./intersect"), exports);

package/build/require/type/intersect/intersect-create.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../schema/index';
+import type { TIntersect, IntersectOptions } from './intersect-type';
+export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions): TIntersect<T>;

package/build/require/type/intersect/intersect-create.js

@@ -0,0 +1,51 @@
+"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.IntersectCreate = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+const type_2 = require("../guard/type");
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntersectCreate(T, options) {
+    const allObjects = T.every((schema) => (0, type_2.TObject)(schema));
+    const clonedUnevaluatedProperties = (0, type_2.TSchema)(options.unevaluatedProperties)
+        ? { unevaluatedProperties: (0, type_1.CloneType)(options.unevaluatedProperties) }
+        : {};
+    return ((options.unevaluatedProperties === false || (0, type_2.TSchema)(options.unevaluatedProperties) || allObjects
+        ? { ...options, ...clonedUnevaluatedProperties, [index_1.Kind]: 'Intersect', type: 'object', allOf: (0, type_1.CloneRest)(T) }
+        : { ...options, ...clonedUnevaluatedProperties, [index_1.Kind]: 'Intersect', allOf: (0, type_1.CloneRest)(T) }));
+}
+exports.IntersectCreate = IntersectCreate;

package/build/require/type/intersect/intersect-evaluated.d.ts

@@ -0,0 +1,17 @@
+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 { TIntersect, IntersectOptions } from './intersect-type';
+type IsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? IsIntersectOptional<R> : false : true);
+declare function IsIntersectOptional<T extends TSchema[]>(T: T): IsIntersectOptional<T>;
+type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
+declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
+type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
+declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
+type ResolveIntersect<T extends TSchema[]> = (IsIntersectOptional<T> extends true ? TOptional<TIntersect<RemoveOptionalFromRest<T>>> : TIntersect<RemoveOptionalFromRest<T>>);
+declare function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): ResolveIntersect<T>;
+export type IntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveIntersect<T>);
+/** `[Json]` Creates an evaluated Intersect type */
+export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export {};