@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/type/record/index.d.ts

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

package/build/cjs/type/record/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./record"), exports);

package/build/cjs/type/record/record.d.ts

@@ -0,0 +1,71 @@
+import { Kind } from '../symbols/index';
+import type { TSchema } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Evaluate, Ensure, Assert } from '../helpers/index';
+import { type TAny } from '../any/index';
+import { type TBoolean } from '../boolean/index';
+import { type TEnumRecord, type TEnum } from '../enum/index';
+import { type TInteger } from '../integer/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TNumber } from '../number/index';
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
+import { type TRegExp } from '../regexp/index';
+import { type TString } from '../string/index';
+import { type TUnion } from '../union/index';
+import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index';
+type TFromTemplateLiteralKeyInfinite<Key extends TTemplateLiteral, Type extends TSchema> = Ensure<TRecord<Key, Type>>;
+type TFromTemplateLiteralKeyFinite<Key extends TTemplateLiteral, Type extends TSchema, I extends string = Static<Key>> = (Ensure<TObject<Evaluate<{
+    [_ in I]: Type;
+}>>>);
+type TFromTemplateLiteralKey<Key extends TTemplateLiteral, Type extends TSchema> = TIsTemplateLiteralFinite<Key> extends false ? TFromTemplateLiteralKeyInfinite<Key, Type> : TFromTemplateLiteralKeyFinite<Key, Type>;
+type TFromEnumKey<Key extends Record<string, string | number>, Type extends TSchema> = Ensure<TObject<{
+    [_ in Key[keyof Key]]: Type;
+}>>;
+type TFromUnionKeyLiteralString<Key extends TLiteral<string>, Type extends TSchema> = {
+    [_ in Key['const']]: Type;
+};
+type TFromUnionKeyLiteralNumber<Key extends TLiteral<number>, Type extends TSchema> = {
+    [_ in Key['const']]: Type;
+};
+type TFromUnionKeyVariants<Keys extends TSchema[], Type extends TSchema, Result extends TProperties = {}> = Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyVariants<Types, Type>> : Left extends TLiteral<string> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyLiteralString<Left, Type>> : Left extends TLiteral<number> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyLiteralNumber<Left, Type>> : {}) : Result;
+type TFromUnionKey<Key extends TSchema[], Type extends TSchema, Properties extends TProperties = TFromUnionKeyVariants<Key, Type>> = (Ensure<TObject<Evaluate<Properties>>>);
+type TFromLiteralKey<Key extends TLiteralValue, Type extends TSchema> = (Ensure<TObject<{
+    [_ in Assert<Key, PropertyKey>]: Type;
+}>>);
+type TFromRegExpKey<_Key extends TRegExp, Type extends TSchema> = (Ensure<TRecord<TRegExp, Type>>);
+type TFromStringKey<_Key extends TString, Type extends TSchema> = (Ensure<TRecord<TString, Type>>);
+type TFromAnyKey<_Key extends TAny, Type extends TSchema> = (Ensure<TRecord<TAny, Type>>);
+type TFromNeverKey<_Key extends TNever, Type extends TSchema> = (Ensure<TRecord<TNever, Type>>);
+type TFromBooleanKey<_Key extends TBoolean, Type extends TSchema> = (Ensure<TObject<{
+    true: Type;
+    false: Type;
+}>>);
+type TFromIntegerKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+type TFromNumberKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{
+    [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>;
+}>);
+export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Record';
+    static: RecordStatic<Key, Type, this['params']>;
+    type: 'object';
+    patternProperties: {
+        [pattern: string]: Type;
+    };
+    additionalProperties: TAdditionalProperties;
+}
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TBoolean ? TFromBooleanKey<Key, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
+/** `[Json]` Creates a Record type */
+export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
+/** Gets the Records Pattern */
+export declare function RecordPattern(record: TRecord): string;
+/** Gets the Records Key Type */
+export type TRecordKey<Type extends TRecord, Result extends TSchema = Type extends TRecord<infer Key extends TSchema, TSchema> ? (Key extends TNumber ? TNumber : Key extends TString ? TString : TString) : TString> = Result;
+/** Gets the Records Key Type */
+export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
+/** Gets a Record Value Type */
+export type TRecordValue<Type extends TRecord, Result extends TSchema = (Type extends TRecord<TSchema, infer Value extends TSchema> ? Value : TNever)> = Result;
+/** Gets a Record Value Type */
+export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
+export {};

package/build/cjs/type/record/record.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Record = Record;
+exports.RecordPattern = RecordPattern;
+exports.RecordKey = RecordKey;
+exports.RecordValue = RecordValue;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+const index_2 = require("../never/index");
+const index_3 = require("../number/index");
+const index_4 = require("../object/index");
+const index_5 = require("../string/index");
+const index_6 = require("../union/index");
+const index_7 = require("../template-literal/index");
+const index_8 = require("../patterns/index");
+const index_9 = require("../indexed/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+const value_1 = require("../guard/value");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern, T, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: T } }, options);
+}
+// ------------------------------------------------------------------
+// RecordCreateFromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromKeys(K, T, options) {
+    const result = {};
+    for (const K2 of K)
+        result[K2] = T;
+    return (0, index_4.Object)(result, { ...options, [index_1.Hint]: 'Record' });
+}
+// prettier-ignore
+function FromTemplateLiteralKey(K, T, options) {
+    return ((0, index_7.IsTemplateLiteralFinite)(K)
+        ? RecordCreateFromKeys((0, index_9.IndexPropertyKeys)(K), T, options)
+        : RecordCreateFromPattern(K.pattern, T, options));
+}
+// prettier-ignore
+function FromUnionKey(key, type, options) {
+    return RecordCreateFromKeys((0, index_9.IndexPropertyKeys)((0, index_6.Union)(key)), type, options);
+}
+// prettier-ignore
+function FromLiteralKey(key, type, options) {
+    return RecordCreateFromKeys([key.toString()], type, options);
+}
+// prettier-ignore
+function FromRegExpKey(key, type, options) {
+    return RecordCreateFromPattern(key.source, type, options);
+}
+// prettier-ignore
+function FromStringKey(key, type, options) {
+    const pattern = (0, value_1.IsUndefined)(key.pattern) ? index_8.PatternStringExact : key.pattern;
+    return RecordCreateFromPattern(pattern, type, options);
+}
+// prettier-ignore
+function FromAnyKey(_, type, options) {
+    return RecordCreateFromPattern(index_8.PatternStringExact, type, options);
+}
+// prettier-ignore
+function FromNeverKey(_key, type, options) {
+    return RecordCreateFromPattern(index_8.PatternNeverExact, type, options);
+}
+// prettier-ignore
+function FromBooleanKey(_key, type, options) {
+    return (0, index_4.Object)({ true: type, false: type }, options);
+}
+// prettier-ignore
+function FromIntegerKey(_key, type, options) {
+    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
+}
+// prettier-ignore
+function FromNumberKey(_, type, options) {
+    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
+}
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
+function Record(key, type, options = {}) {
+    // prettier-ignore
+    return ((0, kind_1.IsUnion)(key) ? FromUnionKey(key.anyOf, type, options) :
+        (0, kind_1.IsTemplateLiteral)(key) ? FromTemplateLiteralKey(key, type, options) :
+            (0, kind_1.IsLiteral)(key) ? FromLiteralKey(key.const, type, options) :
+                (0, kind_1.IsBoolean)(key) ? FromBooleanKey(key, type, options) :
+                    (0, kind_1.IsInteger)(key) ? FromIntegerKey(key, type, options) :
+                        (0, kind_1.IsNumber)(key) ? FromNumberKey(key, type, options) :
+                            (0, kind_1.IsRegExp)(key) ? FromRegExpKey(key, type, options) :
+                                (0, kind_1.IsString)(key) ? FromStringKey(key, type, options) :
+                                    (0, kind_1.IsAny)(key) ? FromAnyKey(key, type, options) :
+                                        (0, kind_1.IsNever)(key) ? FromNeverKey(key, type, options) :
+                                            (0, index_2.Never)(options));
+}
+// ------------------------------------------------------------------
+// Record Utilities
+// ------------------------------------------------------------------
+/** Gets the Records Pattern */
+function RecordPattern(record) {
+    return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+/** Gets the Records Key Type */
+// prettier-ignore
+function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    return (pattern === index_8.PatternStringExact ? (0, index_5.String)() :
+        pattern === index_8.PatternNumberExact ? (0, index_3.Number)() :
+            (0, index_5.String)({ pattern }));
+}
+/** Gets a Record Value Type */
+// prettier-ignore
+function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
+}

package/build/cjs/type/recursive/index.d.ts

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

package/build/cjs/type/recursive/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./recursive"), exports);

package/build/cjs/type/recursive/recursive.d.ts

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

package/build/cjs/type/recursive/recursive.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Recursive = Recursive;
+const type_1 = require("../clone/type");
+const type_2 = require("../create/type");
+const value_1 = require("../guard/value");
+const index_1 = require("../symbols/index");
+// Auto Tracked For Recursive Types without ID's
+let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
+function Recursive(callback, options = {}) {
+    if ((0, value_1.IsUndefined)(options.$id))
+        options.$id = `T${Ordinal++}`;
+    const thisType = (0, type_1.CloneType)(callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` }));
+    thisType.$id = options.$id;
+    // prettier-ignore
+    return (0, type_2.CreateType)({ [index_1.Hint]: 'Recursive', ...thisType }, options);
+}

package/build/cjs/type/ref/index.d.ts

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

package/build/cjs/type/ref/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ref"), exports);

package/build/cjs/type/ref/ref.d.ts

@@ -0,0 +1,41 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+import { TUnsafe } from '../unsafe/index';
+import { Static } from '../static/index';
+export interface TRef<Ref extends string = string> extends TSchema {
+    [Kind]: 'Ref';
+    static: unknown;
+    $ref: Ref;
+}
+export type TRefUnsafe<Type extends TSchema> = TUnsafe<Static<Type>>;
+/** `[Json]` Creates a Ref type.*/
+export declare function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
+/**
+ * @deprecated `[Json]` Creates a Ref type. This signature was deprecated in 0.34.0 where Ref requires callers to pass
+ * a `string` value for the reference (and not a schema).
+ *
+ * To adhere to the 0.34.0 signature, Ref implementations should be updated to the following.
+ *
+ * ```typescript
+ * // pre-0.34.0
+ *
+ * const T = Type.String({ $id: 'T' })
+ *
+ * const R = Type.Ref(T)
+ * ```
+ * should be changed to the following
+ *
+ * ```typescript
+ * // post-0.34.0
+ *
+ * const T = Type.String({ $id: 'T' })
+ *
+ * const R = Type.Unsafe<Static<typeof T>>(Type.Ref('T'))
+ * ```
+ * You can also create a generic function to replicate the pre-0.34.0 signature if required
+ *
+ * ```typescript
+ * const LegacyRef = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T>>(Type.Ref(schema.$id!))
+ * ```
+ */
+export declare function Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;

package/build/cjs/type/ref/ref.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ref = Ref;
+const index_1 = require("../error/index");
+const type_1 = require("../create/type");
+const index_2 = require("../symbols/index");
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+function Ref(...args) {
+    const [$ref, options] = typeof args[0] === 'string' ? [args[0], args[1]] : [args[0].$id, args[1]];
+    if (typeof $ref !== 'string')
+        throw new index_1.TypeBoxError('Ref: $ref must be a string');
+    return (0, type_1.CreateType)({ [index_2.Kind]: 'Ref', $ref }, options);
+}

package/build/cjs/type/regexp/index.d.ts

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

package/build/cjs/type/regexp/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./regexp"), exports);

package/build/cjs/type/regexp/regexp.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface RegExpOptions extends SchemaOptions {
+    /** The maximum length of the string */
+    maxLength?: number;
+    /** The minimum length of the string */
+    minLength?: number;
+}
+export interface TRegExp extends TSchema {
+    [Kind]: 'RegExp';
+    static: `${string}`;
+    type: 'RegExp';
+    source: string;
+    flags: string;
+}
+/** `[JavaScript]` Creates a RegExp type */
+export declare function RegExp(pattern: string, options?: RegExpOptions): TRegExp;
+/** `[JavaScript]` Creates a RegExp type */
+export declare function RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;

package/build/cjs/type/regexp/regexp.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegExp = RegExp;
+const type_1 = require("../create/type");
+const value_1 = require("../guard/value");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a RegExp type */
+function RegExp(unresolved, options) {
+    const expr = (0, value_1.IsString)(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options);
+}

package/build/cjs/type/registry/format.d.ts

@@ -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/build/cjs/type/registry/format.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entries = Entries;
+exports.Clear = Clear;
+exports.Delete = Delete;
+exports.Has = Has;
+exports.Set = Set;
+exports.Get = Get;
+/** A registry for user defined string formats */
+const map = new Map();
+/** Returns the entries in this registry */
+function Entries() {
+    return new Map(map);
+}
+/** Clears all user defined string formats */
+function Clear() {
+    return map.clear();
+}
+/** Deletes a registered format */
+function Delete(format) {
+    return map.delete(format);
+}
+/** Returns true if the user defined string format exists */
+function Has(format) {
+    return map.has(format);
+}
+/** Sets a validation function for a user defined string format */
+function Set(format, func) {
+    map.set(format, func);
+}
+/** Gets a validation function for a user defined string format */
+function Get(format) {
+    return map.get(format);
+}

package/build/cjs/type/registry/index.d.ts

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

package/build/cjs/type/registry/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeRegistry = exports.FormatRegistry = void 0;
+exports.FormatRegistry = __importStar(require("./format"));
+exports.TypeRegistry = __importStar(require("./type"));

package/build/cjs/type/registry/type.d.ts

@@ -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/build/cjs/type/registry/type.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entries = Entries;
+exports.Clear = Clear;
+exports.Delete = Delete;
+exports.Has = Has;
+exports.Set = Set;
+exports.Get = Get;
+/** A registry for user defined types */
+const map = new Map();
+/** Returns the entries in this registry */
+function Entries() {
+    return new Map(map);
+}
+/** Clears all user defined types */
+function Clear() {
+    return map.clear();
+}
+/** Deletes a registered type */
+function Delete(kind) {
+    return map.delete(kind);
+}
+/** Returns true if this registry contains this kind */
+function Has(kind) {
+    return map.has(kind);
+}
+/** Sets a validation function for a user defined type */
+function Set(kind, func) {
+    map.set(kind, func);
+}
+/** Gets a custom validation function for a user defined type */
+function Get(kind) {
+    return map.get(kind);
+}

package/build/cjs/type/required/index.d.ts

@@ -0,0 +1,2 @@
+export * from './required-from-mapped-result';
+export * from './required';

package/build/cjs/type/required/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./required-from-mapped-result"), exports);
+__exportStar(require("./required"), exports);

package/build/cjs/type/required/required-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index';
+import type { Ensure, Evaluate } from '../helpers/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TRequired } from './required';
+type TFromProperties<P extends TProperties> = ({
+    [K2 in keyof P]: TRequired<P[K2]>;
+});
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
+export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+export {};

package/build/cjs/type/required/required-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredFromMappedResult = RequiredFromMappedResult;
+const index_1 = require("../mapped/index");
+const required_1 = require("./required");
+// prettier-ignore
+function FromProperties(P, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, required_1.Required)(P[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
+}
+// prettier-ignore
+function RequiredFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
+    return (0, index_1.MappedResult)(P);
+}