@sinclair/typebox 0.32.35 → 0.33.1

package/build/cjs/type/pick/pick.js

@@ -2,13 +2,13 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pick = Pick;
+const type_1 = require("../create/type");
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const index_3 = require("../object/index");
 const index_4 = require("../indexed/index");
 const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
 const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
 // ------------------------------------------------------------------
@@ -40,7 +40,7 @@ function PickResolve(T, K) {
             (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
                 (0, index_3.Object)({}));
 }
-function Pick(T, K, options = {}) {
+function Pick(T, K, options) {
     // mapped
     if ((0, kind_1.IsMappedKey)(K))
         return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
@@ -49,6 +49,6 @@ function Pick(T, K, options = {}) {
     // non-mapped
     const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
     const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(PickResolve(T, I), options);
-    return { ...D, ...R };
+    const R = PickResolve(T, I);
+    return (0, type_1.CreateType)({ ...D, ...R }, options);
 }

package/build/cjs/type/promise/promise.js

@@ -2,14 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Promise = Promise;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Promise type */
-function Promise(item, options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Promise',
-        type: 'Promise',
-        item: (0, type_1.CloneType)(item),
-    };
+function Promise(item, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Promise', type: 'Promise', item }, options);
 }

package/build/cjs/type/readonly/readonly.js

@@ -2,16 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Readonly = Readonly;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const readonly_from_mapped_result_1 = require("./readonly-from-mapped-result");
 const kind_1 = require("../guard/kind");
 function RemoveReadonly(schema) {
-    return (0, index_2.Discard)((0, type_1.CloneType)(schema), [index_1.ReadonlyKind]);
+    return (0, type_1.CreateType)((0, index_2.Discard)(schema, [index_1.ReadonlyKind]));
 }
 function AddReadonly(schema) {
-    return { ...(0, type_1.CloneType)(schema), [index_1.ReadonlyKind]: 'Readonly' };
+    return (0, type_1.CreateType)({ ...schema, [index_1.ReadonlyKind]: 'Readonly' });
 }
 // prettier-ignore
 function ReadonlyWithFlag(schema, F) {

package/build/cjs/type/record/record.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = Record;
+const type_1 = require("../create/type");
 const index_1 = require("../object/index");
 const index_2 = require("../never/index");
 const index_3 = require("../union/index");
@@ -9,7 +10,6 @@ const index_4 = require("../template-literal/index");
 const index_5 = require("../patterns/index");
 const index_6 = require("../indexed/index");
 const index_7 = require("../symbols/index");
-const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -23,12 +23,11 @@ const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern, T, options) {
-    return {
-        ...options,
+    return (0, type_1.CreateType)({
         [index_7.Kind]: 'Record',
         type: 'object',
-        patternProperties: { [pattern]: (0, type_1.CloneType)(T) }
-    };
+        patternProperties: { [pattern]: T }
+    }, options);
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
@@ -37,7 +36,7 @@ function RecordCreateFromPattern(pattern, T, options) {
 function RecordCreateFromKeys(K, T, options) {
     const Acc = {};
     for (const K2 of K)
-        Acc[K2] = (0, type_1.CloneType)(T);
+        Acc[K2] = T;
     return (0, index_1.Object)(Acc, { ...options, [index_7.Hint]: 'Record' });
 }
 // prettier-ignore

package/build/cjs/type/recursive/recursive.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Recursive = Recursive;
 const type_1 = require("../clone/type");
+const type_2 = require("../create/type");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 // Auto Tracked For Recursive Types without ID's
@@ -11,8 +12,8 @@ let Ordinal = 0;
 function Recursive(callback, options = {}) {
     if ((0, value_1.IsUndefined)(options.$id))
         options.$id = `T${Ordinal++}`;
-    const thisType = callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` });
+    const thisType = (0, type_1.CloneType)(callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` }));
     thisType.$id = options.$id;
     // prettier-ignore
-    return (0, type_1.CloneType)({ ...options, [index_1.Hint]: 'Recursive', ...thisType });
+    return (0, type_2.CreateType)({ [index_1.Hint]: 'Recursive', ...thisType }, options);
 }

package/build/cjs/type/ref/ref.js

@@ -2,20 +2,17 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ref = Ref;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 /** `[Json]` Creates a Ref type. */
-function Ref(unresolved, options = {}) {
+function Ref(unresolved, options) {
     if ((0, value_1.IsString)(unresolved))
-        return { ...options, [index_1.Kind]: 'Ref', $ref: unresolved };
+        return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref: unresolved }, options);
     if ((0, value_1.IsUndefined)(unresolved.$id))
         throw new Error('Reference target type must specify an $id');
-    return {
-        ...options,
-        [index_1.Kind]: 'Ref',
-        $ref: unresolved.$id,
-    };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref: unresolved.$id }, options);
 }

package/build/cjs/type/regexp/regexp.js

@@ -2,10 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExp = RegExp;
+const type_1 = require("../create/type");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a RegExp type */
-function RegExp(unresolved, options = {}) {
+function RegExp(unresolved, options) {
     const expr = (0, value_1.IsString)(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-    return { ...options, [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options);
 }

package/build/cjs/type/required/required-from-mapped-result.d.ts

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties> = ({
 });
 type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
 export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/cjs/type/required/required.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Required = Required;
+const type_1 = require("../create/type");
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const index_3 = require("../object/index");
 const index_4 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const index_5 = require("../discard/index");
 const required_from_mapped_result_1 = require("./required-from-mapped-result");
 // ------------------------------------------------------------------
@@ -35,13 +35,13 @@ function RequiredResolve(T) {
                 (0, index_3.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
-function Required(T, options = {}) {
+function Required(T, options) {
     if ((0, kind_1.IsMappedResult)(T)) {
         return (0, required_from_mapped_result_1.RequiredFromMappedResult)(T, options);
     }
     else {
         const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
-        const R = (0, type_1.CloneType)(RequiredResolve(T), options);
-        return { ...D, ...R };
+        const R = RequiredResolve(T);
+        return (0, type_1.CreateType)({ ...D, ...R }, options);
     }
 }

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

@@ -2,7 +2,7 @@ import type { TSchema } from '../schema/index';
 import type { TIntersect } from '../intersect/index';
 import type { TUnion } from '../union/index';
 import type { TTuple } from '../tuple/index';
-type TRestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+type TRestResolve<T extends TSchema> = T extends TIntersect<infer S extends TSchema[]> ? S : T extends TUnion<infer S extends TSchema[]> ? S : T extends TTuple<infer S extends TSchema[]> ? S : [
 ];
 export type TRest<T extends TSchema> = TRestResolve<T>;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */

package/build/cjs/type/rest/rest.js

@@ -2,19 +2,18 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rest = Rest;
-const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
 function RestResolve(T) {
-    return ((0, kind_1.IsIntersect)(T) ? (0, type_1.CloneRest)(T.allOf) :
-        (0, kind_1.IsUnion)(T) ? (0, type_1.CloneRest)(T.anyOf) :
-            (0, kind_1.IsTuple)(T) ? (0, type_1.CloneRest)(T.items ?? []) :
+    return ((0, kind_1.IsIntersect)(T) ? T.allOf :
+        (0, kind_1.IsUnion)(T) ? T.anyOf :
+            (0, kind_1.IsTuple)(T) ? T.items ?? [] :
                 []);
 }
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 function Rest(T) {
-    return (0, type_1.CloneRest)(RestResolve(T));
+    return RestResolve(T);
 }

package/build/cjs/type/return-type/return-type.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturnType = ReturnType;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-function ReturnType(schema, options = {}) {
-    return (0, type_1.CloneType)(schema.returns, options);
+function ReturnType(schema, options) {
+    return (0, type_1.CreateType)(schema.returns, options);
 }

package/build/cjs/type/string/string.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.String = String;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a String type */
-function String(options = {}) {
-    return { ...options, [index_1.Kind]: 'String', type: 'string' };
+function String(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'String', type: 'string' }, options);
 }

package/build/cjs/type/symbol/symbol.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Symbol = Symbol;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Symbol type */
 function Symbol(options) {
-    return { ...options, [index_1.Kind]: 'Symbol', type: 'symbol' };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Symbol', type: 'symbol' }, options);
 }

package/build/cjs/type/template-literal/template-literal.js

@@ -2,15 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteral = TemplateLiteral;
+const type_1 = require("../create/type");
 const syntax_1 = require("./syntax");
 const pattern_1 = require("./pattern");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a TemplateLiteral type */
 // prettier-ignore
-function TemplateLiteral(unresolved, options = {}) {
+function TemplateLiteral(unresolved, options) {
     const pattern = (0, value_1.IsString)(unresolved)
         ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))
         : (0, pattern_1.TemplateLiteralPattern)(unresolved);
-    return { ...options, [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern }, options);
 }

package/build/cjs/type/transform/transform.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
 exports.Transform = Transform;
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -38,8 +37,7 @@ class TransformEncodeBuilder {
         return { ...schema, [index_1.TransformKind]: Codec };
     }
     Encode(encode) {
-        const schema = (0, type_1.CloneType)(this.schema);
-        return ((0, kind_1.IsTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+        return ((0, kind_1.IsTransform)(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema));
     }
 }
 exports.TransformEncodeBuilder = TransformEncodeBuilder;

package/build/cjs/type/tuple/tuple.js

@@ -2,14 +2,12 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tuple = Tuple;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a Tuple type */
-function Tuple(items, options = {}) {
-    // return TupleResolver.Resolve(T)
-    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+function Tuple(items, options) {
     // prettier-ignore
-    return (items.length > 0 ?
-        { ...options, [index_1.Kind]: 'Tuple', type: 'array', items: (0, type_1.CloneRest)(items), additionalItems, minItems, maxItems } :
-        { ...options, [index_1.Kind]: 'Tuple', type: 'array', minItems, maxItems });
+    return (0, type_1.CreateType)(items.length > 0 ?
+        { [index_1.Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
+        { [index_1.Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length }, options);
 }

package/build/cjs/type/type/javascript.js

@@ -23,19 +23,19 @@ const index_17 = require("../void/index");
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
     /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options = {}) {
+    AsyncIterator(items, options) {
         return (0, index_1.AsyncIterator)(items, options);
     }
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options = {}) {
+    Awaited(schema, options) {
         return (0, index_2.Awaited)(schema, options);
     }
     /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options = {}) {
+    BigInt(options) {
         return (0, index_3.BigInt)(options);
     }
     /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
+    ConstructorParameters(schema, options) {
         return (0, index_5.ConstructorParameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
@@ -51,27 +51,27 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
         return (0, index_7.Function)(parameters, returns, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options = {}) {
+    InstanceType(schema, options) {
         return (0, index_8.InstanceType)(schema, options);
     }
     /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options = {}) {
+    Iterator(items, options) {
         return (0, index_9.Iterator)(items, options);
     }
     /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
+    Parameters(schema, options) {
         return (0, index_10.Parameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options = {}) {
+    Promise(item, options) {
         return (0, index_11.Promise)(item, options);
     }
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(unresolved, options = {}) {
+    RegExp(unresolved, options) {
         return (0, index_12.RegExp)(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options = {}) {
+    ReturnType(schema, options) {
         return (0, index_13.ReturnType)(schema, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
@@ -79,15 +79,15 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
         return (0, index_14.Symbol)(options);
     }
     /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options = {}) {
+    Undefined(options) {
         return (0, index_16.Undefined)(options);
     }
     /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
+    Uint8Array(options) {
         return (0, index_15.Uint8Array)(options);
     }
     /** `[JavaScript]` Creates a Void type */
-    Void(options = {}) {
+    Void(options) {
         return (0, index_17.Void)(options);
     }
 }

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

@@ -71,19 +71,19 @@ class JsonTypeBuilder {
     // Types
     // ------------------------------------------------------------------------
     /** `[Json]` Creates an Any type */
-    Any(options = {}) {
+    Any(options) {
         return (0, index_1.Any)(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options = {}) {
+    Array(schema, options) {
         return (0, index_2.Array)(schema, options);
     }
     /** `[Json]` Creates a Boolean type */
-    Boolean(options = {}) {
+    Boolean(options) {
         return (0, index_3.Boolean)(options);
     }
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize(schema, options = {}) {
+    Capitalize(schema, options) {
         return (0, index_14.Capitalize)(schema, options);
     }
     /** `[Json]` Creates a Composite object type */
@@ -91,7 +91,7 @@ class JsonTypeBuilder {
         return (0, index_4.Composite)(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
     }
     /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const(value, options = {}) {
+    Const(value, options) {
         return (0, index_5.Const)(value, options);
     }
     /** `[Json]` Creates a dereferenced type */
@@ -99,51 +99,51 @@ class JsonTypeBuilder {
         return (0, index_6.Deref)(schema, references);
     }
     /** `[Json]` Creates a Enum type */
-    Enum(item, options = {}) {
+    Enum(item, options) {
         return (0, index_7.Enum)(item, options);
     }
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude(unionType, excludedMembers, options = {}) {
+    Exclude(unionType, excludedMembers, options) {
         return (0, index_8.Exclude)(unionType, excludedMembers, options);
     }
     /** `[Json]` Creates a Conditional type */
-    Extends(L, R, T, F, options = {}) {
+    Extends(L, R, T, F, options) {
         return (0, index_9.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 = {}) {
+    Extract(type, union, options) {
         return (0, index_10.Extract)(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options = {}) {
+    Index(schema, unresolved, options) {
         return (0, index_11.Index)(schema, unresolved, options);
     }
     /** `[Json]` Creates an Integer type */
-    Integer(options = {}) {
+    Integer(options) {
         return (0, index_12.Integer)(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options = {}) {
+    Intersect(T, options) {
         return (0, index_13.Intersect)(T, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options = {}) {
+    KeyOf(schema, options) {
         return (0, index_15.KeyOf)(schema, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options = {}) {
+    Literal(value, options) {
         return (0, index_16.Literal)(value, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options = {}) {
+    Lowercase(schema, options) {
         return (0, index_14.Lowercase)(schema, options);
     }
     /** `[Json]` Creates a Mapped object type */
-    Mapped(key, map, options = {}) {
+    Mapped(key, map, options) {
         return (0, index_17.Mapped)(key, map, options);
     }
     /** `[Json]` Creates a Never type */
-    Never(options = {}) {
+    Never(options) {
         return (0, index_18.Never)(options);
     }
     /** `[Json]` Creates a Not type */
@@ -151,43 +151,43 @@ class JsonTypeBuilder {
         return (0, index_19.Not)(schema, options);
     }
     /** `[Json]` Creates a Null type */
-    Null(options = {}) {
+    Null(options) {
         return (0, index_20.Null)(options);
     }
     /** `[Json]` Creates a Number type */
-    Number(options = {}) {
+    Number(options) {
         return (0, index_21.Number)(options);
     }
     /** `[Json]` Creates an Object type */
-    Object(properties, options = {}) {
+    Object(properties, options) {
         return (0, index_22.Object)(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options = {}) {
+    Omit(schema, unresolved, options) {
         return (0, index_23.Omit)(schema, unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options = {}) {
+    Partial(schema, options) {
         return (0, index_25.Partial)(schema, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options = {}) {
+    Pick(schema, unresolved, options) {
         return (0, index_26.Pick)(schema, unresolved, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options = {}) {
+    Record(key, schema, options) {
         return (0, index_29.Record)(key, schema, options);
     }
     /** `[Json]` Creates a Recursive type */
-    Recursive(callback, options = {}) {
+    Recursive(callback, options) {
         return (0, index_30.Recursive)(callback, options);
     }
     /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options = {}) {
+    Ref(unresolved, options) {
         return (0, index_31.Ref)(unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options = {}) {
+    Required(schema, options) {
         return (0, index_32.Required)(schema, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
@@ -195,11 +195,11 @@ class JsonTypeBuilder {
         return (0, index_33.Rest)(schema);
     }
     /** `[Json]` Creates a String type */
-    String(options = {}) {
+    String(options) {
         return (0, index_35.String)(options);
     }
     /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral(unresolved, options = {}) {
+    TemplateLiteral(unresolved, options) {
         return (0, index_36.TemplateLiteral)(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
@@ -207,27 +207,27 @@ class JsonTypeBuilder {
         return (0, index_37.Transform)(schema);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options = {}) {
+    Tuple(items, options) {
         return (0, index_38.Tuple)(items, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options = {}) {
+    Uncapitalize(schema, options) {
         return (0, index_14.Uncapitalize)(schema, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options = {}) {
+    Union(schemas, options) {
         return (0, index_39.Union)(schemas, options);
     }
     /** `[Json]` Creates an Unknown type */
-    Unknown(options = {}) {
+    Unknown(options) {
         return (0, index_40.Unknown)(options);
     }
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe(options = {}) {
+    Unsafe(options) {
         return (0, index_41.Unsafe)(options);
     }
     /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase(schema, options = {}) {
+    Uppercase(schema, options) {
         return (0, index_14.Uppercase)(schema, options);
     }
 }

package/build/cjs/type/uint8array/uint8array.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uint8Array = Uint8Array;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Uint8Array type */
-function Uint8Array(options = {}) {
-    return { ...options, [index_1.Kind]: 'Uint8Array', type: 'Uint8Array' };
+function Uint8Array(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Uint8Array', type: 'Uint8Array' }, options);
 }

package/build/cjs/type/undefined/undefined.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Undefined = Undefined;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Undefined type */
-function Undefined(options = {}) {
-    return { ...options, [index_1.Kind]: 'Undefined', type: 'undefined' };
+function Undefined(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Undefined', type: 'undefined' }, options);
 }