@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/esm/type/record/record.mjs

@@ -0,0 +1,92 @@
+/*--------------------------------------------------------------------------
+
+@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 { Object } from '../object/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Union } from '../union/index.mjs';
+import { IsTemplateLiteralFinite, TemplateLiteralParseExact } from '../template-literal/index.mjs';
+import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
+import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { IsUndefined } from '../guard/value.mjs';
+import { TUnion as IsUnionType, TTemplateLiteral as IsTemplateLiteralType, TLiteral as IsLiteralType, TString as IsStringType, TInteger as IsIntegerType, TNumber as IsNumberType } from '../guard/type.mjs';
+// ------------------------------------------------------------------
+// FromPattern | FromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPattern(pattern, T) {
+    return { [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: CloneType(T) } };
+}
+// prettier-ignore
+function FromKeys(keys, T) {
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: CloneType(T) }), {});
+    return Object(properties, { [Hint]: 'Record' });
+}
+// prettier-ignore
+function FromTemplateLiteralKey(K, T) {
+    const expression = TemplateLiteralParseExact(K.pattern);
+    return (IsTemplateLiteralFinite(expression)
+        ? FromKeys(IndexedKeyResolve(K), T)
+        : FromPattern(K.pattern, T));
+}
+// prettier-ignore
+function FromUnionKey(K, T) {
+    return FromKeys(IndexedKeyResolve(Union(K)), T);
+}
+// prettier-ignore
+function FromLiteralKey(K, T) {
+    return FromKeys([K.toString()], T);
+}
+// prettier-ignore
+function FromStringKey(K, T) {
+    const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
+    return FromPattern(pattern, T);
+}
+// prettier-ignore
+function FromIntegerKey(_, T) {
+    return FromPattern(PatternNumberExact, T);
+}
+// prettier-ignore
+function FromNumberKey(_, T) {
+    return FromPattern(PatternNumberExact, T);
+}
+// prettier-ignore
+export function RecordResolve(K, T) {
+    return (IsUnionType(K) ? FromUnionKey(K.anyOf, T) :
+        IsTemplateLiteralType(K) ? FromTemplateLiteralKey(K, T) :
+            IsLiteralType(K) ? FromLiteralKey(K.const, T) :
+                IsStringType(K) ? FromStringKey(K, T) :
+                    IsIntegerType(K) ? FromIntegerKey(K, T) :
+                        IsNumberType(K) ? FromNumberKey(K, T) :
+                            Never());
+}
+// prettier-ignore
+/** `[Json]` Creates a Record type */
+export function Record(K, T, options = {}) {
+    return CloneType(RecordResolve(K, T), options);
+}

package/esm/type/recursive/index.d.mts

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

package/esm/type/recursive/index.mjs

@@ -0,0 +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 './recursive.mjs';

package/esm/type/recursive/recursive.d.mts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { Static } from '../static/index.mjs';
+export interface TThis extends TSchema {
+    [Kind]: 'This';
+    static: this['params'][0];
+    $ref: string;
+}
+export type RecursiveResolve<T extends TSchema> = Static<T, [RecursiveResolve<T>]>;
+export interface TRecursive<T extends TSchema> extends TSchema {
+    [Hint]: 'Recursive';
+    static: RecursiveResolve<T>;
+}
+/** `[Json]` Creates a Recursive type */
+export declare function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;

package/esm/type/recursive/recursive.mjs

@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@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 { IsUndefined } from '../guard/value.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+// Auto Tracked For Recursive Types without ID's
+let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
+export function Recursive(callback, options = {}) {
+    if (IsUndefined(options.$id))
+        options.$id = `T${Ordinal++}`;
+    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
+    thisType.$id = options.$id;
+    return CloneType({
+        ...options,
+        [Hint]: 'Recursive',
+        ...thisType,
+    });
+}

package/esm/type/ref/index.d.mts

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

package/esm/type/ref/index.mjs

@@ -0,0 +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 './ref.mjs';

package/esm/type/ref/ref.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TRef<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Ref';
+    static: Static<T, this['params']>;
+    $ref: string;
+}
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+export declare function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+/** `[Json]` Creates a Ref type. */
+export declare function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;

package/esm/type/ref/ref.mjs

@@ -0,0 +1,41 @@
+/*--------------------------------------------------------------------------
+
+@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 { IsString, IsUndefined } from '../guard/value.mjs';
+/** `[Json]` Creates a Ref type. */
+export function Ref(unresolved, options = {}) {
+    if (IsString(unresolved))
+        return { ...options, [Kind]: 'Ref', $ref: unresolved };
+    if (IsUndefined(unresolved.$id))
+        throw new Error('Reference target type must specify an $id');
+    return {
+        ...options,
+        [Kind]: 'Ref',
+        $ref: unresolved.$id,
+    };
+}

package/esm/type/regexp/index.d.mts

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

package/esm/type/regexp/index.mjs

@@ -0,0 +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 './regexp.mjs';

package/esm/type/regexp/regexp.d.mts

@@ -0,0 +1,7 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TString } from '../string/index.mjs';
+export type TRegExp = TString;
+/** `[JavaScript]` Creates a String type from a Regular Expression pattern */
+export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+/** `[JavaScript]` Creates a String type from a Regular Expression */
+export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;

package/esm/type/regexp/regexp.mjs

@@ -0,0 +1,34 @@
+/*--------------------------------------------------------------------------
+
+@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 { IsString } from '../guard/value.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a String type */
+export function RegExp(unresolved, options = {}) {
+    const pattern = IsString(unresolved) ? unresolved : unresolved.source;
+    return { ...options, [Kind]: 'String', type: 'string', pattern };
+}

package/esm/type/registry/format.d.mts

@@ -0,0 +1,13 @@
+export type FormatRegistryValidationFunction = (value: string) => boolean;
+/** Returns the entries in this registry */
+export declare function Entries(): Map<string, FormatRegistryValidationFunction>;
+/** Clears all user defined string formats */
+export declare function Clear(): void;
+/** Deletes a registered format */
+export declare function Delete(format: string): boolean;
+/** Returns true if the user defined string format exists */
+export declare function Has(format: string): boolean;
+/** Sets a validation function for a user defined string format */
+export declare function Set(format: string, func: FormatRegistryValidationFunction): void;
+/** Gets a validation function for a user defined string format */
+export declare function Get(format: string): FormatRegistryValidationFunction | undefined;

package/esm/type/registry/format.mjs

@@ -0,0 +1,53 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+/** A registry for user defined string formats */
+const map = new Map();
+/** Returns the entries in this registry */
+export function Entries() {
+    return new Map(map);
+}
+/** Clears all user defined string formats */
+export function Clear() {
+    return map.clear();
+}
+/** Deletes a registered format */
+export function Delete(format) {
+    return map.delete(format);
+}
+/** Returns true if the user defined string format exists */
+export function Has(format) {
+    return map.has(format);
+}
+/** Sets a validation function for a user defined string format */
+export function Set(format, func) {
+    map.set(format, func);
+}
+/** Gets a validation function for a user defined string format */
+export function Get(format) {
+    return map.get(format);
+}

package/esm/type/registry/index.d.mts

@@ -0,0 +1,2 @@
+export * as FormatRegistry from './format.mjs';
+export * as TypeRegistry from './type.mjs';

package/esm/type/registry/index.mjs

@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@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 * as FormatRegistry from './format.mjs';
+export * as TypeRegistry from './type.mjs';

package/esm/type/registry/type.d.mts

@@ -0,0 +1,13 @@
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** Returns the entries in this registry */
+export declare function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
+/** Clears all user defined types */
+export declare function Clear(): void;
+/** Deletes a registered type */
+export declare function Delete(kind: string): boolean;
+/** Returns true if this registry contains this kind */
+export declare function Has(kind: string): boolean;
+/** Sets a validation function for a user defined type */
+export declare function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+/** Gets a custom validation function for a user defined type */
+export declare function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;

package/esm/type/registry/type.mjs

@@ -0,0 +1,53 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+/** A registry for user defined types */
+const map = new Map();
+/** Returns the entries in this registry */
+export function Entries() {
+    return new Map(map);
+}
+/** Clears all user defined types */
+export function Clear() {
+    return map.clear();
+}
+/** Deletes a registered type */
+export function Delete(kind) {
+    return map.delete(kind);
+}
+/** Returns true if this registry contains this kind */
+export function Has(kind) {
+    return map.has(kind);
+}
+/** Sets a validation function for a user defined type */
+export function Set(kind, func) {
+    map.set(kind, func);
+}
+/** Gets a custom validation function for a user defined type */
+export function Get(kind) {
+    return map.get(kind);
+}

package/esm/type/required/index.d.mts

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

package/esm/type/required/index.mjs

@@ -0,0 +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 './required.mjs';

package/esm/type/required/required.d.mts

@@ -0,0 +1,23 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromIntersect<R>] : []);
+declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromUnion<R>] : []);
+declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
+type FromProperties<T extends TProperties> = Evaluate<{
+    [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
+}>;
+declare function FromProperties<T extends TProperties>(T: T): TProperties;
+export type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+export declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
+export type TRequired<T extends TSchema> = RequiredResolve<T>;
+/** `[Json]` Constructs a type where all properties are required */
+export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
+export {};

package/esm/type/required/required.mjs

@@ -0,0 +1,67 @@
+/*--------------------------------------------------------------------------
+
+@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 { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Object } from '../object/index.mjs';
+import { OptionalKind, TransformKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+// prettier-ignore
+function FromIntersect(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [RequiredResolve(L), ...FromIntersect(R)]
+        : []);
+}
+// prettier-ignore
+function FromUnion(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [RequiredResolve(L), ...FromUnion(R)]
+        : []);
+}
+// prettier-ignore
+function FromProperties(T) {
+    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
+        return { ...Acc, [K]: Discard(T[K], [OptionalKind]) };
+    }, {});
+}
+// prettier-ignore
+export function RequiredResolve(T) {
+    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
+        IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
+            IsObjectType(T) ? Object(FromProperties(T.properties)) :
+                Object({}));
+}
+/** `[Json]` Constructs a type where all properties are required */
+export function Required(T, options = {}) {
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(RequiredResolve(T), options);
+    return { ...D, ...R };
+}

package/esm/type/rest/index.d.mts

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