@sinclair/typebox 0.33.7 → 0.33.9

package/build/cjs/compiler/compiler.d.ts

@@ -1,7 +1,7 @@
 import { ValueErrorIterator } from '../errors/index';
 import { TypeBoxError } from '../type/error/index';
 import type { TSchema } from '../type/schema/index';
-import type { Static, StaticDecode, StaticEncode } from '../type/static/index';
+import type { Static, StaticDecode } from '../type/static/index';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends TSchema> {
     private readonly schema;
@@ -17,9 +17,9 @@ export declare class TypeCheck<T extends TSchema> {
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Static<T>;
     /** Decodes a value or throws if error */
-    Decode<R = StaticDecode<T>>(value: unknown): R;
+    Decode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
     /** Encodes a value or throws if error */
-    Encode<R = StaticEncode<T>>(value: unknown): R;
+    Encode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
 }
 export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/cjs/errors/errors.js

@@ -251,13 +251,16 @@ function* FromInteger(schema, references, path, value) {
     }
 }
 function* FromIntersect(schema, references, path, value) {
+    let hasError = false;
     for (const inner of schema.allOf) {
-        const next = Visit(inner, references, path, value).next();
-        if (!next.done) {
-            yield Create(ValueErrorType.Intersect, schema, path, value);
-            yield next.value;
+        for (const error of Visit(inner, references, path, value)) {
+            hasError = true;
+            yield error;
         }
     }
+    if (hasError) {
+        return yield Create(ValueErrorType.Intersect, schema, path, value);
+    }
     if (schema.unevaluatedProperties === false) {
         const keyCheck = new RegExp((0, index_2.KeyOfPattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {

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

@@ -1,5 +1,5 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import type { TupleToUnion, Evaluate } from '../helpers/index';
+import type { SchemaOptions, TSchema } from '../schema/index';
+import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index';
 import { type TRecursive } from '../recursive/index';
 import type { TMappedKey, TMappedResult } from '../mapped/index';
 import { type TIntersect } from '../intersect/index';
@@ -11,7 +11,8 @@ import { type TOmitFromMappedResult } from './omit-from-mapped-result';
 type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmit<L, K>]> : Acc);
 type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmit<L, K>]> : Acc);
 type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
-export type TOmit<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : TObject<{}>;
+type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
+export type TOmit<T extends TProperties, K extends PropertyKey[]> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>);
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function 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 */

package/build/cjs/type/omit/omit.js

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Omit = Omit;
 const type_1 = require("../create/type");
+const discard_1 = require("../discard/discard");
 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 omit_from_mapped_key_1 = require("./omit-from-mapped-key");
 const omit_from_mapped_result_1 = require("./omit-from-mapped-result");
+const symbols_1 = require("../symbols/symbols");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -35,6 +35,12 @@ function FromProperty(T, K) {
 function FromProperties(T, K) {
     return K.reduce((T, K2) => FromProperty(T, K2), T);
 }
+// prettier-ignore
+function FromObject(T, K) {
+    const options = (0, discard_1.Discard)(T, [symbols_1.TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties'], K);
+    return (0, index_3.Object)(properties, options);
+}
 // ------------------------------------------------------------------
 // OmitResolve
 // ------------------------------------------------------------------
@@ -42,7 +48,7 @@ function FromProperties(T, K) {
 function OmitResolve(T, K) {
     return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
         (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
-            (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K), (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required'])) :
+            (0, kind_1.IsObject)(T) ? FromObject(T, K) :
                 (0, index_3.Object)({}));
 }
 function Omit(T, K, options) {
@@ -53,5 +59,6 @@ function Omit(T, K, options) {
         return (0, omit_from_mapped_result_1.OmitFromMappedResult)(T, K, options);
     // non-mapped
     const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
-    return (0, type_1.CreateType)(OmitResolve(T, I), options);
+    // special: mapping types require overridable options
+    return (0, type_1.CreateType)({ ...OmitResolve(T, I), ...options });
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Evaluate } from '../helpers/index';
+import type { Evaluate, Ensure } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TOptional } from '../optional/index';
@@ -13,7 +13,8 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [in
 type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
 }>;
-export type TPartial<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
+type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+export type TPartial<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are optional */

package/build/cjs/type/partial/partial.js

@@ -25,6 +25,12 @@ function FromProperties(T) {
         Acc[K] = (0, index_1.Optional)(T[K]);
     return Acc;
 }
+// prettier-ignore
+function FromObject(T) {
+    const options = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties']);
+    return (0, index_2.Object)(properties, options);
+}
 // ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
@@ -32,14 +38,16 @@ function FromProperties(T) {
 function PartialResolve(T) {
     return ((0, kind_1.IsIntersect)(T) ? (0, index_3.Intersect)(FromRest(T.allOf)) :
         (0, kind_1.IsUnion)(T) ? (0, index_4.Union)(FromRest(T.anyOf)) :
-            (0, kind_1.IsObject)(T) ? (0, index_2.Object)(FromProperties(T.properties)) :
+            (0, kind_1.IsObject)(T) ? FromObject(T) :
                 (0, index_2.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 function Partial(T, options) {
-    if ((0, kind_1.IsMappedResult)(T))
+    if ((0, kind_1.IsMappedResult)(T)) {
         return (0, partial_from_mapped_result_1.PartialFromMappedResult)(T, options);
-    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-    const R = PartialResolve(T);
-    return (0, type_1.CreateType)({ ...options, ...D, ...R });
+    }
+    else {
+        // special: mapping types require overridable options
+        return (0, type_1.CreateType)({ ...PartialResolve(T), ...options });
+    }
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { TupleToUnion, Evaluate } from '../helpers/index';
+import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index';
 import { type TRecursive } from '../recursive/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
@@ -12,9 +12,9 @@ type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSc
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
 declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
-type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
-declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): never;
-export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
+type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
+type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
+export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S extends TSchema> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */

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

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pick = Pick;
 const type_1 = require("../create/type");
+const discard_1 = require("../discard/discard");
 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 pick_from_mapped_key_1 = require("./pick-from-mapped-key");
 const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
+const symbols_1 = require("../symbols/symbols");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -30,6 +30,12 @@ function FromProperties(T, K) {
             Acc[K2] = T[K2];
     return Acc;
 }
+// prettier-ignore
+function FromObject(T, K) {
+    const options = (0, discard_1.Discard)(T, [symbols_1.TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties'], K);
+    return (0, index_3.Object)(properties, options);
+}
 // ------------------------------------------------------------------
 // PickResolve
 // ------------------------------------------------------------------
@@ -37,7 +43,7 @@ function FromProperties(T, K) {
 function PickResolve(T, K) {
     return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
         (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
-            (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K), (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required'])) :
+            (0, kind_1.IsObject)(T) ? FromObject(T, K) :
                 (0, index_3.Object)({}));
 }
 function Pick(T, K, options) {
@@ -48,5 +54,6 @@ function Pick(T, K, options) {
         return (0, pick_from_mapped_result_1.PickFromMappedResult)(T, K, options);
     // non-mapped
     const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
-    return (0, type_1.CreateType)(PickResolve(T, I), options);
+    // special: mapping types require overridable options
+    return (0, type_1.CreateType)({ ...PickResolve(T, I), ...options });
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Evaluate } from '../helpers/index';
+import type { Evaluate, Ensure } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TOptional } from '../optional/index';
@@ -13,7 +13,8 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [in
 type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
-export type TRequired<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
+type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+export type TRequired<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are required */

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

@@ -24,6 +24,12 @@ function FromProperties(T) {
         Acc[K] = (0, index_5.Discard)(T[K], [index_4.OptionalKind]);
     return Acc;
 }
+// prettier-ignore
+function FromObject(T) {
+    const options = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties']);
+    return (0, index_3.Object)(properties, options);
+}
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
@@ -31,7 +37,7 @@ function FromProperties(T) {
 function RequiredResolve(T) {
     return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromRest(T.allOf)) :
         (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromRest(T.anyOf)) :
-            (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
+            (0, kind_1.IsObject)(T) ? FromObject(T) :
                 (0, index_3.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
@@ -40,8 +46,7 @@ function Required(T, options) {
         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 = RequiredResolve(T);
-        return (0, type_1.CreateType)({ ...D, ...R }, options);
+        // special: mapping types require overridable options
+        return (0, type_1.CreateType)({ ...RequiredResolve(T), ...options });
     }
 }

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

@@ -1,3 +1,12 @@
 import type { TSchema } from '../schema/index';
-/** `[Json]` Omits compositing symbols from this schema. */
-export declare function Strict<T extends TSchema>(schema: T): T;
+export type TStrict<T extends TSchema> = T;
+/**
+ * @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()))
+ * ```
+ */
+export declare function Strict<T extends TSchema>(schema: T): TStrict<T>;

package/build/cjs/type/strict/strict.js

@@ -2,7 +2,15 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strict = Strict;
-/** `[Json]` Omits compositing symbols from this schema. */
+/**
+ * @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()))
+ * ```
+ */
 function Strict(schema) {
     return JSON.parse(JSON.stringify(schema));
 }

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

@@ -33,6 +33,7 @@ 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';
@@ -42,8 +43,16 @@ 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 {
-    /** `[Json]` Omits compositing symbols from this schema */
-    Strict<T extends TSchema>(schema: T): T;
+    /**
+     * @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>;
     /** `[Json]` Creates a Readonly property */
@@ -133,19 +142,19 @@ export declare class JsonTypeBuilder {
     /** `[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): TOmitFromMappedKey<T, K>;
+    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?: ObjectOptions): TPartialFromMappedResult<T>;
+    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?: ObjectOptions): TPartial<T>;
+    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]): TPickFromMappedResult<T, K>;
+    Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
     /** `[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>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
@@ -159,9 +168,9 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a Ref type. */
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>;
+    Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>;
+    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
     Rest<T extends TSchema>(schema: T): TRest<T>;
     /** `[Json]` Creates a String type */

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

@@ -48,7 +48,15 @@ class JsonTypeBuilder {
     // ------------------------------------------------------------------------
     // Strict
     // ------------------------------------------------------------------------
-    /** `[Json]` Omits compositing symbols from this schema */
+    /**
+     * @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);
     }

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

@@ -44,8 +44,8 @@ export { RegExp } from '../regexp/index';
 export { Required } from '../required/index';
 export { Rest } from '../rest/index';
 export { ReturnType } from '../return-type/index';
-export { Strict } from '../strict/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';

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

@@ -1,8 +1,8 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Mapped = exports.Literal = exports.KeyOf = exports.Iterator = exports.Uppercase = exports.Lowercase = exports.Uncapitalize = exports.Capitalize = exports.Intersect = exports.Integer = exports.InstanceType = exports.Index = exports.Function = exports.Extract = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = void 0;
-exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.Transform = exports.TemplateLiteral = exports.Symbol = exports.String = void 0;
+exports.String = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Mapped = exports.Literal = exports.KeyOf = exports.Iterator = exports.Uppercase = exports.Lowercase = exports.Uncapitalize = exports.Capitalize = exports.Intersect = exports.Integer = exports.InstanceType = exports.Index = exports.Function = exports.Extract = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = void 0;
+exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.Transform = exports.TemplateLiteral = exports.Symbol = exports.Strict = void 0;
 // ------------------------------------------------------------------
 // Type: Module
 // ------------------------------------------------------------------
@@ -101,10 +101,10 @@ var index_45 = require("../rest/index");
 Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_45.Rest; } });
 var index_46 = require("../return-type/index");
 Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_46.ReturnType; } });
-var index_47 = require("../strict/index");
-Object.defineProperty(exports, "Strict", { enumerable: true, get: function () { return index_47.Strict; } });
-var index_48 = require("../string/index");
-Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_48.String; } });
+var index_47 = require("../string/index");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_47.String; } });
+var index_48 = require("../strict/index");
+Object.defineProperty(exports, "Strict", { enumerable: true, get: function () { return index_48.Strict; } });
 var index_49 = require("../symbol/index");
 Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_49.Symbol; } });
 var index_50 = require("../template-literal/index");

package/build/cjs/value/create/create.js

@@ -12,6 +12,7 @@ const index_6 = require("../../type/patterns/index");
 const index_7 = require("../../type/registry/index");
 const index_8 = require("../../type/symbols/index");
 const index_9 = require("../../type/error/index");
+const guard_1 = require("../guard/guard");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -26,7 +27,7 @@ exports.ValueCreateError = ValueCreateError;
 // Default
 // ------------------------------------------------------------------
 function FromDefault(value) {
-    return typeof value === 'function' ? value : (0, index_3.Clone)(value);
+    return (0, guard_1.IsFunction)(value) ? value() : (0, index_3.Clone)(value);
 }
 // ------------------------------------------------------------------
 // Create

package/build/cjs/value/default/default.js

@@ -18,7 +18,8 @@ const kind_1 = require("../../type/guard/kind");
 // ValueOrDefault
 // ------------------------------------------------------------------
 function ValueOrDefault(schema, value) {
-    const clone = (0, index_5.HasPropertyKey)(schema, 'default') ? (0, index_2.Clone)(schema.default) : undefined;
+    const defaultValue = (0, index_5.HasPropertyKey)(schema, 'default') ? schema.default : undefined;
+    const clone = (0, index_5.IsFunction)(defaultValue) ? defaultValue() : (0, index_2.Clone)(defaultValue);
     return (0, index_5.IsUndefined)(value) ? clone : (0, index_5.IsObject)(value) && (0, index_5.IsObject)(clone) ? Object.assign(clone, value) : value;
 }
 // ------------------------------------------------------------------

package/build/cjs/value/transform/encode.js

@@ -73,7 +73,7 @@ function FromIntersect(schema, references, path, value) {
             knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
-        return Default(schema, path, knownProperties);
+        return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;

package/build/cjs/value/value/value.d.ts

@@ -30,17 +30,17 @@ export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
 /** Decodes a value or throws if error */
-export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+export declare function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
 /** Decodes a value or throws if error */
-export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default(schema: TSchema, value: unknown): unknown;
 /** Encodes a value or throws if error */
-export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
 /** Encodes a value or throws if error */
-export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;
 /** Parses a value or throws an `AssertError` if invalid. */
 export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Parses a value or throws an `AssertError` if invalid. */

package/build/esm/compiler/compiler.d.mts

@@ -1,7 +1,7 @@
 import { ValueErrorIterator } from '../errors/index.mjs';
 import { TypeBoxError } from '../type/error/index.mjs';
 import type { TSchema } from '../type/schema/index.mjs';
-import type { Static, StaticDecode, StaticEncode } from '../type/static/index.mjs';
+import type { Static, StaticDecode } from '../type/static/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends TSchema> {
     private readonly schema;
@@ -17,9 +17,9 @@ export declare class TypeCheck<T extends TSchema> {
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Static<T>;
     /** Decodes a value or throws if error */
-    Decode<R = StaticDecode<T>>(value: unknown): R;
+    Decode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
     /** Encodes a value or throws if error */
-    Encode<R = StaticEncode<T>>(value: unknown): R;
+    Encode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
 }
 export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/esm/errors/errors.mjs

@@ -244,13 +244,16 @@ function* FromInteger(schema, references, path, value) {
     }
 }
 function* FromIntersect(schema, references, path, value) {
+    let hasError = false;
     for (const inner of schema.allOf) {
-        const next = Visit(inner, references, path, value).next();
-        if (!next.done) {
-            yield Create(ValueErrorType.Intersect, schema, path, value);
-            yield next.value;
+        for (const error of Visit(inner, references, path, value)) {
+            hasError = true;
+            yield error;
         }
     }
+    if (hasError) {
+        return yield Create(ValueErrorType.Intersect, schema, path, value);
+    }
     if (schema.unevaluatedProperties === false) {
         const keyCheck = new RegExp(KeyOfPattern(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {

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

@@ -1,5 +1,5 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { TupleToUnion, Evaluate } from '../helpers/index.mjs';
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
 import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
@@ -11,7 +11,8 @@ import { type TOmitFromMappedResult } from './omit-from-mapped-result.mjs';
 type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmit<L, K>]> : Acc);
 type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmit<L, K>]> : Acc);
 type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
-export type TOmit<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : TObject<{}>;
+type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
+export type TOmit<T extends TProperties, K extends PropertyKey[]> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>);
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function 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 */

package/build/esm/type/omit/omit.mjs

@@ -1,12 +1,12 @@
 import { CreateType } from '../create/type.mjs';
+import { Discard } from '../discard/discard.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
-import { Discard } from '../discard/index.mjs';
-import { TransformKind } from '../symbols/index.mjs';
 import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
 import { OmitFromMappedResult } from './omit-from-mapped-result.mjs';
+import { TransformKind } from '../symbols/symbols.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -31,6 +31,12 @@ function FromProperty(T, K) {
 function FromProperties(T, K) {
     return K.reduce((T, K2) => FromProperty(T, K2), T);
 }
+// prettier-ignore
+function FromObject(T, K) {
+    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties'], K);
+    return Object(properties, options);
+}
 // ------------------------------------------------------------------
 // OmitResolve
 // ------------------------------------------------------------------
@@ -38,7 +44,7 @@ function FromProperties(T, K) {
 function OmitResolve(T, K) {
     return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
         IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
-            IsObject(T) ? Object(FromProperties(T.properties, K), Discard(T, [TransformKind, '$id', 'required'])) :
+            IsObject(T) ? FromObject(T, K) :
                 Object({}));
 }
 export function Omit(T, K, options) {
@@ -49,5 +55,6 @@ export function Omit(T, K, options) {
         return OmitFromMappedResult(T, K, options);
     // non-mapped
     const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-    return CreateType(OmitResolve(T, I), options);
+    // special: mapping types require overridable options
+    return CreateType({ ...OmitResolve(T, I), ...options });
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Evaluate } from '../helpers/index.mjs';
+import type { Evaluate, Ensure } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
@@ -13,7 +13,8 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [in
 type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
 }>;
-export type TPartial<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
+type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+export type TPartial<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are optional */

package/build/esm/type/partial/partial.mjs

@@ -21,6 +21,12 @@ function FromProperties(T) {
         Acc[K] = Optional(T[K]);
     return Acc;
 }
+// prettier-ignore
+function FromObject(T) {
+    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties']);
+    return Object(properties, options);
+}
 // ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
@@ -28,14 +34,16 @@ function FromProperties(T) {
 function PartialResolve(T) {
     return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
         IsUnion(T) ? Union(FromRest(T.anyOf)) :
-            IsObject(T) ? Object(FromProperties(T.properties)) :
+            IsObject(T) ? FromObject(T) :
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial(T, options) {
-    if (IsMappedResult(T))
+    if (IsMappedResult(T)) {
         return PartialFromMappedResult(T, options);
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = PartialResolve(T);
-    return CreateType({ ...options, ...D, ...R });
+    }
+    else {
+        // special: mapping types require overridable options
+        return CreateType({ ...PartialResolve(T), ...options });
+    }
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { TupleToUnion, Evaluate } from '../helpers/index.mjs';
+import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
@@ -12,9 +12,9 @@ type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSc
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
 declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
-type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
-declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): never;
-export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
+type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
+type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
+export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S extends TSchema> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */

package/build/esm/type/pick/pick.mjs

@@ -1,12 +1,12 @@
 import { CreateType } from '../create/type.mjs';
+import { Discard } from '../discard/discard.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
-import { Discard } from '../discard/index.mjs';
-import { TransformKind } from '../symbols/index.mjs';
 import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
 import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
+import { TransformKind } from '../symbols/symbols.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -26,6 +26,12 @@ function FromProperties(T, K) {
             Acc[K2] = T[K2];
     return Acc;
 }
+// prettier-ignore
+function FromObject(T, K) {
+    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties'], K);
+    return Object(properties, options);
+}
 // ------------------------------------------------------------------
 // PickResolve
 // ------------------------------------------------------------------
@@ -33,7 +39,7 @@ function FromProperties(T, K) {
 function PickResolve(T, K) {
     return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
         IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
-            IsObject(T) ? Object(FromProperties(T.properties, K), Discard(T, [TransformKind, '$id', 'required'])) :
+            IsObject(T) ? FromObject(T, K) :
                 Object({}));
 }
 export function Pick(T, K, options) {
@@ -44,5 +50,6 @@ export function Pick(T, K, options) {
         return PickFromMappedResult(T, K, options);
     // non-mapped
     const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-    return CreateType(PickResolve(T, I), options);
+    // special: mapping types require overridable options
+    return CreateType({ ...PickResolve(T, I), ...options });
 }

package/build/esm/type/required/required.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Evaluate } from '../helpers/index.mjs';
+import type { Evaluate, Ensure } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
@@ -13,7 +13,8 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [in
 type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
-export type TRequired<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
+type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+export type TRequired<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are required */

package/build/esm/type/required/required.mjs

@@ -20,6 +20,12 @@ function FromProperties(T) {
         Acc[K] = Discard(T[K], [OptionalKind]);
     return Acc;
 }
+// prettier-ignore
+function FromObject(T) {
+    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(T['properties']);
+    return Object(properties, options);
+}
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
@@ -27,7 +33,7 @@ function FromProperties(T) {
 function RequiredResolve(T) {
     return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
         IsUnion(T) ? Union(FromRest(T.anyOf)) :
-            IsObject(T) ? Object(FromProperties(T.properties)) :
+            IsObject(T) ? FromObject(T) :
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
@@ -36,8 +42,7 @@ export function Required(T, options) {
         return RequiredFromMappedResult(T, options);
     }
     else {
-        const D = Discard(T, [TransformKind, '$id', 'required']);
-        const R = RequiredResolve(T);
-        return CreateType({ ...D, ...R }, options);
+        // special: mapping types require overridable options
+        return CreateType({ ...RequiredResolve(T), ...options });
     }
 }

package/build/esm/type/strict/strict.d.mts

@@ -1,3 +1,12 @@
 import type { TSchema } from '../schema/index.mjs';
-/** `[Json]` Omits compositing symbols from this schema. */
-export declare function Strict<T extends TSchema>(schema: T): T;
+export type TStrict<T extends TSchema> = T;
+/**
+ * @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()))
+ * ```
+ */
+export declare function Strict<T extends TSchema>(schema: T): TStrict<T>;

package/build/esm/type/strict/strict.mjs

@@ -1,4 +1,12 @@
-/** `[Json]` Omits compositing symbols from this schema. */
+/**
+ * @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()))
+ * ```
+ */
 export function Strict(schema) {
     return JSON.parse(JSON.stringify(schema));
 }

package/build/esm/type/type/json.d.mts

@@ -33,6 +33,7 @@ import { type TRef } from '../ref/index.mjs';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
+import { type TStrict } from '../strict/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index.mjs';
 import { TransformDecodeBuilder } from '../transform/index.mjs';
@@ -42,8 +43,16 @@ import { type TUnknown } from '../unknown/index.mjs';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
 /** Json Type Builder with Static Resolution for TypeScript */
 export declare class JsonTypeBuilder {
-    /** `[Json]` Omits compositing symbols from this schema */
-    Strict<T extends TSchema>(schema: T): T;
+    /**
+     * @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>;
     /** `[Json]` Creates a Readonly property */
@@ -133,19 +142,19 @@ export declare class JsonTypeBuilder {
     /** `[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): TOmitFromMappedKey<T, K>;
+    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?: ObjectOptions): TPartialFromMappedResult<T>;
+    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?: ObjectOptions): TPartial<T>;
+    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]): TPickFromMappedResult<T, K>;
+    Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
     /** `[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>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
@@ -159,9 +168,9 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a Ref type. */
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>;
+    Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>;
+    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
     Rest<T extends TSchema>(schema: T): TRest<T>;
     /** `[Json]` Creates a String type */

package/build/esm/type/type/json.mjs

@@ -44,7 +44,15 @@ export class JsonTypeBuilder {
     // ------------------------------------------------------------------------
     // Strict
     // ------------------------------------------------------------------------
-    /** `[Json]` Omits compositing symbols from this schema */
+    /**
+     * @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 Strict(schema);
     }

package/build/esm/type/type/type.d.mts

@@ -44,8 +44,8 @@ export { RegExp } from '../regexp/index.mjs';
 export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';
-export { Strict } from '../strict/index.mjs';
 export { String } from '../string/index.mjs';
+export { Strict } from '../strict/index.mjs';
 export { Symbol } from '../symbol/index.mjs';
 export { TemplateLiteral } from '../template-literal/index.mjs';
 export { Transform } from '../transform/index.mjs';

package/build/esm/type/type/type.mjs

@@ -47,8 +47,8 @@ export { RegExp } from '../regexp/index.mjs';
 export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';
-export { Strict } from '../strict/index.mjs';
 export { String } from '../string/index.mjs';
+export { Strict } from '../strict/index.mjs';
 export { Symbol } from '../symbol/index.mjs';
 export { TemplateLiteral } from '../template-literal/index.mjs';
 export { Transform } from '../transform/index.mjs';

package/build/esm/value/create/create.mjs

@@ -7,6 +7,7 @@ import { PatternStringExact, PatternNumberExact } from '../../type/patterns/inde
 import { TypeRegistry } from '../../type/registry/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
+import { IsFunction } from '../guard/guard.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -20,7 +21,7 @@ export class ValueCreateError extends TypeBoxError {
 // Default
 // ------------------------------------------------------------------
 function FromDefault(value) {
-    return typeof value === 'function' ? value : Clone(value);
+    return IsFunction(value) ? value() : Clone(value);
 }
 // ------------------------------------------------------------------
 // Create

package/build/esm/value/default/default.mjs

@@ -5,7 +5,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsString, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index.mjs';
+import { IsString, IsFunction, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -14,7 +14,8 @@ import { IsKind } from '../../type/guard/kind.mjs';
 // ValueOrDefault
 // ------------------------------------------------------------------
 function ValueOrDefault(schema, value) {
-    const clone = HasPropertyKey(schema, 'default') ? Clone(schema.default) : undefined;
+    const defaultValue = HasPropertyKey(schema, 'default') ? schema.default : undefined;
+    const clone = IsFunction(defaultValue) ? defaultValue() : Clone(defaultValue);
     return IsUndefined(value) ? clone : IsObject(value) && IsObject(clone) ? Object.assign(clone, value) : value;
 }
 // ------------------------------------------------------------------

package/build/esm/value/transform/encode.mjs

@@ -66,7 +66,7 @@ function FromIntersect(schema, references, path, value) {
             knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
     if (!IsTransform(schema.unevaluatedProperties)) {
-        return Default(schema, path, knownProperties);
+        return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;

package/build/esm/value/value/value.d.mts

@@ -30,17 +30,17 @@ export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
 /** Decodes a value or throws if error */
-export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+export declare function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
 /** Decodes a value or throws if error */
-export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default(schema: TSchema, value: unknown): unknown;
 /** Encodes a value or throws if error */
-export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
 /** Encodes a value or throws if error */
-export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;
 /** Parses a value or throws an `AssertError` if invalid. */
 export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Parses a value or throws an `AssertError` if invalid. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.7",
+  "version": "0.33.9",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -77,7 +77,6 @@ License MIT
   - [Transform](#types-transform)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
-  - [Strict](#types-strict)
 - [Values](#values)
   - [Assert](#values-assert)
   - [Create](#values-create)
@@ -1078,35 +1077,6 @@ if(TypeGuard.IsString(T)) {
 }
 ```
 
-<a name='types-strict'></a>
-
-### Strict
-
-TypeBox types contain various symbol properties that are used for reflection, composition and compilation. These properties are not strictly valid Json Schema; so in some cases it may be desirable to omit them. TypeBox provides a `Strict` function that will omit these properties if necessary.
-
-```typescript
-const T = Type.Object({                              // const T = {
-  name: Type.Optional(Type.String())                 //   [Symbol(TypeBox.Kind)]: 'Object',
-})                                                   //   type: 'object',
-                                                     //   properties: {
-                                                     //     name: {
-                                                     //       type: 'string',
-                                                     //       [Symbol(TypeBox.Kind)]: 'String',
-                                                     //       [Symbol(TypeBox.Optional)]: 'Optional'
-                                                     //     }
-                                                     //   }
-                                                     // }
-
-const U = Type.Strict(T)                             // const U = {
-                                                     //   type: 'object',
-                                                     //   properties: {
-                                                     //     name: {
-                                                     //       type: 'string'
-                                                     //     }
-                                                     //   }
-                                                     // }
-```
-
 <a name='values'></a>
 
 ## Values