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

package/build/import/type/guard/type.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.
+
+---------------------------------------------------------------------------*/
 import * as ValueGuard from './value.mjs';
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
 export class TypeGuardUnknownTypeError extends Error {
@@ -80,16 +107,27 @@ function IsOptionalFormat(value) {
 function IsOptionalSchema(value) {
     return ValueGuard.IsUndefined(value) || TSchema(value);
 }
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+/** Returns true if this value has a Readonly symbol */
 export function TReadonly(value) {
     return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
 }
+/** Returns true if this value has a Optional symbol */
 export function TOptional(value) {
     return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
 }
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
 export function TAny(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TArray */
 export function TArray(value) {
     return (TKindOf(value, 'Array') &&
         value.type === 'array' &&
@@ -102,13 +140,17 @@ export function TArray(value) {
         IsOptionalNumber(value.minContains) &&
         IsOptionalNumber(value.maxContains));
 }
+/** Returns true if the given value is TAsyncIterator */
 export function TAsyncIterator(value) {
+    // prettier-ignore
     return (TKindOf(value, 'AsyncIterator') &&
         value.type === 'AsyncIterator' &&
         IsOptionalString(value.$id) &&
         TSchema(value.items));
 }
+/** Returns true if the given value is TBigInt */
 export function TBigInt(value) {
+    // prettier-ignore
     return (TKindOf(value, 'BigInt') &&
         value.type === 'bigint' &&
         IsOptionalString(value.$id) &&
@@ -118,12 +160,16 @@ export function TBigInt(value) {
         IsOptionalBigInt(value.minimum) &&
         IsOptionalBigInt(value.multipleOf));
 }
+/** Returns true if the given value is TBoolean */
 export function TBoolean(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Boolean') &&
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TConstructor */
 export function TConstructor(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Constructor') &&
         value.type === 'Constructor' &&
         IsOptionalString(value.$id) &&
@@ -131,6 +177,7 @@ export function TConstructor(value) {
         value.parameters.every(schema => TSchema(schema)) &&
         TSchema(value.returns));
 }
+/** Returns true if the given value is TDate */
 export function TDate(value) {
     return (TKindOf(value, 'Date') &&
         value.type === 'Date' &&
@@ -141,7 +188,9 @@ export function TDate(value) {
         IsOptionalNumber(value.minimumTimestamp) &&
         IsOptionalNumber(value.multipleOfTimestamp));
 }
+/** Returns true if the given value is TFunction */
 export function TFunction(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Function') &&
         value.type === 'Function' &&
         IsOptionalString(value.$id) &&
@@ -149,6 +198,7 @@ export function TFunction(value) {
         value.parameters.every(schema => TSchema(schema)) &&
         TSchema(value.returns));
 }
+/** Returns true if the given value is TInteger */
 export function TInteger(value) {
     return (TKindOf(value, 'Integer') &&
         value.type === 'integer' &&
@@ -159,11 +209,15 @@ export function TInteger(value) {
         IsOptionalNumber(value.minimum) &&
         IsOptionalNumber(value.multipleOf));
 }
+/** Returns true if the given schema is TProperties */
 export function TProperties(value) {
+    // prettier-ignore
     return (ValueGuard.IsObject(value) &&
         Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema)));
 }
+/** Returns true if the given value is TIntersect */
 export function TIntersect(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Intersect') &&
         (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
         ValueGuard.IsArray(value.allOf) &&
@@ -172,54 +226,74 @@ export function TIntersect(value) {
         (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TIterator */
 export function TIterator(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Iterator') &&
         value.type === 'Iterator' &&
         IsOptionalString(value.$id) &&
         TSchema(value.items));
 }
+/** Returns true if the given value is a TKind with the given name. */
 export function TKindOf(value, kind) {
     return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind;
 }
+/** Returns true if the given value is TLiteral<string> */
 export function TLiteralString(value) {
     return TLiteral(value) && ValueGuard.IsString(value.const);
 }
+/** Returns true if the given value is TLiteral<number> */
 export function TLiteralNumber(value) {
     return TLiteral(value) && ValueGuard.IsNumber(value.const);
 }
+/** Returns true if the given value is TLiteral<boolean> */
 export function TLiteralBoolean(value) {
     return TLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
+/** Returns true if the given value is TLiteral */
 export function TLiteral(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Literal') &&
         IsOptionalString(value.$id) && TLiteralValue(value.const));
 }
+/** Returns true if the given value is a TLiteralValue */
 export function TLiteralValue(value) {
     return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
 }
+/** Returns true if the given value is a TMappedKey */
 export function TMappedKey(value) {
+    // prettier-ignore
     return (TKindOf(value, 'MappedKey') &&
         ValueGuard.IsArray(value.keys) &&
         value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
 }
+/** Returns true if the given value is TMappedResult */
 export function TMappedResult(value) {
+    // prettier-ignore
     return (TKindOf(value, 'MappedResult') &&
         TProperties(value.properties));
 }
+/** Returns true if the given value is TNever */
 export function TNever(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Never') &&
         ValueGuard.IsObject(value.not) &&
         Object.getOwnPropertyNames(value.not).length === 0);
 }
+/** Returns true if the given value is TNot */
 export function TNot(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Not') &&
         TSchema(value.not));
 }
+/** Returns true if the given value is TNull */
 export function TNull(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Null') &&
         value.type === 'null' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TNumber */
 export function TNumber(value) {
     return (TKindOf(value, 'Number') &&
         value.type === 'number' &&
@@ -230,7 +304,9 @@ export function TNumber(value) {
         IsOptionalNumber(value.minimum) &&
         IsOptionalNumber(value.multipleOf));
 }
+/** Returns true if the given value is TObject */
 export function TObject(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Object') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
@@ -239,13 +315,17 @@ export function TObject(value) {
         IsOptionalNumber(value.minProperties) &&
         IsOptionalNumber(value.maxProperties));
 }
+/** Returns true if the given value is TPromise */
 export function TPromise(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Promise') &&
         value.type === 'Promise' &&
         IsOptionalString(value.$id) &&
         TSchema(value.item));
 }
+/** Returns true if the given value is TRecord */
 export function TRecord(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Record') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
@@ -259,15 +339,20 @@ export function TRecord(value) {
                 TSchema(schema.patternProperties[keys[0]]));
         })(value));
 }
+/** Returns true if this value is TRecursive */
 export function TRecursive(value) {
     return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
 }
+/** Returns true if the given value is TRef */
 export function TRef(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Ref') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
+/** Returns true if the given value is TString */
 export function TString(value) {
+    // prettier-ignore
     return (TKindOf(value, 'String') &&
         value.type === 'string' &&
         IsOptionalString(value.$id) &&
@@ -276,76 +361,101 @@ export function TString(value) {
         IsOptionalPattern(value.pattern) &&
         IsOptionalFormat(value.format));
 }
+/** Returns true if the given value is TSymbol */
 export function TSymbol(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Symbol') &&
         value.type === 'symbol' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TTemplateLiteral */
 export function TTemplateLiteral(value) {
+    // prettier-ignore
     return (TKindOf(value, 'TemplateLiteral') &&
         value.type === 'string' &&
         ValueGuard.IsString(value.pattern) &&
         value.pattern[0] === '^' &&
         value.pattern[value.pattern.length - 1] === '$');
 }
+/** Returns true if the given value is TThis */
 export function TThis(value) {
+    // prettier-ignore
     return (TKindOf(value, 'This') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
+/** Returns true of this value is TTransform */
 export function TTransform(value) {
     return ValueGuard.IsObject(value) && TransformKind in value;
 }
+/** Returns true if the given value is TTuple */
 export function TTuple(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Tuple') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsNumber(value.minItems) &&
         ValueGuard.IsNumber(value.maxItems) &&
         value.minItems === value.maxItems &&
-        ((ValueGuard.IsUndefined(value.items) &&
+        (( // empty
+        ValueGuard.IsUndefined(value.items) &&
             ValueGuard.IsUndefined(value.additionalItems) &&
             value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
             value.items.every(schema => TSchema(schema)))));
 }
+/** Returns true if the given value is TUndefined */
 export function TUndefined(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Undefined') &&
         value.type === 'undefined' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
 export function TUnionLiteral(value) {
     return TUnion(value) && value.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
 }
+/** Returns true if the given value is TUnion */
 export function TUnion(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Union') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsObject(value) &&
         ValueGuard.IsArray(value.anyOf) &&
         value.anyOf.every(schema => TSchema(schema)));
 }
+/** Returns true if the given value is TUint8Array */
 export function TUint8Array(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Uint8Array') &&
         value.type === 'Uint8Array' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.minByteLength) &&
         IsOptionalNumber(value.maxByteLength));
 }
+/** Returns true if the given value is TUnknown */
 export function TUnknown(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Unknown') &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is a raw TUnsafe */
 export function TUnsafe(value) {
     return TKindOf(value, 'Unsafe');
 }
+/** Returns true if the given value is TVoid */
 export function TVoid(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Void') &&
         value.type === 'void' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TKind */
 export function TKind(value) {
     return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
+/** Returns true if the given value is TSchema */
 export function TSchema(value) {
+    // prettier-ignore
     return (ValueGuard.IsObject(value)) && (TAny(value) ||
         TArray(value) ||
         TBoolean(value) ||

package/build/import/type/guard/value.d.mts

@@ -1,14 +1,28 @@
+/** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+/** Returns true if this value is an array */
 export declare function IsArray(value: unknown): value is unknown[];
+/** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is a boolean */
 export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is a Date object */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is a function */
 export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+/** Returns true if this value is null */
 export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is number */
 export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an object */
 export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is symbol */
 export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a Uint8Array */
 export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if this value is undefined */
 export declare function IsUndefined(value: unknown): value is undefined;

package/build/import/type/guard/value.mjs

@@ -1,42 +1,83 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+/** Returns true if this value is an async iterator */
 export function IsAsyncIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
 }
+/** Returns true if this value is an array */
 export function IsArray(value) {
     return Array.isArray(value);
 }
+/** Returns true if this value is bigint */
 export function IsBigInt(value) {
     return typeof value === 'bigint';
 }
+/** Returns true if this value is a boolean */
 export function IsBoolean(value) {
     return typeof value === 'boolean';
 }
+/** Returns true if this value is a Date object */
 export function IsDate(value) {
     return value instanceof globalThis.Date;
 }
+/** Returns true if this value is a function */
 export function IsFunction(value) {
     return typeof value === 'function';
 }
+/** Returns true if this value is an iterator */
 export function IsIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
 }
+/** Returns true if this value is null */
 export function IsNull(value) {
     return value === null;
 }
+/** Returns true if this value is number */
 export function IsNumber(value) {
     return typeof value === 'number';
 }
+/** Returns true if this value is an object */
 export function IsObject(value) {
     return typeof value === 'object' && value !== null;
 }
+/** Returns true if this value is string */
 export function IsString(value) {
     return typeof value === 'string';
 }
+/** Returns true if this value is symbol */
 export function IsSymbol(value) {
     return typeof value === 'symbol';
 }
+/** Returns true if this value is a Uint8Array */
 export function IsUint8Array(value) {
     return value instanceof globalThis.Uint8Array;
 }
+/** Returns true if this value is undefined */
 export function IsUndefined(value) {
     return value === undefined;
 }

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

@@ -34,6 +34,7 @@ type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
 type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
 type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
 export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+/** Increments the given string value + 1 */
 export declare function Increment<T extends string>(T: T): Increment<T>;
 export type AssertProperties<T> = T extends TProperties ? T : TProperties;
 export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];

package/build/import/type/helpers/helpers.mjs

@@ -1,3 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+/** Increments the given string value + 1 */
 export function Increment(T) {
     return (parseInt(T) + 1).toString();
 }

package/build/import/type/helpers/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 './helpers.mjs';

package/build/import/type/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 './any/index.mjs';
 export * from './array/index.mjs';
 export * from './async-iterator/index.mjs';

package/build/import/type/indexed/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 './indexed-from-mapped-key.mjs';
 export * from './indexed-property-keys.mjs';
 export * from './indexed-result.mjs';

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

@@ -1,17 +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 { IndexResult } from './indexed-result.mjs';
 import { MappedResult } from '../mapped/index.mjs';
+// 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]: 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
 export function IndexFromMappedKey(T, K, options) {
     const P = MappedIndexProperties(T, K, options);
     return MappedResult(P);

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

@@ -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 {};