@sinclair/typebox 0.34.0 → 0.34.2

package/build/esm/type/omit/omit.mjs

@@ -1,60 +1,71 @@
 import { CreateType } from '../create/type.mjs';
 import { Discard } from '../discard/discard.mjs';
+import { TransformKind } from '../symbols/symbols.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexPropertyKeys } from '../indexed/index.mjs';
+// ------------------------------------------------------------------
+// Mapped
+// ------------------------------------------------------------------
 import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
 import { OmitFromMappedResult } from './omit-from-mapped-result.mjs';
-import { TransformKind } from '../symbols/symbols.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/kind.mjs';
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult, IsLiteralValue, IsRef } from '../guard/kind.mjs';
+import { IsArray as IsArrayValue } from '../guard/value.mjs';
 // prettier-ignore
-function FromIntersect(T, K) {
-    return T.map((T) => OmitResolve(T, K));
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
 }
 // prettier-ignore
-function FromUnion(T, K) {
-    return T.map((T) => OmitResolve(T, K));
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
 // prettier-ignore
-function FromProperty(T, K) {
-    const { [K]: _, ...R } = T;
+function FromProperty(properties, key) {
+    const { [key]: _, ...R } = properties;
     return R;
 }
 // prettier-ignore
-function FromProperties(T, K) {
-    return K.reduce((T, K2) => FromProperty(T, K2), T);
+function FromProperties(properties, propertyKeys) {
+    return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
 }
 // prettier-ignore
-function FromObject(T, K) {
-    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(T['properties'], K);
-    return Object(properties, options);
+function FromObject(properties, propertyKeys) {
+    const options = Discard(properties, [TransformKind, '$id', 'required', 'properties']);
+    const omittedProperties = FromProperties(properties['properties'], propertyKeys);
+    return Object(omittedProperties, options);
 }
-// ------------------------------------------------------------------
-// OmitResolve
-// ------------------------------------------------------------------
 // prettier-ignore
-function OmitResolve(T, K) {
-    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
-        IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
-            IsObject(T) ? FromObject(T, K) :
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
+    return Union(result);
+}
+// prettier-ignore
+function OmitResolve(properties, propertyKeys) {
+    return (IsIntersect(properties) ? Intersect(FromIntersect(properties.allOf, propertyKeys)) :
+        IsUnion(properties) ? Union(FromUnion(properties.anyOf, propertyKeys)) :
+            IsObject(properties) ? FromObject(properties, propertyKeys) :
                 Object({}));
 }
-export function Omit(T, K, options) {
-    // mapped
-    if (IsMappedKey(K))
-        return OmitFromMappedKey(T, K, options);
-    if (IsMappedResult(T))
-        return OmitFromMappedResult(T, K, options);
-    // non-mapped
-    const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-    // special: mapping types require overridable options
-    return CreateType({ ...OmitResolve(T, I), ...options });
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+export function Omit(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) ? OmitFromMappedResult(type, propertyKeys, options) :
+        IsMappedKey(key) ? OmitFromMappedKey(type, key, options) :
+            (isTypeRef && isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+                        CreateType({ ...OmitResolve(type, propertyKeys), ...options }));
 }

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

@@ -2,21 +2,25 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Evaluate, Ensure } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TComputed } from '../computed/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 TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
+import { type TRef } from '../ref/index.mjs';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result.mjs';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TPartial<L>]> : Acc);
-type TFromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Partial', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Partial', [TRef<Ref>]>>;
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+    [K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<Properties[K]>;
 }>;
-type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
-export type TPartial<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
+type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TPartial<L>]> : Result);
+export type TPartial<T extends TSchema> = (T extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> : T extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : T extends TRef<infer Ref extends string> ? TFromRef<Ref> : T extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : T extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : T extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
-export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
+export declare function Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
 /** `[Json]` Constructs a type where all properties are optional */
-export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
+export declare function Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
 export {};

package/build/esm/type/partial/partial.mjs

@@ -1,25 +1,31 @@
 import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
+import { Ref } from '../ref/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind.mjs';
+import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind.mjs';
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => PartialResolve(L));
+function FromComputed(target, parameters) {
+    return Computed('Partial', [Computed(target, parameters)]);
 }
 // prettier-ignore
-function FromProperties(T) {
-    const Acc = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(T))
-        Acc[K] = Optional(T[K]);
-    return Acc;
+function FromRef($ref) {
+    return Computed('Partial', [Ref($ref)]);
+}
+// prettier-ignore
+function FromProperties(properties) {
+    const partialProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        partialProperties[K] = Optional(properties[K]);
+    return partialProperties;
 }
 // prettier-ignore
 function FromObject(T) {
@@ -27,23 +33,29 @@ function FromObject(T) {
     const properties = FromProperties(T['properties']);
     return Object(properties, options);
 }
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => PartialResolve(type));
+}
 // ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-function PartialResolve(T) {
-    return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
-        IsUnion(T) ? Union(FromRest(T.anyOf)) :
-            IsObject(T) ? FromObject(T) :
-                Object({}));
+function PartialResolve(type) {
+    return (IsComputed(type) ? FromComputed(type.target, type.parameters) :
+        IsRef(type) ? FromRef(type.$ref) :
+            IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+                IsUnion(type) ? Union(FromRest(type.anyOf)) :
+                    IsObject(type) ? FromObject(type) :
+                        Object({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(T, options) {
-    if (IsMappedResult(T)) {
-        return PartialFromMappedResult(T, options);
+export function Partial(type, options) {
+    if (IsMappedResult(type)) {
+        return PartialFromMappedResult(type, options);
     }
     else {
         // special: mapping types require overridable options
-        return CreateType({ ...PartialResolve(T), ...options });
+        return CreateType({ ...PartialResolve(type), ...options });
     }
 }

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

@@ -2,11 +2,11 @@ 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<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TPick<T, [K]>;
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TPick<Type, [Key]>;
 };
-type TFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>> : Acc);
-type TFromMappedKey<T extends TSchema, K extends TMappedKey> = (TFromPropertyKeys<T, K['keys']>);
-export type TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
+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

@@ -2,23 +2,23 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
 import { Clone } from '../clone/value.mjs';
 // prettier-ignore
-function FromPropertyKey(T, K, options) {
+function FromPropertyKey(type, key, options) {
     return {
-        [K]: Pick(T, [K], Clone(options))
+        [key]: Pick(type, [key], Clone(options))
     };
 }
 // prettier-ignore
-function FromPropertyKeys(T, K, options) {
-    return K.reduce((Acc, LK) => {
-        return { ...Acc, ...FromPropertyKey(T, LK, options) };
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, leftKey) => {
+        return { ...result, ...FromPropertyKey(type, leftKey, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedKey(T, K, options) {
-    return FromPropertyKeys(T, K.keys, options);
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
 }
 // prettier-ignore
-export function PickFromMappedKey(T, K, options) {
-    const P = FromMappedKey(T, K, options);
-    return MappedResult(P);
+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

@@ -3,10 +3,10 @@ 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<P extends TProperties, K extends PropertyKey[]> = ({
-    [K2 in keyof P]: TPick<P[K2], K>;
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TPick<Properties[K2], PropertyKeys>;
 });
-type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
-export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
+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

@@ -2,18 +2,18 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
 import { Clone } from '../clone/value.mjs';
 // prettier-ignore
-function FromProperties(P, K, options) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = Pick(P[K2], K, Clone(options));
-    return Acc;
+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(R, K, options) {
-    return FromProperties(R.properties, K, options);
+function FromMappedResult(mappedResult, propertyKeys, options) {
+    return FromProperties(mappedResult.properties, propertyKeys, options);
 }
 // prettier-ignore
-export function PickFromMappedResult(R, K, options) {
-    const P = FromMappedResult(R, K, options);
-    return MappedResult(P);
+export function PickFromMappedResult(mappedResult, propertyKeys, options) {
+    const properties = FromMappedResult(mappedResult, propertyKeys, options);
+    return MappedResult(properties);
 }

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

@@ -1,26 +1,36 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TupleToUnion, Evaluate, Ensure } 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 TUnion } from '../union/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
-import type { TMappedKey, TMappedResult } from '../mapped/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 FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, TPick<L, K>]> : Acc;
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
-type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
-declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
-type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
-type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
-export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S extends TSchema> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>;
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
+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, Key extends PropertyKey[], Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties, Key>)>>;
+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<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TPickResolve<Types, PropertyKeys>> : Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Properties extends TObject<infer Types extends TProperties> ? TFromObject<TObject<Types>, PropertyKeys> : 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<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+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<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+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

@@ -1,30 +1,36 @@
 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 { Union } from '../union/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 { PickFromMappedKey } from './pick-from-mapped-key.mjs';
-import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
 import { TransformKind } from '../symbols/symbols.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// Guards
 // ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/kind.mjs';
-function FromIntersect(T, K) {
-    return T.map((T) => PickResolve(T, K));
+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(T, K) {
-    return T.map((T) => PickResolve(T, K));
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
 }
 // prettier-ignore
-function FromProperties(T, K) {
-    const Acc = {};
-    for (const K2 of K)
-        if (K2 in T)
-            Acc[K2] = T[K2];
-    return Acc;
+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(T, K) {
@@ -32,24 +38,29 @@ function FromObject(T, K) {
     const properties = FromProperties(T['properties'], K);
     return Object(properties, options);
 }
-// ------------------------------------------------------------------
-// PickResolve
-// ------------------------------------------------------------------
 // prettier-ignore
-function PickResolve(T, K) {
-    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
-        IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
-            IsObject(T) ? FromObject(T, K) :
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
+    return Union(result);
+}
+// prettier-ignore
+function PickResolve(properties, propertyKeys) {
+    return (IsIntersect(properties) ? Intersect(FromIntersect(properties.allOf, propertyKeys)) :
+        IsUnion(properties) ? Union(FromUnion(properties.anyOf, propertyKeys)) :
+            IsObject(properties) ? FromObject(properties, propertyKeys) :
                 Object({}));
 }
-export function Pick(T, K, options) {
-    // mapped
-    if (IsMappedKey(K))
-        return PickFromMappedKey(T, K, options);
-    if (IsMappedResult(T))
-        return PickFromMappedResult(T, K, options);
-    // non-mapped
-    const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-    // special: mapping types require overridable options
-    return CreateType({ ...PickResolve(T, I), ...options });
+/** `[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/record/record.d.mts

@@ -2,6 +2,7 @@ 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 TComputed } from '../computed/index.mjs';
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNever } from '../never/index.mjs';
@@ -11,6 +12,7 @@ import { type TString } from '../string/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TEnum } from '../enum/index.mjs';
+import { type TRef } from '../ref/index.mjs';
 import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
@@ -50,7 +52,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : K extends TAny ? TFromAnyKey<K, T> : K extends TNever ? TFromNeverKey<K, T> : TNever;
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = Type extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer S> ? TFromEnumKey<S, Type> : Key extends TUnion<infer S> ? TFromUnionKey<S, Type> : Key extends TLiteral<infer S> ? TFromLiteralKey<S, 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<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
+export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
 export {};

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

@@ -1,4 +1,5 @@
 import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Union } from '../union/index.mjs';
@@ -13,7 +14,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
+import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -78,16 +79,18 @@ function FromNumberKey(_, T, options) {
 // TRecordOrObject
 // ------------------------------------------------------------------
 /** `[Json]` Creates a Record type */
-export function Record(K, T, options = {}) {
+export function Record(key, type, options = {}) {
     // prettier-ignore
-    return (IsUnion(K) ? FromUnionKey(K.anyOf, T, options) :
-        IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) :
-            IsLiteral(K) ? FromLiteralKey(K.const, T, options) :
-                IsInteger(K) ? FromIntegerKey(K, T, options) :
-                    IsNumber(K) ? FromNumberKey(K, T, options) :
-                        IsRegExp(K) ? FromRegExpKey(K, T, options) :
-                            IsString(K) ? FromStringKey(K, T, options) :
-                                IsAny(K) ? FromAnyKey(K, T, options) :
-                                    IsNever(K) ? FromNeverKey(K, T, options) :
-                                        Never(options));
+    return (IsRef(type) ? Computed('Record', [key, type]) :
+        IsRef(key) ? Computed('Record', [key, type]) :
+            IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
+                IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
+                    IsLiteral(key) ? FromLiteralKey(key.const, 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));
 }

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

@@ -2,21 +2,25 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Evaluate, Ensure } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TComputed } from '../computed/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 TObject, type TProperties } from '../object/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';
+import { type TRef } from '../ref/index.mjs';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequired<L>]> : Acc);
-type TFromProperties<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];
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Required', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Required', [TRef<Ref>]>>;
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+    [K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonly<S> : Properties[K] extends (TOptional<infer S>) ? S : Properties[K];
 }>;
-type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
-export type TRequired<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
+type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TRequired<L>]> : Result);
+export type TRequired<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are required */
-export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
+export declare function Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
 /** `[Json]` Constructs a type where all properties are required */
-export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
+export declare function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
 export {};