@sinclair/typebox 0.33.22 → 0.34.1

package/build/cjs/type/type/json.d.ts

@@ -3,28 +3,28 @@ import { type TArray, type ArrayOptions } from '../array/index';
 import { type TBoolean } from '../boolean/index';
 import { type TComposite } from '../composite/index';
 import { type TConst } from '../const/index';
-import { type TDeref } from '../deref/index';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index';
+import { TIndex, type TIndexPropertyKeys } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { Intersect, type IntersectOptions } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
-import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index';
+import { type TKeyOf } from '../keyof/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
 import { type TNever } from '../never/index';
 import { type TNot } from '../not/index';
 import { type TNull } from '../null/index';
 import { type TMappedKey } from '../mapped/index';
+import { TModule } from '../module/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
-import { type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index';
+import { type TOmit } from '../omit/index';
 import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
-import { type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index';
+import { type TPick } from '../pick/index';
 import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TRecordOrObject } from '../record/index';
@@ -33,7 +33,6 @@ import { type TRef } from '../ref/index';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index';
 import { type TRest } from '../rest/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
-import { type TStrict } from '../strict/index';
 import { type TString, type StringOptions } from '../string/index';
 import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index';
 import { TransformDecodeBuilder } from '../transform/index';
@@ -43,38 +42,28 @@ import { type TUnknown } from '../unknown/index';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
 /** Json Type Builder with Static Resolution for TypeScript */
 export declare class JsonTypeBuilder {
-    /**
-     * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
-     * to use the JSON parse/stringify to remove compositing symbols if needed. This
-     * is how Strict works internally.
-     *
-     * ```typescript
-     * JSON.parse(JSON.stringify(Type.String()))
-     * ```
-     */
-    Strict<T extends TSchema>(schema: T): TStrict<T>;
     /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    ReadonlyOptional<Type extends TSchema>(type: Type): TReadonlyOptional<Type>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+    Readonly<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TReadonlyFromMappedResult<Type, Flag>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+    Readonly<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TReadonlyWithFlag<Type, Flag>;
     /** `[Json]` Creates a Optional property */
-    Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+    Readonly<Type extends TMappedResult>(type: Type): TReadonlyFromMappedResult<Type, true>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+    Readonly<Type extends TSchema>(type: Type): TReadonlyWithFlag<Type, true>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+    Optional<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TOptionalFromMappedResult<Type, Flag>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+    Optional<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TOptionalWithFlag<Type, Flag>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+    Optional<Type extends TMappedResult>(type: Type): TOptionalFromMappedResult<Type, true>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
+    Optional<Type extends TSchema>(type: Type): TOptionalWithFlag<Type, true>;
     /** `[Json]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
     /** `[Json]` Creates an Array type */
-    Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+    Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
     /** `[Json]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
@@ -83,8 +72,6 @@ export declare class JsonTypeBuilder {
     Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[JavaScript]` Creates a readonly const type from the given value. */
     Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
-    /** `[Json]` Creates a dereferenced type */
-    Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     /** `[Json]` Creates a Enum type */
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
@@ -106,87 +93,77 @@ export declare class JsonTypeBuilder {
     /** `[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>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
+    Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+    Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
     /** `[Json]` Creates an Integer type */
     Integer(options?: IntegerOptions): TInteger;
     /** `[Json]` Creates an Intersect type */
-    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;
+    Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;
     /** `[Json]` Creates a KeyOf type */
-    KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
-    /** `[Json]` Creates a KeyOf type */
-    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
     /** `[Json]` Creates a Literal type */
-    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    Literal<LiteralValue extends TLiteralValue>(literalValue: LiteralValue, options?: SchemaOptions): TLiteral<LiteralValue>;
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
+    Lowercase<Type extends TSchema>(type: Type, options?: SchemaOptions): TLowercase<Type>;
     /** `[Json]` Creates a Mapped object type */
     Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
     /** `[Json]` Creates a Mapped object type */
     Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Type Definition Module. */
+    Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;
     /** `[Json]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
     /** `[Json]` Creates a Not type */
-    Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+    Not<T extends TSchema>(type: T, options?: SchemaOptions): TNot<T>;
     /** `[Json]` Creates a Null type */
     Null(options?: SchemaOptions): TNull;
     /** `[Json]` Creates a Number type */
     Number(options?: NumberOptions): TNumber;
     /** `[Json]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    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 */
-    Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<T extends TSchema>(schema: T, options?: SchemaOptions): TPartial<T>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
+    Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
+    Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    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 */
-    Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+    Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
     /** `[Json]` Creates a Record type */
-    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T>;
+    Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value>;
     /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     /** `[Json]` Creates a Ref type. */
-    Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+    Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
+    Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest<T extends TSchema>(schema: T): TRest<T>;
+    Rest<Type extends TSchema>(type: Type): TRest<Type>;
     /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
+    TemplateLiteral<Syntax extends string>(syntax: Syntax, options?: SchemaOptions): TTemplateLiteralSyntax<Syntax>;
     /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+    TemplateLiteral<Kinds extends TTemplateLiteralKind[]>(kinds: [...Kinds], options?: SchemaOptions): TTemplateLiteral<Kinds>;
     /** `[Json]` Creates a Transform type */
-    Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+    Transform<Type extends TSchema>(type: Type): TransformDecodeBuilder<Type>;
     /** `[Json]` Creates a Tuple type */
-    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
+    Uncapitalize<Type extends TSchema>(type: Type, options?: SchemaOptions): TUncapitalize<Type>;
     /** `[Json]` Creates a Union type */
-    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T>;
+    Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;
     /** `[Json]` Creates an Unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */

package/build/cjs/type/type/json.js

@@ -7,21 +7,21 @@ const index_2 = require("../array/index");
 const index_3 = require("../boolean/index");
 const index_4 = require("../composite/index");
 const index_5 = require("../const/index");
-const index_6 = require("../deref/index");
-const index_7 = require("../enum/index");
-const index_8 = require("../exclude/index");
-const index_9 = require("../extends/index");
-const index_10 = require("../extract/index");
-const index_11 = require("../indexed/index");
-const index_12 = require("../integer/index");
-const index_13 = require("../intersect/index");
-const index_14 = require("../intrinsic/index");
-const index_15 = require("../keyof/index");
-const index_16 = require("../literal/index");
-const index_17 = require("../mapped/index");
-const index_18 = require("../never/index");
-const index_19 = require("../not/index");
-const index_20 = require("../null/index");
+const index_6 = require("../enum/index");
+const index_7 = require("../exclude/index");
+const index_8 = require("../extends/index");
+const index_9 = require("../extract/index");
+const index_10 = require("../indexed/index");
+const index_11 = require("../integer/index");
+const index_12 = require("../intersect/index");
+const index_13 = require("../intrinsic/index");
+const index_14 = require("../keyof/index");
+const index_15 = require("../literal/index");
+const index_16 = require("../mapped/index");
+const index_17 = require("../never/index");
+const index_18 = require("../not/index");
+const index_19 = require("../null/index");
+const index_20 = require("../module/index");
 const index_21 = require("../number/index");
 const index_22 = require("../object/index");
 const index_23 = require("../omit/index");
@@ -35,45 +35,29 @@ const index_30 = require("../recursive/index");
 const index_31 = require("../ref/index");
 const index_32 = require("../required/index");
 const index_33 = require("../rest/index");
-const index_34 = require("../strict/index");
-const index_35 = require("../string/index");
-const index_36 = require("../template-literal/index");
-const index_37 = require("../transform/index");
-const index_38 = require("../tuple/index");
-const index_39 = require("../union/index");
-const index_40 = require("../unknown/index");
-const index_41 = require("../unsafe/index");
+const index_34 = require("../string/index");
+const index_35 = require("../template-literal/index");
+const index_36 = require("../transform/index");
+const index_37 = require("../tuple/index");
+const index_38 = require("../union/index");
+const index_39 = require("../unknown/index");
+const index_40 = require("../unsafe/index");
 /** Json Type Builder with Static Resolution for TypeScript */
 class JsonTypeBuilder {
-    // ------------------------------------------------------------------------
-    // Strict
-    // ------------------------------------------------------------------------
-    /**
-     * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
-     * to use the JSON parse/stringify to remove compositing symbols if needed. This
-     * is how Strict works internally.
-     *
-     * ```typescript
-     * JSON.parse(JSON.stringify(Type.String()))
-     * ```
-     */
-    Strict(schema) {
-        return (0, index_34.Strict)(schema);
-    }
     // ------------------------------------------------------------------------
     // Modifiers
     // ------------------------------------------------------------------------
     /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional(schema) {
-        return (0, index_28.ReadonlyOptional)(schema);
+    ReadonlyOptional(type) {
+        return (0, index_28.ReadonlyOptional)(type);
     }
     /** `[Json]` Creates a Readonly property */
-    Readonly(schema, enable) {
-        return (0, index_27.Readonly)(schema, enable ?? true);
+    Readonly(type, enable) {
+        return (0, index_27.Readonly)(type, enable ?? true);
     }
     /** `[Json]` Creates a Optional property */
-    Optional(schema, enable) {
-        return (0, index_24.Optional)(schema, enable ?? true);
+    Optional(type, enable) {
+        return (0, index_24.Optional)(type, enable ?? true);
     }
     // ------------------------------------------------------------------------
     // Types
@@ -83,8 +67,8 @@ class JsonTypeBuilder {
         return (0, index_1.Any)(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options) {
-        return (0, index_2.Array)(schema, options);
+    Array(items, options) {
+        return (0, index_2.Array)(items, options);
     }
     /** `[Json]` Creates a Boolean type */
     Boolean(options) {
@@ -92,7 +76,7 @@ class JsonTypeBuilder {
     }
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
     Capitalize(schema, options) {
-        return (0, index_14.Capitalize)(schema, options);
+        return (0, index_13.Capitalize)(schema, options);
     }
     /** `[Json]` Creates a Composite object type */
     Composite(schemas, options) {
@@ -102,65 +86,65 @@ class JsonTypeBuilder {
     Const(value, options) {
         return (0, index_5.Const)(value, options);
     }
-    /** `[Json]` Creates a dereferenced type */
-    Deref(schema, references) {
-        return (0, index_6.Deref)(schema, references);
-    }
     /** `[Json]` Creates a Enum type */
     Enum(item, options) {
-        return (0, index_7.Enum)(item, options);
+        return (0, index_6.Enum)(item, options);
     }
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude(unionType, excludedMembers, options) {
-        return (0, index_8.Exclude)(unionType, excludedMembers, options);
+        return (0, index_7.Exclude)(unionType, excludedMembers, options);
     }
     /** `[Json]` Creates a Conditional type */
     Extends(L, R, T, F, options) {
-        return (0, index_9.Extends)(L, R, T, F, options);
+        return (0, index_8.Extends)(L, R, T, F, options);
     }
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract(type, union, options) {
-        return (0, index_10.Extract)(type, union, options);
+        return (0, index_9.Extract)(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options) {
-        return (0, index_11.Index)(schema, unresolved, options);
+    Index(type, key, options) {
+        return (0, index_10.Index)(type, key, options);
     }
     /** `[Json]` Creates an Integer type */
     Integer(options) {
-        return (0, index_12.Integer)(options);
+        return (0, index_11.Integer)(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options) {
-        return (0, index_13.Intersect)(T, options);
+    Intersect(types, options) {
+        return (0, index_12.Intersect)(types, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options) {
-        return (0, index_15.KeyOf)(schema, options);
+    KeyOf(type, options) {
+        return (0, index_14.KeyOf)(type, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options) {
-        return (0, index_16.Literal)(value, options);
+    Literal(literalValue, options) {
+        return (0, index_15.Literal)(literalValue, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options) {
-        return (0, index_14.Lowercase)(schema, options);
+    Lowercase(type, options) {
+        return (0, index_13.Lowercase)(type, options);
     }
     /** `[Json]` Creates a Mapped object type */
     Mapped(key, map, options) {
-        return (0, index_17.Mapped)(key, map, options);
+        return (0, index_16.Mapped)(key, map, options);
+    }
+    /** `[Json]` Creates a Type Definition Module. */
+    Module(properties) {
+        return (0, index_20.Module)(properties);
     }
     /** `[Json]` Creates a Never type */
     Never(options) {
-        return (0, index_18.Never)(options);
+        return (0, index_17.Never)(options);
     }
     /** `[Json]` Creates a Not type */
-    Not(schema, options) {
-        return (0, index_19.Not)(schema, options);
+    Not(type, options) {
+        return (0, index_18.Not)(type, options);
     }
     /** `[Json]` Creates a Null type */
     Null(options) {
-        return (0, index_20.Null)(options);
+        return (0, index_19.Null)(options);
     }
     /** `[Json]` Creates a Number type */
     Number(options) {
@@ -171,72 +155,72 @@ class JsonTypeBuilder {
         return (0, index_22.Object)(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options) {
-        return (0, index_23.Omit)(schema, unresolved, options);
+    Omit(schema, selector, options) {
+        return (0, index_23.Omit)(schema, selector, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options) {
-        return (0, index_25.Partial)(schema, options);
+    Partial(type, options) {
+        return (0, index_25.Partial)(type, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options) {
-        return (0, index_26.Pick)(schema, unresolved, options);
+    Pick(type, key, options) {
+        return (0, index_26.Pick)(type, key, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options) {
-        return (0, index_29.Record)(key, schema, options);
+    Record(key, value, options) {
+        return (0, index_29.Record)(key, value, options);
     }
     /** `[Json]` Creates a Recursive type */
     Recursive(callback, options) {
         return (0, index_30.Recursive)(callback, options);
     }
     /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options) {
-        return (0, index_31.Ref)(unresolved, options);
+    Ref($ref, options) {
+        return (0, index_31.Ref)($ref, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options) {
-        return (0, index_32.Required)(schema, options);
+    Required(type, options) {
+        return (0, index_32.Required)(type, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest(schema) {
-        return (0, index_33.Rest)(schema);
+    Rest(type) {
+        return (0, index_33.Rest)(type);
     }
     /** `[Json]` Creates a String type */
     String(options) {
-        return (0, index_35.String)(options);
+        return (0, index_34.String)(options);
     }
     /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral(unresolved, options) {
-        return (0, index_36.TemplateLiteral)(unresolved, options);
+        return (0, index_35.TemplateLiteral)(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
-    Transform(schema) {
-        return (0, index_37.Transform)(schema);
+    Transform(type) {
+        return (0, index_36.Transform)(type);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options) {
-        return (0, index_38.Tuple)(items, options);
+    Tuple(types, options) {
+        return (0, index_37.Tuple)(types, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options) {
-        return (0, index_14.Uncapitalize)(schema, options);
+    Uncapitalize(type, options) {
+        return (0, index_13.Uncapitalize)(type, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options) {
-        return (0, index_39.Union)(schemas, options);
+    Union(types, options) {
+        return (0, index_38.Union)(types, options);
     }
     /** `[Json]` Creates an Unknown type */
     Unknown(options) {
-        return (0, index_40.Unknown)(options);
+        return (0, index_39.Unknown)(options);
     }
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe(options) {
-        return (0, index_41.Unsafe)(options);
+        return (0, index_40.Unsafe)(options);
     }
     /** `[Json]` Intrinsic function to Uppercase LiteralString types */
     Uppercase(schema, options) {
-        return (0, index_14.Uppercase)(schema, options);
+        return (0, index_13.Uppercase)(schema, options);
     }
 }
 exports.JsonTypeBuilder = JsonTypeBuilder;

package/build/cjs/type/type/type.d.ts

@@ -9,7 +9,6 @@ export { Const } from '../const/index';
 export { Constructor } from '../constructor/index';
 export { ConstructorParameters } from '../constructor-parameters/index';
 export { Date } from '../date/index';
-export { Deref } from '../deref/index';
 export { Enum } from '../enum/index';
 export { Exclude } from '../exclude/index';
 export { Extends } from '../extends/index';
@@ -24,6 +23,7 @@ export { Iterator } from '../iterator/index';
 export { KeyOf } from '../keyof/index';
 export { Literal } from '../literal/index';
 export { Mapped } from '../mapped/index';
+export { Module } from '../module/index';
 export { Never } from '../never/index';
 export { Not } from '../not/index';
 export { Null } from '../null/index';
@@ -45,7 +45,6 @@ export { Required } from '../required/index';
 export { Rest } from '../rest/index';
 export { ReturnType } from '../return-type/index';
 export { String } from '../string/index';
-export { Strict } from '../strict/index';
 export { Symbol } from '../symbol/index';
 export { TemplateLiteral } from '../template-literal/index';
 export { Transform } from '../transform/index';