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

package/build/import/type/intersect/intersect.d.mts

@@ -1,21 +1,6 @@
-import type { TupleToIntersect, AssertType } from '../helpers/index.mjs';
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { OptionalFromIntersect } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-export type IntersectResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromIntersect<T>);
-export declare function IntersectResolve<T extends TSchema[]>(T: T): IntersectResolve<T>;
-export type TUnevaluatedProperties = undefined | TSchema | boolean;
-export interface IntersectOptions extends SchemaOptions {
-    unevaluatedProperties?: TUnevaluatedProperties;
-}
-export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
-    [Kind]: 'Intersect';
-    static: TupleToIntersect<{
-        [K in keyof T]: Static<AssertType<T[K]>, this['params']>;
-    }>;
-    type?: 'object';
-    allOf: [...T];
-}
-export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+import { TIntersect, IntersectOptions } from './intersect-type.mjs';
+export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+/** `[Json]` Creates an evaluated Intersect type */
+export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;

package/build/import/type/intersect/intersect.mjs

@@ -1,25 +1,45 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+import { CloneType } from '../clone/type.mjs';
 import { Never } from '../never/index.mjs';
-import { OptionalFromIntersect } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-import { CloneType, CloneRest } from '../clone/type.mjs';
-import { TTransform as IsTransformType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
-export function IntersectResolve(T) {
-    return (T.length === 0
-        ? Never()
-        : T.length === 1
-            ? T[0]
-            : OptionalFromIntersect(T));
-}
+import { IntersectCreate } from './intersect-create.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { TTransform as IsTransformType, } from '../guard/type.mjs';
+/** `[Json]` Creates an evaluated Intersect type */
 export function Intersect(T, options = {}) {
     if (T.length === 0)
-        return Never();
+        return Never(options);
     if (T.length === 1)
         return CloneType(T[0], options);
     if (T.some((schema) => IsTransformType(schema)))
         throw new Error('Cannot intersect transform types');
-    const allObjects = T.every((schema) => IsObjectType(schema));
-    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties) ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } : {};
-    return (options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
-        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
-        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) });
+    return IntersectCreate(T, options);
 }

package/build/import/type/intrinsic/capitalize.d.mts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>;
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
 export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;

package/build/import/type/intrinsic/capitalize.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
 export function Capitalize(T, options = {}) {
     return Intrinsic(T, 'Capitalize', options);
 }

package/build/import/type/intrinsic/index.mjs

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './capitalize.mjs';
 export * from './intrinsic-from-mapped-key.mjs';
 export * from './intrinsic.mjs';

package/build/import/type/intrinsic/intrinsic-from-mapped-key.mjs

@@ -1,20 +1,51 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { MappedResult } from '../mapped/index.mjs';
 import { Intrinsic } from './intrinsic.mjs';
 import { Literal } from '../literal/index.mjs';
+// prettier-ignore
 function MappedIntrinsicPropertyKey(K, M, options) {
     return {
         [K]: Intrinsic(Literal(K), M, options)
     };
 }
+// prettier-ignore
 function MappedIntrinsicPropertyKeys(K, M, options) {
     const [L, ...R] = K;
     return (K.length > 0
         ? { ...MappedIntrinsicPropertyKey(L, M, options), ...MappedIntrinsicPropertyKeys(R, M, options) }
         : {});
 }
+// prettier-ignore
 function MappedIntrinsicProperties(T, M, options) {
     return MappedIntrinsicPropertyKeys(T['keys'], M, options);
 }
+// prettier-ignore
 export function IntrinsicFromMappedKey(T, M, options) {
     const P = MappedIntrinsicProperties(T, M, options);
     return MappedResult(P);

package/build/import/type/intrinsic/intrinsic.d.mts

@@ -12,6 +12,8 @@ declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): st
 type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
 declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
 export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+/** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
+/** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>;
 export {};

package/build/import/type/intrinsic/intrinsic.mjs

@@ -1,8 +1,42 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
 import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
 function ApplyUncapitalize(value) {
     const [first, rest] = [value.slice(0, 1), value.slice(1)];
     return [first.toLowerCase(), rest].join('');
@@ -18,6 +52,8 @@ function ApplyLowercase(value) {
     return value.toLowerCase();
 }
 function FromTemplateLiteral(schema, mode, options) {
+    // note: template literals require special runtime handling as they are encoded in string patterns.
+    // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = TemplateLiteralParseExact(schema.pattern);
     const finite = IsTemplateLiteralFinite(expression);
     if (!finite)
@@ -28,6 +64,7 @@ function FromTemplateLiteral(schema, mode, options) {
     const union = Union(mapped);
     return TemplateLiteral([union], options);
 }
+// prettier-ignore
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
         mode === 'Capitalize' ? ApplyCapitalize(value) :
@@ -39,8 +76,13 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
 }
+/** Applies an intrinsic string manipulation to the given type. */
 export function Intrinsic(schema, mode, options = {}) {
-    return (IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+    // prettier-ignore
+    return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        // Standard-Inference
         IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode, schema) :
             IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode), options) :
                 IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :

package/build/import/type/intrinsic/lowercase.d.mts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TLowercase<T extends TSchema> = TIntrinsic<T, 'Lowercase'>;
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
 export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;

package/build/import/type/intrinsic/lowercase.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
 export function Lowercase(T, options = {}) {
     return Intrinsic(T, 'Lowercase', options);
 }

package/build/import/type/intrinsic/uncapitalize.d.mts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TUncapitalize<T extends TSchema> = TIntrinsic<T, 'Uncapitalize'>;
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;

package/build/import/type/intrinsic/uncapitalize.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 export function Uncapitalize(T, options = {}) {
     return Intrinsic(T, 'Uncapitalize', options);
 }

package/build/import/type/intrinsic/uppercase.d.mts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TUppercase<T extends TSchema> = TIntrinsic<T, 'Uppercase'>;
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
 export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;

package/build/import/type/intrinsic/uppercase.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
 export function Uppercase(T, options = {}) {
     return Intrinsic(T, 'Uppercase', options);
 }

package/build/import/type/iterator/index.mjs

@@ -1 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './iterator.mjs';

package/build/import/type/iterator/iterator.d.mts

@@ -7,4 +7,5 @@ export interface TIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'Iterator';
     items: T;
 }
+/** `[JavaScript]` Creates an Iterator type */
 export declare function Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;

package/build/import/type/iterator/iterator.mjs

@@ -1,5 +1,33 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[JavaScript]` Creates an Iterator type */
 export function Iterator(items, options = {}) {
     return {
         ...options,

package/build/import/type/keyof/index.mjs

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './keyof-from-mapped-result.mjs';
 export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

package/build/import/type/keyof/keyof-from-mapped-result.mjs

@@ -1,13 +1,43 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { MappedResult } from '../mapped/index.mjs';
 import { KeyOf } from './keyof.mjs';
+// prettier-ignore
 function FromProperties(K, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: KeyOf(K[K2], options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, options) {
     return FromProperties(K.properties, options);
 }
+// prettier-ignore
 export function KeyOfFromMappedResult(T, options) {
     const P = FromMappedResult(T, options);
     return MappedResult(P);

package/build/import/type/keyof/keyof-property-keys.d.mts

@@ -23,6 +23,8 @@ type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
 declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
 export type KeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
 ]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
 export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): KeyOfPropertyKeys<T>;
+/** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};