@sinclair/typebox 0.30.4 → 0.31.0-dev-2

package/typebox.d.ts

@@ -1,3 +1,4 @@
+export declare const Transform: unique symbol;
 export declare const Readonly: unique symbol;
 export declare const Optional: unique symbol;
 export declare const Hint: unique symbol;
@@ -148,6 +149,8 @@ export interface DateOptions extends SchemaOptions {
     maximumTimestamp?: number;
     /** The minimum timestamp value */
     minimumTimestamp?: number;
+    /** The multiple of timestamp value */
+    multipleOfTimestamp?: number;
 }
 export interface TDate extends TSchema, DateOptions {
     [Kind]: 'Date';
@@ -284,8 +287,11 @@ export type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
 export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
 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 {
@@ -362,7 +368,7 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
     static: Static<T, this['params']>;
     $ref: string;
 }
-export type TRest<T extends TSchema> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : Assert<[T], TSchema[]>;
+export type TRest<T extends TSchema> = T extends TIntersect<infer R> ? R : T extends TUnion<infer R> ? R : T extends TTuple<infer R> ? R : [];
 export type TReturnType<T extends TFunction> = T['returns'];
 export type TRequiredRest<T extends TSchema[]> = AssertRest<{
     [K in keyof T]: TRequired<AssertType<T[K]>>;
@@ -420,10 +426,26 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     type: 'string';
     pattern: string;
 }
-export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : [];
+export type DecodeStaticProperties<T extends TProperties> = {
+    [K in keyof T]: DecodeStaticType<T[K]>;
+};
+export type DecodeStaticRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? [DecodeStaticType<AssertType<L>>, ...DecodeStaticRest<AssertRest<R>>] : [];
+export type DecodeStaticType<T extends TSchema> = T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S> ? TArray<DecodeStaticType<S>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<DecodeStaticType<S>> : T extends TConstructor<infer P, infer R> ? TConstructor<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> : T extends TFunction<infer P, infer R> ? TFunction<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> : T extends TIntersect<infer S> ? TIntersect<AssertRest<DecodeStaticRest<S>>> : T extends TIterator<infer S> ? TIterator<DecodeStaticType<S>> : T extends TNot<infer S> ? TNot<DecodeStaticType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeStaticProperties<S>>> : T extends TPromise<infer S> ? TPromise<DecodeStaticType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeStaticType<S>> : T extends TRecursive<infer S> ? TRecursive<DecodeStaticType<S>> : T extends TRef<infer S> ? TRef<DecodeStaticType<S>> : T extends TTuple<infer S> ? TTuple<AssertRest<DecodeStaticRest<S>>> : T extends TUnion<infer S> ? TUnion<AssertRest<DecodeStaticRest<S>>> : T;
+export type TransformFunction<T = any, U = any> = (value: T) => U;
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+    Decode: TransformFunction<StaticDecode<I>, O>;
+    Encode: TransformFunction<O, StaticDecode<I>>;
+}
+export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+    static: TTransformResolve<I, this['params']>;
+    [Transform]: TransformOptions<I, O>;
+    [key: string]: any;
+}
+export type TTupleRest<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleRest<AssertRest<R>, P>] : [];
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
-    static: TTupleInfer<T, this['params']>;
+    static: TTupleRest<T, this['params']>;
     type: 'array';
     items?: T;
     additionalItems?: false;
@@ -474,7 +496,11 @@ export interface TVoid extends TSchema {
     static: void;
     type: 'void';
 }
-/** Infers a static type from a TypeBox type */
+/** Creates the decoded static form for a TypeBox type */
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeStaticType<T>, P>;
+/** Creates the encoded static form for a TypeBox type */
+export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
+/** Creates the static type for a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];
@@ -494,6 +520,9 @@ export declare namespace TypeRegistry {
     /** Gets a custom validation function for a user defined type */
     function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;
 }
+export declare class TypeBoxError extends Error {
+    constructor(message: string);
+}
 export type FormatRegistryValidationFunction = (value: string) => boolean;
 /** A registry for user defined string formats */
 export declare namespace FormatRegistry {
@@ -510,19 +539,26 @@ export declare namespace FormatRegistry {
     /** Gets a validation function for a user defined string format */
     function Get(format: string): FormatRegistryValidationFunction | undefined;
 }
+/** Provides functions to type guard raw JavaScript values */
 export declare namespace ValueGuard {
-    function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+    /** Returns true if this value is an array */
     function IsArray(value: unknown): value is unknown[];
+    /** Returns true if this value is bigint */
+    function IsBigInt(value: unknown): value is bigint;
+    /** Returns true if this value is a boolean */
     function IsBoolean(value: unknown): value is boolean;
+    /** Returns true if this value is null */
     function IsNull(value: unknown): value is null;
-    function IsUndefined(value: unknown): value is undefined;
-    function IsBigInt(value: unknown): value is bigint;
+    /** Returns true if this value is number */
     function IsNumber(value: unknown): value is number;
+    /** Returns true if this value is an object */
+    function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+    /** Returns true if this value is string */
     function IsString(value: unknown): value is string;
+    /** Returns true if this value is undefined */
+    function IsUndefined(value: unknown): value is undefined;
 }
-export declare class TypeGuardUnknownTypeError extends Error {
-    readonly schema: unknown;
-    constructor(schema: unknown);
+export declare class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 /** Provides functions to test if JavaScript values are TypeBox types */
 export declare namespace TypeGuard {
@@ -578,6 +614,10 @@ export declare namespace TypeGuard {
     function TPromise(schema: unknown): schema is TPromise;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema: unknown): schema is TRecord;
+    /** Returns true if this schema is TRecursive */
+    function TRecursive(schema: unknown): schema is {
+        [Hint]: 'Recursive';
+    };
     /** Returns true if the given schema is TRef */
     function TRef(schema: unknown): schema is TRef;
     /** Returns true if the given schema is TString */
@@ -588,6 +628,10 @@ export declare namespace TypeGuard {
     function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral;
     /** Returns true if the given schema is TThis */
     function TThis(schema: unknown): schema is TThis;
+    /** Returns true of this schema is TTransform */
+    function TTransform(schema: unknown): schema is {
+        [Transform]: TransformOptions;
+    };
     /** Returns true if the given schema is TTuple */
     function TTuple(schema: unknown): schema is TTuple;
     /** Returns true if the given schema is TUndefined */
@@ -615,6 +659,8 @@ export declare namespace TypeGuard {
 export declare namespace ExtendsUndefined {
     function Check(schema: TSchema): boolean;
 }
+export declare class TypeExtendsError extends TypeBoxError {
+}
 export declare enum TypeExtendsResult {
     Union = 0,
     True = 1,
@@ -625,8 +671,10 @@ export declare namespace TypeExtends {
 }
 /** Specialized Clone for Types */
 export declare namespace TypeClone {
-    /** Clones a type. */
-    function Clone<T extends TSchema>(schema: T, options?: SchemaOptions): T;
+    /** Clones a Rest */
+    function Rest<T extends TSchema[]>(schemas: [...T]): T;
+    /** Clones a Type */
+    function Type<T extends TSchema>(schema: T, options?: SchemaOptions): T;
 }
 export declare namespace IndexedAccessor {
     function Resolve(schema: TSchema, keys: TPropertyKey[], options?: SchemaOptions): TSchema;
@@ -647,6 +695,8 @@ export declare namespace KeyResolver {
     /** Resolves a regular expression pattern matching all keys in this schema */
     function ResolvePattern(schema: TSchema): string;
 }
+export declare class KeyArrayResolverError extends TypeBoxError {
+}
 export declare namespace KeyArrayResolver {
     /** Resolves an array of string[] keys from the given schema or array type. */
     function Resolve(schema: TSchema | string[]): string[];
@@ -655,6 +705,8 @@ export declare namespace UnionResolver {
     /** Returns a resolved union with interior unions flattened */
     function Resolve(union: TUnion): TUnion;
 }
+export declare class TemplateLiteralPatternError extends TypeBoxError {
+}
 export declare namespace TemplateLiteralPattern {
     function Create(kinds: TTemplateLiteralKind[]): string;
 }
@@ -662,8 +714,7 @@ export declare namespace TemplateLiteralResolver {
     /** Resolves a template literal as a TUnion */
     function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral;
 }
-export declare class TemplateLiteralParserError extends Error {
-    constructor(message: string);
+export declare class TemplateLiteralParserError extends TypeBoxError {
 }
 export declare namespace TemplateLiteralParser {
     type Expression = And | Or | Const;
@@ -684,196 +735,219 @@ export declare namespace TemplateLiteralParser {
     /** Parses a pattern and strips forward and trailing ^ and $ */
     function ParseExact(pattern: string): Expression;
 }
+export declare class TemplateLiteralFiniteError extends TypeBoxError {
+}
 export declare namespace TemplateLiteralFinite {
     function Check(expression: TemplateLiteralParser.Expression): boolean;
 }
+export declare class TemplateLiteralGeneratorError extends TypeBoxError {
+}
 export declare namespace TemplateLiteralGenerator {
     function Generate(expression: TemplateLiteralParser.Expression): IterableIterator<string>;
 }
 export declare namespace TemplateLiteralDslParser {
     function Parse(template_dsl: string): TTemplateLiteralKind[];
 }
+export declare class TransformDecodeBuilder<T extends TSchema> {
+    private readonly schema;
+    constructor(schema: T);
+    Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
+}
+export declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+    private readonly schema;
+    private readonly decode;
+    constructor(schema: T, decode: D);
+    Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
+}
+export declare class TypeBuilderError extends TypeBoxError {
+}
 export declare class TypeBuilder {
-    /** `[Utility]` Creates a schema without `static` and `params` types */
+    /** `[Internal]` Creates a schema without `static` and `params` types */
     protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
-    /** `[Utility]` Discards a property key from the given schema */
+    /** `[Internal]` Throws a TypeBuilder error with the given message */
+    protected Throw(message: string): never;
+    /** `[Internal]` Discards a property key from the given schema */
     protected Discard(schema: TSchema, key: PropertyKey): TSchema;
-    /** `[Standard]` Omits compositing symbols from this schema */
+    /** `[Json]` Omits compositing symbols from this schema */
     Strict<T extends TSchema>(schema: T): T;
 }
-export declare class StandardTypeBuilder extends TypeBuilder {
-    /** `[Standard]` Creates a Readonly and Optional property */
+export declare class JsonTypeBuilder extends TypeBuilder {
+    /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;
-    /** `[Standard]` Creates a Readonly property */
+    /** `[Json]` Creates a Readonly property */
     Readonly<T extends TSchema>(schema: T): TReadonly<T>;
-    /** `[Standard]` Creates an Optional property */
+    /** `[Json]` Creates an Optional property */
     Optional<T extends TSchema>(schema: T): TOptional<T>;
-    /** `[Standard]` Creates an Any type */
+    /** `[Json]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
-    /** `[Standard]` Creates an Array type */
+    /** `[Json]` Creates an Array type */
     Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
-    /** `[Standard]` Creates a Boolean type */
+    /** `[Json]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Standard]` Intrinsic function to Capitalize LiteralString types */
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
     Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Capitalize'>;
-    /** `[Standard]` Creates a Composite object type */
+    /** `[Json]` Creates a Composite object type */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
-    /** `[Standard]` Creates a Enum type */
+    /** `[Json]` Creates a Enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
-    /** `[Standard]` Creates a Conditional type */
+    /** `[Json]` Creates a Conditional type */
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
-    /** `[Standard]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Standard]` Constructs a type by extracting from type all union members that are assignable to union */
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
-    Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<T extends TTuple, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<AssertRest<T['items']>>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>;
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema;
-    /** `[Standard]` Creates an Integer type */
+    /** `[Json]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
-    /** `[Standard]` Creates an Intersect type */
+    /** `[Json]` Creates an Intersect type */
     Intersect(allOf: [], options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates an Intersect type */
+    /** `[Json]` Creates an Intersect type */
     Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0];
-    /** `[Standard]` Creates an Intersect type */
+    /** `[Json]` Creates an Intersect type */
     Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>;
-    /** `[Standard]` Creates a KeyOf type */
+    /** `[Json]` Creates a KeyOf type */
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
-    /** `[Standard]` Creates a Literal type */
+    /** `[Json]` Creates a Literal type */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
-    /** `[Standard]` Intrinsic function to Lowercase LiteralString types */
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
     Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Lowercase'>;
-    /** `[Standard]` Creates a Never type */
+    /** `[Json]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Not type */
+    /** `[Json]` Creates a Not type */
     Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
-    /** `[Standard]` Creates a Null type */
+    /** `[Json]` Creates a Null type */
     Null(options?: SchemaOptions): TNull;
-    /** `[Standard]` Creates a Number type */
+    /** `[Json]` Creates a Number type */
     Number(options?: NumericOptions<number>): TNumber;
-    /** `[Standard]` Creates an Object type */
+    /** `[Json]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
-    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>;
-    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>;
-    /** `[Standard]` Constructs a type where all properties are optional */
+    /** `[Json]` Constructs a type where all properties are optional */
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    /** `[Standard]` Constructs a type whose keys are picked from the given type */
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
-    /** `[Standard]` Constructs a type whose keys are picked from the given type */
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Constructs a type whose keys are picked from the given type */
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>;
-    /** `[Standard]` Constructs a type whose keys are picked from the given type */
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>;
-    /** `[Standard]` Constructs a type whose keys are picked from the given type */
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
-    /** `[Standard]` Creates a Record type */
+    /** `[Json]` Creates a Record type */
     Record<K extends TUnion, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
-    /** `[Standard]` Creates a Record type */
+    /** `[Json]` Creates a Record type */
     Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>;
-    /** `[Standard]` Creates a Record type */
+    /** `[Json]` Creates a Record type */
     Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordTemplateLiteralType<K, T>;
-    /** `[Standard]` Creates a Record type */
+    /** `[Json]` Creates a Record type */
     Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordNumberType<K, T>;
-    /** `[Standard]` Creates a Record type */
+    /** `[Json]` Creates a Record type */
     Record<K extends TString, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordStringType<K, T>;
-    /** `[Standard]` Creates a Recursive type */
+    /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
+    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
-    /** `[Standard]` Creates a Ref type. */
+    /** `[Json]` Creates a Ref type. */
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
-    /** `[Standard]` Constructs a type where all properties are required */
+    /** `[Json]` Constructs a type where all properties are required */
     Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
-    /** `[Standard]` Extracts the rest array from a Tuple */
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
     Rest<T extends TSchema>(schema: T): TRest<T>;
-    /** `[Standard]` Creates a String type */
+    /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
-    /** `[Standard]` Creates a TemplateLiteral type from template dsl string */
+    /** `[Json]` Creates a TemplateLiteral type from template dsl string */
     TemplateLiteral<T extends string>(templateDsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>;
-    /** `[Standard]` Creates a TemplateLiteral type */
+    /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
-    /** `[Standard]` Creates a Tuple type */
+    /** `[Json]` Creates a Transform type */
+    Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+    /** `[Json]` Creates a Tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
-    /** `[Standard]` Intrinsic function to Uncapitalize LiteralString types */
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
     Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Uncapitalize'>;
-    /** `[Standard]` Creates a Union type */
+    /** `[Json]` Creates a Union type */
     Union(anyOf: [], options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Union type */
+    /** `[Json]` Creates a Union type */
     Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0];
-    /** `[Standard]` Creates a Union type */
+    /** `[Json]` Creates a Union type */
     Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>;
-    /** `[Experimental]` Converts a TemplateLiteral into a Union */
+    /** `[Json-Experimental]` Converts a TemplateLiteral into a Union */
     Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>;
-    /** `[Standard]` Creates an Unknown type */
+    /** `[Json]` Creates an Unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
-    /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-    /** `[Standard]` Intrinsic function to Uppercase LiteralString types */
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
     Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Uppercase'>;
 }
-export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
-    /** `[Extended]` Creates a AsyncIterator type */
+export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
-    /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
     Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
-    /** `[Extended]` Creates a BigInt type */
+    /** `[JavaScript]` Creates a BigInt type */
     BigInt(options?: NumericOptions<bigint>): TBigInt;
-    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
-    /** `[Extended]` Creates a Constructor type */
+    /** `[JavaScript]` Creates a Constructor type */
     Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
-    /** `[Extended]` Creates a Date type */
+    /** `[JavaScript]` Creates a Date type */
     Date(options?: DateOptions): TDate;
-    /** `[Extended]` Creates a Function type */
+    /** `[JavaScript]` Creates a Function type */
     Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
-    /** `[Extended]` Extracts the InstanceType from the given Constructor type */
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
-    /** `[Extended]` Creates an Iterator type */
+    /** `[JavaScript]` Creates an Iterator type */
     Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
-    /** `[Extended]` Extracts the Parameters from the given Function type */
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
     Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
-    /** `[Extended]` Creates a Promise type */
+    /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
-    /** `[Extended]` Creates a String type from a Regular Expression pattern */
+    /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
     RegExp(pattern: string, options?: SchemaOptions): TString;
-    /** `[Extended]` Creates a String type from a Regular Expression */
+    /** `[JavaScript]` Creates a String type from a Regular Expression */
     RegExp(regex: RegExp, options?: SchemaOptions): TString;
     /**
      * @deprecated Use `Type.RegExp`
      */
     RegEx(regex: RegExp, options?: SchemaOptions): TString;
-    /** `[Extended]` Extracts the ReturnType from the given Function type */
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
-    /** `[Extended]` Creates a Symbol type */
+    /** `[JavaScript]` Creates a Symbol type */
     Symbol(options?: SchemaOptions): TSymbol;
-    /** `[Extended]` Creates a Undefined type */
+    /** `[JavaScript]` Creates a Undefined type */
     Undefined(options?: SchemaOptions): TUndefined;
-    /** `[Extended]` Creates a Uint8Array type */
+    /** `[JavaScript]` Creates a Uint8Array type */
     Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
-    /** `[Extended]` Creates a Void type */
+    /** `[JavaScript]` Creates a Void type */
     Void(options?: SchemaOptions): TVoid;
 }
-/** JSON Schema Type Builder with Static Resolution for TypeScript */
-export declare const StandardType: StandardTypeBuilder;
-/** JSON Schema Type Builder with Static Resolution for TypeScript */
-export declare const Type: ExtendedTypeBuilder;
+/** Json Type Builder with Static Resolution for TypeScript */
+export declare const JsonType: JsonTypeBuilder;
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+export declare const Type: JavaScriptTypeBuilder;