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

package/build/import/type/union/union-evaluated.d.mts

@@ -0,0 +1,16 @@
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TUnion } from './union-type.mjs';
+type IsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : IsUnionOptional<R> : false);
+declare function IsUnionOptional<T extends TSchema[]>(T: T): IsUnionOptional<T>;
+type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
+declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
+type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
+declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
+type ResolveUnion<T extends TSchema[], R extends TSchema[] = RemoveOptionalFromRest<T>> = (IsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
+declare function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): ResolveUnion<T>;
+export type UnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveUnion<T>);
+export declare function UnionEvaluated<T extends TSchema[], R = UnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export {};

package/build/import/type/union/union-evaluated.mjs

@@ -0,0 +1,31 @@
+import { OptionalKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { UnionCreate } from './union-create.mjs';
+import { TOptional as IsOptionalType } from '../guard/type.mjs';
+function IsUnionOptional(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptionalType(L)
+            ? true
+            : IsUnionOptional(R)
+        : false);
+}
+function RemoveOptionalFromRest(T) {
+    return (T.map(T => RemoveOptionalFromType(T)));
+}
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+function ResolveUnion(T, options) {
+    return (IsUnionOptional(T)
+        ? Optional(UnionCreate(RemoveOptionalFromRest(T), options))
+        : UnionCreate(RemoveOptionalFromRest(T), options));
+}
+export function UnionEvaluated(T, options = {}) {
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            ResolveUnion(T, options));
+}

package/build/import/type/union/union-type.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: UnionStatic<T, this['params']>;
+    anyOf: T;
+}
+export {};

package/build/import/type/union/union-type.mjs

@@ -0,0 +1 @@
+import { Kind } from '../symbols/index.mjs';

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

@@ -1,15 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { OptionalFromUnion } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-export type UnionResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromUnion<T>);
-export declare function UnionResolve<T extends TSchema[]>(T: [...T]): UnionResolve<T>;
-export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
-    [Kind]: 'Union';
-    static: {
-        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never;
-    }[number];
-    anyOf: T;
-}
-export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): UnionResolve<T>;
+import type { TUnion } from './union-type.mjs';
+export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
+export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T>;

package/build/import/type/union/union.mjs

@@ -1,15 +1,8 @@
 import { Never } from '../never/index.mjs';
-import { OptionalFromUnion } from '../modifiers/index.mjs';
-import { CloneType, CloneRest } from '../clone/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-export function UnionResolve(T) {
-    return (T.length === 0 ? Never() :
-        T.length === 1 ? T[0] :
-            OptionalFromUnion(T));
-}
+import { CloneType } from '../clone/type.mjs';
+import { UnionCreate } from './union-create.mjs';
 export function Union(T, options = {}) {
     return (T.length === 0 ? Never(options) :
         T.length === 1 ? CloneType(T[0], options) :
-            { ...options, [Kind]: 'Union', anyOf: CloneRest(T)
-            });
+            UnionCreate(T, options));
 }

package/build/import/value/delta/delta.d.mts

@@ -17,7 +17,7 @@ export declare const Delete: import("../../type/object/object.mjs").TObject<{
     path: import("../../type/string/string.mjs").TString;
 }>;
 export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union.mjs").TUnion<[import("../../type/object/object.mjs").TObject<{
+export declare const Edit: import("../../type/union/union-type.mjs").TUnion<[import("../../type/object/object.mjs").TObject<{
     type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
     path: import("../../type/string/string.mjs").TString;
     value: import("../../type/unknown/unknown.mjs").TUnknown;

package/build/require/index.d.ts

@@ -16,18 +16,18 @@ export { ConstructorParameters, type TConstructorParameters } from './type/const
 export { Date, type TDate, type DateOptions } from './type/date/index';
 export { Deref, type TDeref } from './type/deref/index';
 export { Enum, type TEnum } from './type/enum/index';
-export { Exclude, type TExclude } from './type/exclude/index';
-export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
-export { Extract, type TExtract } from './type/extract/index';
+export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index';
+export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
+export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
-export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from './type/indexed/index';
+export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
-export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index';
+export { Intersect, IntersectEvaluated, type TIntersect, type IntersectOptions } from './type/intersect/index';
 export { Iterator, type TIterator } from './type/iterator/index';
-export { Intrinsic, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
-export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
+export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
+export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
 export { Literal, type TLiteral } from './type/literal/index';
 export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index';
 export { Never, type TNever } from './type/never/index';
@@ -35,11 +35,11 @@ export { Not, type TNot } from './type/not/index';
 export { Null, type TNull } from './type/null/index';
 export { Number, type TNumber, type NumberOptions } from './type/number/index';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
-export { Omit, type TOmit, type TOmitMappedResult } from './type/omit/index';
+export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index';
 export { Optional, type TOptional } from './type/optional/index';
 export { Parameters, type TParameters } from './type/parameters/index';
-export { Partial, type TPartial } from './type/partial/index';
-export { Pick, type TPick, type TPickMappedResult } from './type/pick/index';
+export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index';
+export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index';
 export { Promise, type TPromise } from './type/promise/index';
 export { Readonly, type TReadonly } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
@@ -47,7 +47,7 @@ export { Record, type TRecord } from './type/record/index';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
 export { Ref, type TRef } from './type/ref/index';
 export { RegExp, type TRegExp } from './type/regexp/index';
-export { Required, type TRequired } from './type/required/index';
+export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index';
 export { Rest, type TRest } from './type/rest/index';
 export { ReturnType, type TReturnType } from './type/return-type/index';
 export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index';
@@ -60,7 +60,7 @@ export { Transform, type TTransform, type TransformOptions, type TransformFuncti
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
 export { Undefined, type TUndefined } from './type/undefined/index';
-export { Union, type TUnion } from './type/union/index';
+export { Union, UnionEvaluated, type TUnion } from './type/union/index';
 export { Unknown, type TUnknown } from './type/unknown/index';
 export { Unsafe, type TUnsafe } from './type/unsafe/index';
 export { Void, type TVoid } from './type/void/index';

package/build/require/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Intrinsic = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexMappedResult = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = 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 = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = 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.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = void 0;
+exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = 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 = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
+exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = 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.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
 var index_1 = require("./type/symbols/index");
 Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return index_1.Kind; } });
 Object.defineProperty(exports, "Hint", { enumerable: true, get: function () { return index_1.Hint; } });
@@ -66,17 +67,19 @@ Object.defineProperty(exports, "Increment", { enumerable: true, get: function ()
 var index_23 = require("./type/indexed/index");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_23.Index; } });
 Object.defineProperty(exports, "IndexPropertyKeys", { enumerable: true, get: function () { return index_23.IndexPropertyKeys; } });
-Object.defineProperty(exports, "IndexMappedResult", { enumerable: true, get: function () { return index_23.IndexMappedResult; } });
+Object.defineProperty(exports, "IndexFromMappedKey", { enumerable: true, get: function () { return index_23.IndexFromMappedKey; } });
 var index_24 = require("./type/instance-type/index");
 Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return index_24.InstanceType; } });
 var index_25 = require("./type/integer/index");
 Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return index_25.Integer; } });
 var index_26 = require("./type/intersect/index");
 Object.defineProperty(exports, "Intersect", { enumerable: true, get: function () { return index_26.Intersect; } });
+Object.defineProperty(exports, "IntersectEvaluated", { enumerable: true, get: function () { return index_26.IntersectEvaluated; } });
 var index_27 = require("./type/iterator/index");
 Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return index_27.Iterator; } });
 var index_28 = require("./type/intrinsic/index");
 Object.defineProperty(exports, "Intrinsic", { enumerable: true, get: function () { return index_28.Intrinsic; } });
+Object.defineProperty(exports, "IntrinsicFromMappedKey", { enumerable: true, get: function () { return index_28.IntrinsicFromMappedKey; } });
 Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return index_28.Capitalize; } });
 Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return index_28.Lowercase; } });
 Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return index_28.Uncapitalize; } });
@@ -109,6 +112,7 @@ var index_39 = require("./type/parameters/index");
 Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_39.Parameters; } });
 var index_40 = require("./type/partial/index");
 Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return index_40.Partial; } });
+Object.defineProperty(exports, "PartialFromMappedResult", { enumerable: true, get: function () { return index_40.PartialFromMappedResult; } });
 var index_41 = require("./type/pick/index");
 Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return index_41.Pick; } });
 var index_42 = require("./type/promise/index");
@@ -155,6 +159,7 @@ var index_59 = require("./type/undefined/index");
 Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_59.Undefined; } });
 var index_60 = require("./type/union/index");
 Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_60.Union; } });
+Object.defineProperty(exports, "UnionEvaluated", { enumerable: true, get: function () { return index_60.UnionEvaluated; } });
 var index_61 = require("./type/unknown/index");
 Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_61.Unknown; } });
 var index_62 = require("./type/unsafe/index");

package/build/require/type/array/array.d.ts

@@ -11,7 +11,7 @@ export interface ArrayOptions extends SchemaOptions {
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
     [Kind]: 'Array';
-    static: Static<T, this['params']>[];
+    static: Array<Static<T, this['params']>>;
     type: 'array';
     items: T;
 }

package/build/require/type/constructor/constructor.d.ts

@@ -2,12 +2,12 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
-type TConstructorReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type TConstructorParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorParametersResolve<R, P>] : [];
-export type TConstructorResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorParametersResolve<T, P>) => TConstructorReturnTypeResolve<U, P>>);
+type TConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type TConstructorStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorStaticParameters<R, P>] : [];
+export type TConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorStaticParameters<T, P>) => TConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
-    static: TConstructorResolve<T, U, this['params']>;
+    static: TConstructorStatic<T, U, this['params']>;
     type: 'Constructor';
     parameters: T;
     returns: U;

package/build/require/type/exclude/exclude-from-mapped-result.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TExclude } from './exclude';
+type FromProperties<K extends TProperties, U extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], U>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
+export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/exclude/exclude-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcludeFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const exclude_1 = require("./exclude");
+function FromProperties(K, U, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, exclude_1.Exclude)(K[K2], U, options) };
+    }, {});
+}
+function FromMappedResult(K, U, options) {
+    return FromProperties(K.properties, U, options);
+}
+function ExcludeFromMappedResult(T, U, options) {
+    const P = FromMappedResult(T, U, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ExcludeFromMappedResult = ExcludeFromMappedResult;

package/build/require/type/exclude/exclude.d.ts

@@ -1,20 +1,23 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TTemplateLiteral } from '../template-literal/index';
 import { type TUnion } from '../union/index';
 import { type TNever } from '../never/index';
 import { type TLiteral } from '../literal/index';
 import { type Static } from '../static/index';
-import { UnionResolve } from '../union/index';
-type ExcludeTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
+import { UnionEvaluated } from '../union/index';
+import { type TExcludeFromMappedResult } from './exclude-from-mapped-result';
+type ExcludeTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
 type ExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? ExcludeTemplateLiteralResult<Assert<S, string>> : never);
 type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
-}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
+}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
 type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
-export declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
+declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
 export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
 export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/require/type/exclude/exclude.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Exclude = exports.ExcludeResolve = void 0;
+exports.Exclude = void 0;
 const index_1 = require("../template-literal/index");
 const index_2 = require("../union/index");
 const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
+const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
 const type_2 = require("../guard/type");
 function ExcludeResolve(L, R) {
     return ((0, type_2.TTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
@@ -17,9 +18,13 @@ function ExcludeResolve(L, R) {
                 (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() :
                     L);
 }
-exports.ExcludeResolve = ExcludeResolve;
 function Exclude(unionType, excludedMembers, options = {}) {
-    const E = ExcludeResolve(unionType, excludedMembers);
-    return (0, type_1.CloneType)(E, options);
+    if ((0, type_2.TMappedResult)(unionType)) {
+        return (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(unionType, excludedMembers, options);
+    }
+    else {
+        const E = ExcludeResolve(unionType, excludedMembers);
+        return (0, type_1.CloneType)(E, options);
+    }
 }
 exports.Exclude = Exclude;

package/build/require/type/exclude/index.d.ts

@@ -1 +1,2 @@
+export * from './exclude-from-mapped-result';
 export * from './exclude';

package/build/require/type/exclude/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./exclude-from-mapped-result"), exports);
 __exportStar(require("./exclude"), exports);

package/build/require/type/extends/extends-from-mapped-key.d.ts

@@ -0,0 +1,17 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import type { Assert } from '../helpers/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { TLiteral, TLiteralValue } from '../literal/index';
+import { type TExtends } from './extends';
+type FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
+};
+declare function FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromPropertyKey<K, U, L, R>;
+type FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<LK, U, L, R> & FromPropertyKeys<RK, U, L, R> : {});
+declare function FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R, options: SchemaOptions): FromPropertyKeys<K, U, L, R>;
+type FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (FromPropertyKeys<K['keys'], U, L, R>);
+declare function FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedKey<K, U, L, R>;
+export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/extends/extends-from-mapped-key.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsFromMappedKey = void 0;
+const index_1 = require("../mapped/index");
+const index_2 = require("../literal/index");
+const extends_1 = require("./extends");
+function FromPropertyKey(K, U, L, R, options) {
+    return {
+        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R, options)
+    };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...FromPropertyKey(LK, U, L, R, options), ...FromPropertyKeys(RK, U, L, R, options) }
+        : {});
+}
+function FromMappedKey(K, U, L, R, options) {
+    return FromPropertyKeys(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+    const P = FromMappedKey(T, U, L, R, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ExtendsFromMappedKey = ExtendsFromMappedKey;

package/build/require/type/extends/extends-from-mapped-result.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TExtends } from './extends';
+type FromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
+    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromProperties<K, U, L, R>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (FromProperties<K['properties'], U, L, R>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedResult<K, U, L, R>;
+export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedResult<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/extends/extends-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const extends_1 = require("./extends");
+function FromProperties(K, U, L, R, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, extends_1.Extends)(K[K2], U, L, R, options) };
+    }, {});
+}
+function FromMappedResult(K, U, L, R, options) {
+    return FromProperties(K.properties, U, L, R, options);
+}
+function ExtendsFromMappedResult(T, U, L, R, options) {
+    const P = FromMappedResult(T, U, L, R, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ExtendsFromMappedResult = ExtendsFromMappedResult;

package/build/require/type/extends/extends.d.ts

@@ -3,12 +3,12 @@ import type { Static } from '../static/index';
 import { type TUnion } from '../union/index';
 import { TMappedKey, TMappedResult } from '../mapped/index';
 import { UnionToTuple } from '../helpers/index';
-import { type TExtendsMappedResult } from './extends-mapped-result';
-import { type TExtendsMappedResultFromResult } from './extends-mapped-result-from-result';
+import { type TExtendsFromMappedKey } from './extends-from-mapped-key';
+import { type TExtendsFromMappedResult } from './extends-from-mapped-result';
 type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
 declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
-export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResultFromResult<L, R, T, F>;
-export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResult<L, R, T, F>;
+export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
 export declare function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
 export {};

package/build/require/type/extends/extends.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extends = void 0;
-const type_1 = require("../guard/type");
 const index_1 = require("../union/index");
 const extends_check_1 = require("./extends-check");
-const type_2 = require("../clone/type");
-const extends_mapped_result_1 = require("./extends-mapped-result");
-const extends_mapped_result_from_result_1 = require("./extends-mapped-result-from-result");
+const type_1 = require("../clone/type");
+const extends_from_mapped_key_1 = require("./extends-from-mapped-key");
+const extends_from_mapped_result_1 = require("./extends-from-mapped-result");
+const type_2 = require("../guard/type");
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = (0, extends_check_1.ExtendsCheck)(left, right);
     return (R === extends_check_1.ExtendsResult.Union ? (0, index_1.Union)([trueType, falseType]) :
@@ -14,8 +14,8 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 function Extends(L, R, T, F, options = {}) {
-    return ((0, type_1.TMappedResult)(L) ? (0, type_2.CloneType)((0, extends_mapped_result_from_result_1.ExtendsMappedResultFromResult)(L, R, T, F), options) :
-        (0, type_1.TMappedKey)(L) ? (0, type_2.CloneType)((0, extends_mapped_result_1.ExtendsMappedResult)(L, R, T, F), options) :
-            (0, type_2.CloneType)(ExtendsResolve(L, R, T, F), options));
+    return ((0, type_2.TMappedResult)(L) ? (0, extends_from_mapped_result_1.ExtendsFromMappedResult)(L, R, T, F, options) :
+        (0, type_2.TMappedKey)(L) ? (0, type_1.CloneType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
+            (0, type_1.CloneType)(ExtendsResolve(L, R, T, F), options));
 }
 exports.Extends = Extends;

package/build/require/type/extends/index.d.ts

@@ -1,5 +1,5 @@
 export * from './extends-check';
-export * from './extends-mapped-result-from-result';
-export * from './extends-mapped-result';
+export * from './extends-from-mapped-key';
+export * from './extends-from-mapped-result';
 export * from './extends-undefined';
 export * from './extends';

package/build/require/type/extends/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./extends-check"), exports);
-__exportStar(require("./extends-mapped-result-from-result"), exports);
-__exportStar(require("./extends-mapped-result"), exports);
+__exportStar(require("./extends-from-mapped-key"), exports);
+__exportStar(require("./extends-from-mapped-result"), exports);
 __exportStar(require("./extends-undefined"), exports);
 __exportStar(require("./extends"), exports);

package/build/require/type/extract/extract-from-mapped-result.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TExtract } from './extract';
+type FromProperties<K extends TProperties, U extends TSchema> = ({
+    [K2 in keyof K]: TExtract<K[K2], U>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
+export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/extract/extract-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const extract_1 = require("./extract");
+function FromProperties(K, U, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, extract_1.Extract)(K[K2], U, options) };
+    }, {});
+}
+function FromMappedResult(K, U, options) {
+    return FromProperties(K.properties, U, options);
+}
+function ExtractFromMappedResult(T, U, options) {
+    const P = FromMappedResult(T, U, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ExtractFromMappedResult = ExtractFromMappedResult;

package/build/require/type/extract/extract.d.ts

@@ -1,19 +1,22 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TTemplateLiteral } from '../template-literal/index';
 import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type Static } from '../static/index';
-import { UnionResolve } from '../union/index';
-type FromTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
+import { UnionEvaluated } from '../union/index';
+import { type TExtractFromMappedResult } from './extract-from-mapped-result';
+type FromTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
 type FromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? FromTemplateLiteralResult<Assert<S, string>> : never;
 type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
-}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
+}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
 export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
 export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
 export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
 export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/require/type/extract/extract.js

@@ -6,6 +6,7 @@ const index_2 = require("../union/index");
 const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
+const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
 const type_2 = require("../guard/type");
 function ExtractResolve(L, R) {
     return ((0, type_2.TTemplateLiteral)(L) ? ExtractResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
@@ -19,7 +20,12 @@ function ExtractResolve(L, R) {
 }
 exports.ExtractResolve = ExtractResolve;
 function Extract(type, union, options = {}) {
-    const E = ExtractResolve(type, union);
-    return (0, type_1.CloneType)(E, options);
+    if ((0, type_2.TMappedResult)(type)) {
+        return (0, extract_from_mapped_result_1.ExtractFromMappedResult)(type, union, options);
+    }
+    else {
+        const E = ExtractResolve(type, union);
+        return (0, type_1.CloneType)(E, options);
+    }
 }
 exports.Extract = Extract;