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

package/build/import/type/mapped/mapped.mjs

@@ -1,6 +1,7 @@
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
+// evaluation types
 import { Array } from '../array/index.mjs';
 import { AsyncIterator } from '../async-iterator/index.mjs';
 import { Constructor } from '../constructor/index.mjs';
@@ -15,39 +16,54 @@ import { Promise } from '../promise/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
+// mapping types
 import { MappedResult } from './mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TSchema as IsSchemaType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
+// prettier-ignore
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])
         : MappedResult(P));
 }
+// prettier-ignore
 function MappedKeyToMappedResultProperties(K, P) {
     const [L, ...R] = P;
     return (P.length > 0
         ? { [L]: Literal(L), ...MappedKeyToMappedResultProperties(K, R) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(K, P) {
     const R = MappedKeyToMappedResultProperties(K, P);
     return FromMappedResult(K, R);
 }
+// prettier-ignore
 function FromRest(K, T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [FromSchemaType(K, L), ...FromRest(K, R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(K, T) {
     return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
         return { ...Acc, [K2]: FromSchemaType(K, T[K2]) };
     }, {});
 }
+// prettier-ignore
 function FromSchemaType(K, T) {
-    return (IsOptionalType(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
+    return (
+    // unevaluated modifier types
+    IsOptionalType(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
         IsReadonlyType(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) :
+            // unevaluated mapped types
             IsMappedResultType(T) ? FromMappedResult(K, T.properties) :
                 IsMappedKeyType(T) ? FromMappedKey(K, T.keys) :
+                    // unevaluated types
                     IsConstructorType(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
                         IsFunctionType(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
                             IsAsyncIteratorType(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
@@ -60,12 +76,14 @@ function FromSchemaType(K, T) {
                                                         IsPromiseType(T) ? Promise(FromSchemaType(K, T.item)) :
                                                             T);
 }
+// prettier-ignore
 function FromMappedFunctionReturnType(K, T) {
     const [L, ...R] = K;
     return (K.length > 0
         ? { [L]: FromSchemaType(L, T), ...FromMappedFunctionReturnType(R, T) }
         : {});
 }
+/** `[Json]` Creates a Mapped object type */
 export function Mapped(key, map, options = {}) {
     const K = IsSchemaType(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });

package/build/import/type/modifiers/modifiers.mjs

@@ -3,7 +3,12 @@ import { Union } from '../union/index.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { OptionalKind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TOptional as IsOptionalType } from '../guard/type.mjs';
+// prettier-ignore
 function IsOptionalFromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -12,6 +17,7 @@ function IsOptionalFromIntersect(T) {
             : false
         : true);
 }
+// prettier-ignore
 function IsOptionalFromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -20,18 +26,22 @@ function IsOptionalFromUnion(T) {
             : IsOptionalFromUnion(R)
         : false);
 }
+// prettier-ignore
 function RemoveOptionalFromRest(T) {
     return (T.map(T => RemoveOptionalFromSchema(T)));
 }
+// prettier-ignore
 function RemoveOptionalFromSchema(T) {
     return (Discard(T, [OptionalKind]));
 }
+// prettier-ignore
 export function OptionalFromIntersect(T) {
     const D = RemoveOptionalFromRest(T);
     return (IsOptionalFromIntersect(T)
         ? Optional(Intersect(D))
         : Intersect(T));
 }
+// prettier-ignore
 export function OptionalFromUnion(T) {
     const D = RemoveOptionalFromRest(T);
     return (IsOptionalFromUnion(T)

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

@@ -5,4 +5,5 @@ export interface TNever extends TSchema {
     static: never;
     not: {};
 }
+/** `[Json]` Creates a Never type */
 export declare function Never(options?: SchemaOptions): TNever;

package/build/import/type/never/never.mjs

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Never type */
 export function Never(options = {}) {
     return {
         ...options,

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

@@ -6,4 +6,5 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
     static: T extends TNot<infer U> ? Static<U> : unknown;
     not: T;
 }
+/** `[Json]` Creates a Not type */
 export declare function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;

package/build/import/type/not/not.mjs

@@ -1,5 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[Json]` Creates a Not type */
 export function Not(schema, options) {
     return {
         ...options,

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

@@ -5,4 +5,5 @@ export interface TNull extends TSchema {
     static: null;
     type: 'null';
 }
+/** `[Json]` Creates a Null type */
 export declare function Null(options?: SchemaOptions): TNull;

package/build/import/type/null/null.mjs

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Null type */
 export function Null(options = {}) {
     return {
         ...options,

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

@@ -12,4 +12,5 @@ export interface TNumber extends TSchema, NumberOptions {
     static: number;
     type: 'number';
 }
+/** `[Json]` Creates a Number type */
 export declare function Number(options?: NumberOptions): TNumber;

package/build/import/type/number/number.mjs

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Number type */
 export function Number(options = {}) {
     return {
         ...options,

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

@@ -22,8 +22,11 @@ export type TPropertyKey = string | number;
 export type TProperties = Record<TPropertyKey, TSchema>;
 export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
+    /** Additional property constraints for this object */
     additionalProperties?: TAdditionalProperties;
+    /** The minimum number of properties allowed on this object */
     minProperties?: number;
+    /** The maximum number of properties allowed on this object */
     maxProperties?: number;
 }
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
@@ -34,6 +37,8 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     properties: T;
     required?: string[];
 }
+/** `[Json]` Creates an Object type */
 export declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+/** `[Json]` Creates an Object type */
 export declare const Object: typeof _Object;
 export {};

package/build/import/type/object/object.mjs

@@ -1,6 +1,11 @@
 import { CloneType } from '../clone/type.mjs';
 import { Kind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TOptional as IsOptionalType, TSchema as IsSchemaType } from '../guard/type.mjs';
+/** `[Json]` Creates an Object type */
 export function _Object(properties, options = {}) {
     const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
     const optionalKeys = propertyKeys.filter((key) => IsOptionalType(properties[key]));
@@ -11,4 +16,5 @@ export function _Object(properties, options = {}) {
         ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
         : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties });
 }
+/** `[Json]` Creates an Object type */
 export const Object = _Object;

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

@@ -1,19 +1,23 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Omit } from './omit.mjs';
+// prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
         [K]: Omit(T, [K], options)
     };
 }
+// prettier-ignore
 function FromPropertyKeys(T, K, options) {
     const [LK, ...RK] = K;
     return (K.length > 0
         ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(T, K, options) {
     return FromPropertyKeys(T, K.keys, options);
 }
+// prettier-ignore
 export function OmitFromMappedKey(T, K, options) {
     const P = FromMappedKey(T, K, options);
     return MappedResult(P);

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

@@ -16,7 +16,10 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
 export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
 export {};

package/build/import/type/omit/omit.mjs

@@ -6,22 +6,34 @@ import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+// prettier-ignore
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
 }
+// prettier-ignore
 function FromUnion(T, K) {
     return T.map((T) => OmitResolve(T, K));
 }
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
 function FromProperty(T, K) {
     const { [K]: _, ...R } = T;
     return R;
 }
+// prettier-ignore
 function FromProperties(T, K) {
     return K.reduce((T, K2) => {
         return FromProperty(T, K2);
     }, T);
 }
+// prettier-ignore
 export function OmitResolve(T, K) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf, K)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf, K)) :

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

@@ -1,16 +1,24 @@
 export type OperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : OperatorIncludes<R, S> : false);
+/** Returns true if element S is in the set of T */
 export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): OperatorIncludes<T, S>;
 export type OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? OperatorSubset<R, S> : false : true;
+/** Returns true if T is a subset of S */
 export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorSubset<T, S>;
 export type OperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<Acc, L> extends false ? OperatorDistinct<R, [...Acc, L]> : OperatorDistinct<R, [...Acc]> : Acc;
+/** Returns a distinct set of elements */
 export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): OperatorDistinct<T>;
 export type OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [L, ...OperatorIntersect<R, S>] : [...OperatorIntersect<R, S>] : []);
+/** Returns the Intersect of the given sets */
 export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorIntersect<T, S>;
 export type OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorUnion<R, S>] : [L, ...OperatorUnion<R, S>] : S);
+/** Returns the Union of the given sets */
 export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorUnion<T, S>;
 export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorComplement<R, S>] : [L, ...OperatorComplement<R, S>] : []);
+/** Returns the Complement by omitting elements in T that are in S */
 export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorComplement<T, S>;
 export type OperatorIntersectMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersect<L, OperatorIntersectMany<R>> : []);
+/** Returns the Intersect of multiple sets */
 export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T]): OperatorIntersectMany<T>;
 export type OperatorUnionMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnion<L, OperatorUnionMany<R>> : []);
+/** Returns the Union of multiple sets */
 export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T]): OperatorUnionMany<T>;

package/build/import/type/operators/operators.mjs

@@ -1,3 +1,5 @@
+/** Returns true if element S is in the set of T */
+// prettier-ignore
 export function OperatorIncludes(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -6,6 +8,8 @@ export function OperatorIncludes(T, S) {
             : OperatorIncludes(R, S)
         : false);
 }
+/** Returns true if T is a subset of S */
+// prettier-ignore
 export function OperatorSubset(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -14,6 +18,8 @@ export function OperatorSubset(T, S) {
             : false
         : true);
 }
+/** Returns a distinct set of elements */
+// prettier-ignore
 export function OperatorDistinct(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -22,6 +28,8 @@ export function OperatorDistinct(T, Acc = []) {
             : OperatorDistinct(R, [...Acc])
         : Acc);
 }
+/** Returns the Intersect of the given sets */
+// prettier-ignore
 export function OperatorIntersect(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -30,6 +38,8 @@ export function OperatorIntersect(T, S) {
             : [...OperatorIntersect(R, S)]
         : []);
 }
+/** Returns the Union of the given sets */
+// prettier-ignore
 export function OperatorUnion(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -38,6 +48,8 @@ export function OperatorUnion(T, S) {
             : [L, ...OperatorUnion(R, S)]
         : S);
 }
+/** Returns the Complement by omitting elements in T that are in S */
+// prettier-ignore
 export function OperatorComplement(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -46,6 +58,8 @@ export function OperatorComplement(T, S) {
             : [L, ...OperatorComplement(R, S)]
         : []);
 }
+/** Returns the Intersect of multiple sets */
+// prettier-ignore
 export function OperatorIntersectMany(T) {
     return (T.length === 1
         ? T[0]
@@ -56,6 +70,7 @@ export function OperatorIntersectMany(T) {
                 : []);
         })());
 }
+/** Returns the Union of multiple sets */
 export function OperatorUnionMany(T) {
     return (T.length === 1
         ? T[0]

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

@@ -3,4 +3,5 @@ import { OptionalKind } from '../symbols/index.mjs';
 export type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
+/** `[Json]` Creates an Optional property */
 export declare function Optional<T extends TSchema>(schema: T): TOptional<T>;

package/build/import/type/optional/optional.mjs

@@ -1,5 +1,6 @@
 import { OptionalKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[Json]` Creates an Optional property */
 export function Optional(schema) {
     return { ...CloneType(schema), [OptionalKind]: 'Optional' };
 }

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

@@ -3,4 +3,5 @@ import type { TFunction } from '../function/index.mjs';
 import type { Ensure } from '../helpers/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
 export declare function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;

package/build/import/type/parameters/parameters.mjs

@@ -1,5 +1,6 @@
 import { Tuple } from '../tuple/index.mjs';
 import { CloneRest } from '../clone/type.mjs';
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
 export function Parameters(schema, options = {}) {
     return Tuple(CloneRest(schema.parameters), { ...options });
 }

package/build/import/type/partial/partial-from-mapped-result.mjs

@@ -1,13 +1,16 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Partial } from './partial.mjs';
+// prettier-ignore
 function FromProperties(K, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: Partial(K[K2], options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, options) {
     return FromProperties(K.properties, options);
 }
+// prettier-ignore
 export function PartialFromMappedResult(T, options) {
     const P = FromMappedResult(T, options);
     return MappedResult(P);

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

@@ -20,6 +20,8 @@ declare function FromProperties<T extends TProperties>(T: T): TProperties;
 type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
 declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
 export type TPartial<T extends TSchema> = PartialResolve<T>;
+/** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
+/** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
 export {};

package/build/import/type/partial/partial.mjs

@@ -6,30 +6,39 @@ import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+// prettier-ignore
 function FromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [PartialResolve(L), ...FromIntersect(R)]
         : []);
 }
+// prettier-ignore
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [PartialResolve(L), ...FromUnion(R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(T) {
     return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
         return { ...Acc, [K]: Optional(T[K]) };
     }, {});
 }
+// prettier-ignore
 function PartialResolve(T) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
             IsObjectType(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
+/** `[Json]` Constructs a type where all properties are optional */
 export function Partial(T, options = {}) {
     if (IsMappedResultType(T)) {
         return PartialFromMappedResult(T, options);

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

@@ -1,19 +1,23 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
+// prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
         [K]: Pick(T, [K], options)
     };
 }
+// prettier-ignore
 function FromPropertyKeys(T, K, options) {
     const [LK, ...RK] = K;
     return (K.length > 0
         ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(T, K, options) {
     return FromPropertyKeys(T, K.keys, options);
 }
+// prettier-ignore
 export function PickFromMappedKey(T, K, options) {
     const P = FromMappedKey(T, K, options);
     return MappedResult(P);

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

@@ -16,7 +16,10 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<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): TPickFromMappedKey<T, K>;
+/** `[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>;
+/** `[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 {};

package/build/import/type/pick/pick.mjs

@@ -6,18 +6,25 @@ import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType, } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
+// prettier-ignore
 function FromUnion(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
+// prettier-ignore
 function FromProperties(T, K) {
     return K.reduce((Acc, K) => {
         return K in T ? { ...Acc, [K]: T[K] } : Acc;
     }, {});
 }
+// prettier-ignore
 export function PickResolve(T, K) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf, K)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf, K)) :

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

@@ -7,4 +7,5 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     type: 'Promise';
     item: TSchema;
 }
+/** `[JavaScript]` Creates a Promise type */
 export declare function Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;

package/build/import/type/promise/promise.mjs

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

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

@@ -3,4 +3,5 @@ import { ReadonlyKind } from '../symbols/index.mjs';
 export type TReadonly<T extends TSchema> = T & {
     [ReadonlyKind]: 'Readonly';
 };
+/** `[Json]` Creates a Readonly property */
 export declare function Readonly<T extends TSchema>(schema: T): TReadonly<T>;

package/build/import/type/readonly/readonly.mjs

@@ -1,5 +1,6 @@
 import { ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[Json]` Creates a Readonly property */
 export function Readonly(schema) {
     return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' };
 }

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

@@ -2,4 +2,5 @@ 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/import/type/readonly-optional/readonly-optional.mjs

@@ -1,5 +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));
 }