@depup/sinclair__typebox 0.34.48-depup.0

package/build/esm/type/patterns/patterns.mjs

@@ -0,0 +1,8 @@
+export const PatternBoolean = '(true|false)';
+export const PatternNumber = '(0|[1-9][0-9]*)';
+export const PatternString = '(.*)';
+export const PatternNever = '(?!.*)';
+export const PatternBooleanExact = `^${PatternBoolean}$`;
+export const PatternNumberExact = `^${PatternNumber}$`;
+export const PatternStringExact = `^${PatternString}$`;
+export const PatternNeverExact = `^${PatternNever}$`;

package/build/esm/type/pick/index.d.mts

@@ -0,0 +1,3 @@
+export * from './pick-from-mapped-key.mjs';
+export * from './pick-from-mapped-result.mjs';
+export * from './pick.mjs';

package/build/esm/type/pick/index.mjs

@@ -0,0 +1,3 @@
+export * from './pick-from-mapped-key.mjs';
+export * from './pick-from-mapped-result.mjs';
+export * from './pick.mjs';

package/build/esm/type/pick/pick-from-mapped-key.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TPick } from './pick.mjs';
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TPick<Type, [Key]>;
+};
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer LeftKey extends PropertyKey, ...infer RightKeys extends PropertyKey[]] ? TFromPropertyKeys<Type, RightKeys, Result & TFromPropertyKey<Type, LeftKey>> : Result);
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey['keys']>);
+export type TPickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>> = (TMappedResult<Properties>);
+export declare function PickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/build/esm/type/pick/pick-from-mapped-key.mjs

@@ -0,0 +1,24 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Pick } from './pick.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function FromPropertyKey(type, key, options) {
+    return {
+        [key]: Pick(type, [key], Clone(options))
+    };
+}
+// prettier-ignore
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, leftKey) => {
+        return { ...result, ...FromPropertyKey(type, leftKey, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+export function PickFromMappedKey(type, mappedKey, options) {
+    const properties = FromMappedKey(type, mappedKey, options);
+    return MappedResult(properties);
+}

package/build/esm/type/pick/pick-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TPick } from './pick.mjs';
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TPick<Properties[K2], PropertyKeys>;
+});
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>);
+export type TPickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+export declare function PickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/build/esm/type/pick/pick-from-mapped-result.mjs

@@ -0,0 +1,19 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Pick } from './pick.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function FromProperties(properties, propertyKeys, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
+    return result;
+}
+// prettier-ignore
+function FromMappedResult(mappedResult, propertyKeys, options) {
+    return FromProperties(mappedResult.properties, propertyKeys, options);
+}
+// prettier-ignore
+export function PickFromMappedResult(mappedResult, propertyKeys, options) {
+    const properties = FromMappedResult(mappedResult, propertyKeys, options);
+    return MappedResult(properties);
+}

package/build/esm/type/pick/pick.d.mts

@@ -0,0 +1,36 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TupleToUnion, Evaluate } from '../helpers/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TMappedKey, type TMappedResult } from '../mapped/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+import { type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { type TPickFromMappedKey } from './pick-from-mapped-key.mjs';
+import { type TPickFromMappedResult } from './pick-from-mapped-result.mjs';
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]> : Result;
+type TFromUnion<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]> : Result;
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKeys extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Pick<Properties, UnionKeys & keyof Properties>>);
+type TFromObject<_Type extends TObject, Keys extends PropertyKey[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Properties, Keys>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnion<Result>);
+export type TPickResolve<Type extends TProperties, PropertyKeys extends PropertyKey[]> = (Type extends TRecursive<infer Types extends TSchema> ? TRecursive<TPickResolve<Types, PropertyKeys>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject, PropertyKeys, Properties> : TObject<{}>);
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
+export type TPick<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TPickFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TPickFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : TPickResolve<Type, TResolvePropertyKeys<Key>>);
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
+export {};

package/build/esm/type/pick/pick.mjs

@@ -0,0 +1,66 @@
+import { CreateType } from '../create/type.mjs';
+import { Discard } from '../discard/discard.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Union } from '../union/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
+import { TransformKind } from '../symbols/symbols.mjs';
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema, IsLiteralValue, IsRef } from '../guard/kind.mjs';
+import { IsArray as IsArrayValue } from '../guard/value.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
+import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
+}
+// prettier-ignore
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
+}
+// prettier-ignore
+function FromProperties(properties, propertyKeys) {
+    const result = {};
+    for (const K2 of propertyKeys)
+        if (K2 in properties)
+            result[K2] = properties[K2];
+    return result;
+}
+// prettier-ignore
+function FromObject(Type, keys, properties) {
+    const options = Discard(Type, [TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties, keys);
+    return Object(mappedProperties, options);
+}
+// prettier-ignore
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
+    return Union(result);
+}
+// prettier-ignore
+function PickResolve(type, propertyKeys) {
+    return (IsIntersect(type) ? Intersect(FromIntersect(type.allOf, propertyKeys)) :
+        IsUnion(type) ? Union(FromUnion(type.anyOf, propertyKeys)) :
+            IsObject(type) ? FromObject(type, propertyKeys, type.properties) :
+                Object({}));
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+export function Pick(type, key, options) {
+    const typeKey = IsArrayValue(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+    const isTypeRef = IsRef(type);
+    const isKeyRef = IsRef(key);
+    return (IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) :
+        IsMappedKey(key) ? PickFromMappedKey(type, key, options) :
+            (isTypeRef && isKeyRef) ? Computed('Pick', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? Computed('Pick', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? Computed('Pick', [type, typeKey], options) :
+                        CreateType({ ...PickResolve(type, propertyKeys), ...options }));
+}

package/build/esm/type/promise/index.d.mts

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

package/build/esm/type/promise/index.mjs

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

package/build/esm/type/promise/promise.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Promise';
+    static: Promise<Static<T, this['params']>>;
+    type: 'Promise';
+    item: TSchema;
+}
+/** `[JavaScript]` Creates a Promise type */
+export declare function Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;

package/build/esm/type/promise/promise.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Promise type */
+export function Promise(item, options) {
+    return CreateType({ [Kind]: 'Promise', type: 'Promise', item }, options);
+}

package/build/esm/type/readonly/index.d.mts

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

package/build/esm/type/readonly/index.mjs

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

package/build/esm/type/readonly/readonly-from-mapped-result.d.mts

@@ -0,0 +1,10 @@
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TReadonlyWithFlag } from './readonly.mjs';
+type TFromProperties<P extends TProperties, F extends boolean> = ({
+    [K2 in keyof P]: TReadonlyWithFlag<P[K2], F>;
+});
+type TFromMappedResult<R extends TMappedResult, F extends boolean> = (TFromProperties<R['properties'], F>);
+export type TReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export declare function ReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>>(R: R, F: F): TMappedResult<P>;
+export {};

package/build/esm/type/readonly/readonly-from-mapped-result.mjs

@@ -0,0 +1,18 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Readonly } from './readonly.mjs';
+// prettier-ignore
+function FromProperties(K, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Readonly(K[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, F) {
+    return FromProperties(R.properties, F);
+}
+// prettier-ignore
+export function ReadonlyFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
+    return MappedResult(P);
+}

package/build/esm/type/readonly/readonly.d.mts

@@ -0,0 +1,20 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import { ReadonlyKind } from '../symbols/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
+type TRemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
+type TAddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveReadonly<T> : TAddReadonly<T>;
+export type TReadonly<T extends TSchema> = T & {
+    [ReadonlyKind]: 'Readonly';
+};
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+export {};

package/build/esm/type/readonly/readonly.mjs

@@ -0,0 +1,22 @@
+import { CreateType } from '../create/type.mjs';
+import { ReadonlyKind } from '../symbols/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { ReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
+import { IsMappedResult } from '../guard/kind.mjs';
+function RemoveReadonly(schema) {
+    return CreateType(Discard(schema, [ReadonlyKind]));
+}
+function AddReadonly(schema) {
+    return CreateType({ ...schema, [ReadonlyKind]: 'Readonly' });
+}
+// prettier-ignore
+function ReadonlyWithFlag(schema, F) {
+    return (F === false
+        ? RemoveReadonly(schema)
+        : AddReadonly(schema));
+}
+/** `[Json]` Creates a Readonly property */
+export function Readonly(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}

package/build/esm/type/readonly-optional/index.d.mts

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

package/build/esm/type/readonly-optional/index.mjs

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

package/build/esm/type/readonly-optional/readonly-optional.d.mts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../schema/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>;
+/** `[Json]` Creates a Readonly and Optional property */
+export declare function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;

package/build/esm/type/readonly-optional/readonly-optional.mjs

@@ -0,0 +1,6 @@
+import { Readonly } from '../readonly/index.mjs';
+import { Optional } from '../optional/index.mjs';
+/** `[Json]` Creates a Readonly and Optional property */
+export function ReadonlyOptional(schema) {
+    return Readonly(Optional(schema));
+}

package/build/esm/type/record/index.d.mts

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

package/build/esm/type/record/index.mjs

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

package/build/esm/type/record/record.d.mts

@@ -0,0 +1,71 @@
+import { Kind } from '../symbols/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Evaluate, Ensure, Assert } from '../helpers/index.mjs';
+import { type TAny } from '../any/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TEnumRecord, type TEnum } from '../enum/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index.mjs';
+import { type TRegExp } from '../regexp/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index.mjs';
+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/esm/type/record/record.mjs

@@ -0,0 +1,116 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Number } from '../number/index.mjs';
+import { Object } from '../object/index.mjs';
+import { String } from '../string/index.mjs';
+import { Union } from '../union/index.mjs';
+import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
+import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsUndefined } from '../guard/value.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsInteger, IsLiteral, IsAny, IsBoolean, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern, T, options) {
+    return CreateType({ [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 Object(result, { ...options, [Hint]: 'Record' });
+}
+// prettier-ignore
+function FromTemplateLiteralKey(K, T, options) {
+    return (IsTemplateLiteralFinite(K)
+        ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
+        : RecordCreateFromPattern(K.pattern, T, options));
+}
+// prettier-ignore
+function FromUnionKey(key, type, options) {
+    return RecordCreateFromKeys(IndexPropertyKeys(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 = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+    return RecordCreateFromPattern(pattern, type, options);
+}
+// prettier-ignore
+function FromAnyKey(_, type, options) {
+    return RecordCreateFromPattern(PatternStringExact, type, options);
+}
+// prettier-ignore
+function FromNeverKey(_key, type, options) {
+    return RecordCreateFromPattern(PatternNeverExact, type, options);
+}
+// prettier-ignore
+function FromBooleanKey(_key, type, options) {
+    return Object({ true: type, false: type }, options);
+}
+// prettier-ignore
+function FromIntegerKey(_key, type, options) {
+    return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+// prettier-ignore
+function FromNumberKey(_, type, options) {
+    return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
+export function Record(key, type, options = {}) {
+    // prettier-ignore
+    return (IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
+        IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
+            IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
+                IsBoolean(key) ? FromBooleanKey(key, type, options) :
+                    IsInteger(key) ? FromIntegerKey(key, type, options) :
+                        IsNumber(key) ? FromNumberKey(key, type, options) :
+                            IsRegExp(key) ? FromRegExpKey(key, type, options) :
+                                IsString(key) ? FromStringKey(key, type, options) :
+                                    IsAny(key) ? FromAnyKey(key, type, options) :
+                                        IsNever(key) ? FromNeverKey(key, type, options) :
+                                            Never(options));
+}
+// ------------------------------------------------------------------
+// Record Utilities
+// ------------------------------------------------------------------
+/** Gets the Records Pattern */
+export function RecordPattern(record) {
+    return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+/** Gets the Records Key Type */
+// prettier-ignore
+export function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    return (pattern === PatternStringExact ? String() :
+        pattern === PatternNumberExact ? Number() :
+            String({ pattern }));
+}
+/** Gets a Record Value Type */
+// prettier-ignore
+export function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
+}

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

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

package/build/esm/type/recursive/index.mjs

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

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

@@ -0,0 +1,16 @@
+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;
+}
+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/esm/type/recursive/recursive.mjs

@@ -0,0 +1,15 @@
+import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/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 = CloneType(callback({ [Kind]: 'This', $ref: `${options.$id}` }));
+    thisType.$id = options.$id;
+    // prettier-ignore
+    return CreateType({ [Hint]: 'Recursive', ...thisType }, options);
+}

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

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

package/build/esm/type/ref/index.mjs

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

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

@@ -0,0 +1,41 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+import { TUnsafe } from '../unsafe/index.mjs';
+import { Static } from '../static/index.mjs';
+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/esm/type/ref/ref.mjs

@@ -0,0 +1,10 @@
+import { TypeBoxError } from '../error/index.mjs';
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+export 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 TypeBoxError('Ref: $ref must be a string');
+    return CreateType({ [Kind]: 'Ref', $ref }, options);
+}