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

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

@@ -12,4 +12,5 @@ export interface TBigInt extends TSchema, BigIntOptions {
     static: bigint;
     type: 'bigint';
 }
+/** `[JavaScript]` Creates a BigInt type */
 export declare function BigInt(options?: BigIntOptions): TBigInt;

package/build/import/type/bigint/bigint.mjs

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

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

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

package/build/import/type/boolean/boolean.mjs

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

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

@@ -1,3 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+/** Clones a Rest */
 export declare function CloneRest<T extends TSchema[]>(schemas: T): T;
+/** Clones a Type */
 export declare function CloneType<T extends TSchema>(schema: T, options?: SchemaOptions): T;

package/build/import/type/clone/type.mjs

@@ -1,7 +1,9 @@
 import { Clone } from './value.mjs';
+/** Clones a Rest */
 export function CloneRest(schemas) {
     return schemas.map((schema) => CloneType(schema));
 }
+/** Clones a Type */
 export function CloneType(schema, options = {}) {
     return { ...Clone(schema), ...options };
 }

package/build/import/type/clone/value.d.mts

@@ -1 +1,2 @@
+/** Clones a value */
 export declare function Clone<T>(value: T): T;

package/build/import/type/clone/value.mjs

@@ -13,6 +13,7 @@ function ObjectType(value) {
     const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
     return { ...clonedProperties, ...clonedSymbols };
 }
+// prettier-ignore
 function Visit(value) {
     return (ValueGuard.IsArray(value) ? ArrayType(value) :
         ValueGuard.IsDate(value) ? DateType(value) :
@@ -20,6 +21,7 @@ function Visit(value) {
                 ValueGuard.IsObject(value) ? ObjectType(value) :
                     value);
 }
+/** Clones a value */
 export function Clone(value) {
     return Visit(value);
 }

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

@@ -10,5 +10,6 @@ type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> exten
 export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;
 export declare function CompositeResolve<T extends TObject[]>(T: [...T]): CompositeResolve<T>;
 export type TComposite<T extends TObject[]> = CompositeResolve<T>;
+/** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/import/type/composite/composite.mjs

@@ -9,6 +9,7 @@ export function CompositeResolve(T) {
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {});
     return Object(properties);
 }
+/** `[Json]` Creates a Composite object type */
 export function Composite(T, options) {
     return CloneType(CompositeResolve(T), options);
 }

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

@@ -25,5 +25,6 @@ declare function ConditionalReadonly<T extends TSchema, Root extends boolean>(T:
 type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<FromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? ConditionalReadonly<TObject<Evaluate<FromProperties<T>>>, Root> : T extends Function ? ConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
 declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
 export type TConst<T> = FromValue<T, true>;
-export declare function Const<T>(T: T, options?: SchemaOptions): TConst<T>;
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+export declare function Const</* const (not supported in 4.0) */ T>(T: T, options?: SchemaOptions): TConst<T>;
 export {};

package/build/import/type/const/const.mjs

@@ -13,12 +13,14 @@ import { Undefined } from '../undefined/index.mjs';
 import { Uint8Array } from '../uint8array/index.mjs';
 import { Unknown } from '../unknown/index.mjs';
 import { TypeClone } from '../clone/index.mjs';
+// prettier-ignore
 function FromArray(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [FromValue(L, false), ...FromArray(R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(value) {
     return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
         return { ...acc, [key]: Readonly(FromValue(value[key], false)) };
@@ -27,10 +29,11 @@ function FromProperties(value) {
 function ConditionalReadonly(T, root) {
     return (root === true ? T : Readonly(T));
 }
+// prettier-ignore
 function FromValue(value, root) {
     return (IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
         IsIterator(value) ? ConditionalReadonly(Any(), root) :
-            IsArray(value) ? Readonly(Tuple(FromArray(value))) :
+            IsArray(value) ? Readonly(Tuple(FromArray(value))) : // Always Readonly
                 IsUint8Array(value) ? Uint8Array() :
                     IsDate(value) ? Date() :
                         IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :
@@ -44,6 +47,7 @@ function FromValue(value, root) {
                                                         IsString(value) ? Literal(value) :
                                                             Object({}));
 }
+/** `[JavaScript]` Creates a readonly const type from the given value. */
 export function Const(T, options = {}) {
     return TypeClone.CloneType(FromValue(T, true), options);
 }

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

@@ -12,5 +12,6 @@ export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema
     parameters: T;
     returns: U;
 }
+/** `[JavaScript]` Creates a Constructor type */
 export declare function Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
 export {};

package/build/import/type/constructor/constructor.mjs

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

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

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

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

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

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

@@ -1,10 +1,15 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 export interface DateOptions extends SchemaOptions {
+    /** The exclusive maximum timestamp value */
     exclusiveMaximumTimestamp?: number;
+    /** The exclusive minimum timestamp value */
     exclusiveMinimumTimestamp?: number;
+    /** The maximum timestamp value */
     maximumTimestamp?: number;
+    /** The minimum timestamp value */
     minimumTimestamp?: number;
+    /** The multiple of timestamp value */
     multipleOfTimestamp?: number;
 }
 export interface TDate extends TSchema, DateOptions {
@@ -12,4 +17,5 @@ export interface TDate extends TSchema, DateOptions {
     static: Date;
     type: 'date';
 }
+/** `[JavaScript]` Creates a Date type */
 export declare function Date(options?: DateOptions): TDate;

package/build/import/type/date/date.mjs

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

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

@@ -19,5 +19,6 @@ declare function FromProperties(properties: TProperties, references: TSchema[]):
 export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<FromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
 export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export type TDeref<T extends TSchema> = DerefResolve<T>;
+/** `[Json]` Creates a dereferenced type */
 export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export {};

package/build/import/type/deref/deref.mjs

@@ -1,37 +1,47 @@
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { IsUndefined } from '../guard/value.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TPromise as IsPromiseType, TAsyncIterator as IsAsyncIteratorType, TIterator as IsIteratorType, TRef as IsRefType, } from '../guard/type.mjs';
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));
 }
+// prettier-ignore
 function FromProperties(properties, references) {
     return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
         return { ...acc, [key]: Deref(properties[key], references) };
     }, {});
 }
+// prettier-ignore
 function FromConstructor(schema, references) {
     const clone = CloneType(schema);
     clone.parameters = FromRest(clone.parameters, references);
     clone.returns = Deref(clone.returns, references);
     return clone;
 }
+// prettier-ignore
 function FromFunction(schema, references) {
     const clone = CloneType(schema);
     clone.parameters = FromRest(clone.parameters, references);
     clone.returns = Deref(clone.returns, references);
     return clone;
 }
+// prettier-ignore
 function FromIntersect(schema, references) {
     const clone = CloneType(schema);
     clone.allOf = FromRest(clone.allOf, references);
     return clone;
 }
+// prettier-ignore
 function FromUnion(schema, references) {
     const clone = CloneType(schema);
     clone.anyOf = FromRest(clone.anyOf, references);
     return clone;
 }
+// prettier-ignore
 function FromTuple(schema, references) {
     const clone = CloneType(schema);
     if (IsUndefined(clone.items))
@@ -39,31 +49,37 @@ function FromTuple(schema, references) {
     clone.items = FromRest(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromArray(schema, references) {
     const clone = CloneType(schema);
     clone.items = Deref(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromObject(schema, references) {
     const clone = CloneType(schema);
     clone.properties = FromProperties(clone.properties, references);
     return clone;
 }
+// prettier-ignore
 function FromPromise(schema, references) {
     const clone = CloneType(schema);
     clone.item = Deref(clone.item, references);
     return clone;
 }
+// prettier-ignore
 function FromAsyncIterator(schema, references) {
     const clone = CloneType(schema);
     clone.items = Deref(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromIterator(schema, references) {
     const clone = CloneType(schema);
     clone.items = Deref(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromRef(schema, references) {
     const target = references.find(remote => remote.$id === schema.$ref);
     if (target === undefined)
@@ -71,6 +87,7 @@ function FromRef(schema, references) {
     const discard = Discard(target, ['$id']);
     return Deref(discard, references);
 }
+// prettier-ignore
 export function DerefResolve(schema, references) {
     return (IsConstructorType(schema) ? FromConstructor(schema, references) :
         IsFunctionType(schema) ? FromFunction(schema, references) :
@@ -85,6 +102,7 @@ export function DerefResolve(schema, references) {
                                             IsRefType(schema) ? FromRef(schema, references) :
                                                 schema);
 }
+/** `[Json]` Creates a dereferenced type */
 export function Deref(schema, references) {
     return DerefResolve(schema, references);
 }

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

@@ -10,4 +10,5 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<T[keyof T]>[];
 }
+/** `[Json]` Creates a Enum type */
 export declare function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;

package/build/import/type/enum/enum.mjs

@@ -2,6 +2,7 @@ import { Literal } from '../literal/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsUndefined } from '../guard/value.mjs';
+/** `[Json]` Creates a Enum type */
 export function Enum(item, options = {}) {
     if (IsUndefined(item))
         throw new Error('Enum undefined or empty');

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

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

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

@@ -18,6 +18,8 @@ type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTu
 type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
 declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
 export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/import/type/exclude/exclude.mjs

@@ -4,7 +4,9 @@ import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
+// prettier-ignore
 import { TMappedResult as IsMappedResultType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
+// prettier-ignore
 function ExcludeResolve(L, R) {
     return (IsTemplateLiteralType(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
         IsTemplateLiteralType(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
@@ -15,6 +17,7 @@ function ExcludeResolve(L, R) {
                 ExtendsCheck(L, R) !== ExtendsResult.False ? Never() :
                     L);
 }
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export function Exclude(unionType, excludedMembers, options = {}) {
     if (IsMappedResultType(unionType)) {
         return ExcludeFromMappedResult(unionType, excludedMembers, options);