typebox 1.1.9 → 1.1.10

package/build/type/action/mapped.d.mts

@@ -3,10 +3,10 @@ import { type TIdentifier } from '../types/identifier.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TInstantiate } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
-export type TMappedDeferred<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Key, As, Property]>);
+export type TMappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Type, As, Property]>);
 /** Creates a deferred Mapped action. */
-export declare function MappedDeferred<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, key: Key, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Key, As, Property>;
+export declare function MappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Type, As, Property>;
 /** Applies a Mapped action using the given types. */
-export type TMapped<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = (TInstantiate<{}, TMappedDeferred<Identifier, Key, As, Property>>);
+export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TInstantiate<{}, TMappedDeferred<Identifier, Type, As, Property>>);
 /** Applies a Mapped action using the given types. */
-export declare function Mapped<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, key: Key, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Key, As, Property>;
+export declare function Mapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Type, As, Property>;

package/build/type/action/mapped.mjs

@@ -2,10 +2,10 @@
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
-export function MappedDeferred(identifier, key, as, property, options = {}) {
-    return Deferred('Mapped', [identifier, key, as, property], options);
+export function MappedDeferred(identifier, type, as, property, options = {}) {
+    return Deferred('Mapped', [identifier, type, as, property], options);
 }
 /** Applies a Mapped action using the given types. */
-export function Mapped(identifier, key, as, property, options = {}) {
-    return Instantiate({}, MappedDeferred(identifier, key, as, property, options));
+export function Mapped(identifier, type, as, property, options = {}) {
+    return Instantiate({}, MappedDeferred(identifier, type, as, property, options));
 }

package/build/type/engine/call/distribute-arguments.d.mts

@@ -3,13 +3,13 @@ import { type TUnion } from '../../types/union.mjs';
 import { type TDeferred } from '../../types/deferred.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TParameter } from '../../types/parameter.mjs';
-type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef<infer Name extends string> ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Name]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Result);
+type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef<infer Name extends string> ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Name]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
 type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
 type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
 type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);
 type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
 type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
 type TDistribute<ZippedArguments extends [boolean, TSchema][], Result extends TSchema[][] = [[]]> = (ZippedArguments extends [infer Left extends [boolean, TSchema], ...infer Right extends [boolean, TSchema][]] ? Left[0] extends true ? TDistribute<Right, TCross<Result, TExpand<Left[1]>>> : TDistribute<Right, TCross<Result, [Left[1]]>> : Result);
-export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments]> = Result;
+export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = (Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : Expression extends TDeferred<'Mapped', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments])> = Result;
 export declare function DistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema>(parameters: [...Parameters], arguments_: [...Arguments], expression: Expression): TDistributeArguments<Parameters, Arguments, Expression>;
 export {};

package/build/type/engine/call/distribute-arguments.mjs

@@ -4,11 +4,16 @@ import { IsUnion } from '../../types/union.mjs';
 import { IsDeferred } from '../../types/deferred.mjs';
 import { IsRef } from '../../types/ref.mjs';
 function CollectDistributionNames(expression, result = []) {
-    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+    return (
+    // Conditional
+    IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
         ? IsRef(expression.parameters[0])
             ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0].$ref]))
             : CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], result))
-        : result);
+        // Mapped
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? (IsDeferred(expression.parameters[1]) && Guard.IsEqual(expression.parameters[1].action, 'KeyOf') && IsRef(expression.parameters[1].parameters[0]) ? [...result, expression.parameters[1].parameters[0]['$ref']] :
+                result) : result);
 }
 function BuildDistributionArray(parameters, names) {
     return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
@@ -48,5 +53,7 @@ export function DistributeArguments(parameters, arguments_, expression) {
     const zippedArguments = ZipDistributionArray(arguments_, distributionArray);
     return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
         ? Distribute(zippedArguments)
-        : [arguments_]);
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? Distribute(zippedArguments)
+            : [arguments_]);
 }

package/build/type/engine/call/instantiate.mjs

@@ -31,7 +31,7 @@ function CallDistributed(context, state, target, parameters, expression, distrib
 function CallImmediate(context, state, target, parameters, expression, arguments_) {
     const distributedArguments = DistributeArguments(parameters, arguments_, expression);
     const returnTypes = CallDistributed(context, state, target, parameters, expression, distributedArguments);
-    const result = returnTypes.length === 1 ? returnTypes[0] : EvaluateUnion(returnTypes);
+    const result = Guard.IsEqual(returnTypes.length, 1) ? returnTypes[0] : EvaluateUnion(returnTypes);
     return result;
 }
 export function CallInstantiate(context, state, target, arguments_) {

package/build/type/engine/mapped/instantiate.d.mts

@@ -4,25 +4,22 @@ import { type TLiteral } from '../../types/literal.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
-import { type TMappedKeys } from './mapped-keys.mjs';
 import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TMappedDeferred } from '../../action/mapped.mjs';
 import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TInstantiateKeyAs<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, ContextWithKey extends TProperties = Memory.TAssign<Context, {
-    [_ in Identifier['name']]: Key;
-}>, InstantiatedKeyAs extends TSchema = TInstantiateType<ContextWithKey, State, As>, Result extends TSchema = InstantiatedKeyAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedKeyAs> = Result;
-type TInstantiateProperty<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, Property extends TSchema, ContextWithKey extends TProperties = Memory.TAssign<Context, {
-    [_ in Identifier['name']]: Key;
-}>, InstantiatedProperty extends TSchema = TInstantiateType<ContextWithKey, State, Property>> = InstantiatedProperty;
-type TMappedProperty<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedProperty extends TSchema = TInstantiateProperty<Context, State, Identifier, Key, Property>, InstantiatedKeyAs extends TSchema = TInstantiateKeyAs<Context, State, Identifier, Key, As>, Result extends TProperties = (InstantiatedKeyAs extends TLiteral<string | number> ? {
-    [_ in InstantiatedKeyAs['const']]: InstantiatedProperty;
-} : {})> = Result;
-type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Keys extends TSchema[], As extends TSchema, Type extends TSchema, Result extends TProperties = {}> = (Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Type, Result & TMappedProperty<Context, State, Identifier, Left, As, Type>> : Result);
-type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, Keys extends TSchema[] = TMappedKeys<Key>, Mapped extends TProperties = TMappedProperties<Context, State, Identifier, Keys, As, Property>, Result extends TSchema = TObject<{
-    [Key in keyof Mapped]: Mapped[Key];
-}>> = Result;
-type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedKey extends TSchema = TInstantiateType<Context, State, Key>> = TMappedAction<Context, State, Identifier, InstantiatedKey, As, Property>;
-export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Key]> extends true ? TMappedImmediate<Context, State, Identifier, Key, As, Property> : TMappedDeferred<Identifier, Key, As, Property>;
-export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, key: Key, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Key, As, Property>;
+import { type TMappedVariants } from './mapped-variants.mjs';
+import { type TEvaluateIntersect } from '../evaluate/index.mjs';
+type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
+type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Variant;
+}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
+    [_ in CanonicalAs['const']]: InstantiatedProperty;
+} : {}> = Result;
+type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
+type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
+type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
+type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstantiatedType, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TMappedImmediate<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>;
+export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Type, As, Property>;
 export {};

package/build/type/engine/mapped/instantiate.mjs

@@ -2,46 +2,48 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
 import { Object } from '../../types/object.mjs';
-import { MappedKeys } from './mapped-keys.mjs';
 import { IsTemplateLiteral } from '../../types/template-literal.mjs';
 import { MappedDeferred } from '../../action/mapped.mjs';
 import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function InstantiateKeyAs(context, state, identifier, key, as) {
-    const contextWithKey = Memory.Assign(context, { [identifier['name']]: key });
-    const instantiatedKeyAs = InstantiateType(contextWithKey, state, as);
-    const result = IsTemplateLiteral(instantiatedKeyAs) ? TemplateLiteralDecode(instantiatedKeyAs.pattern) : instantiatedKeyAs;
+import { MappedVariants } from './mapped-variants.mjs';
+import { EvaluateIntersect } from '../evaluate/index.mjs';
+function CanonicalAs(instantiatedAs) {
+    const result = IsTemplateLiteral(instantiatedAs) ? TemplateLiteralDecode(instantiatedAs.pattern) : instantiatedAs;
     return result;
 }
-function InstantiateProperty(context, state, identifier, key, property) {
-    const contextWithKey = Memory.Assign(context, { [identifier['name']]: key });
-    const instantiatedProperty = InstantiateType(contextWithKey, state, property);
-    return instantiatedProperty;
-}
-function MappedProperty(context, state, identifier, key, as, property) {
-    const instantiatedProperty = InstantiateProperty(context, state, identifier, key, property);
-    const instantiatedKeyAs = InstantiateKeyAs(context, state, identifier, key, as);
-    return (IsLiteralString(instantiatedKeyAs) || IsLiteralNumber(instantiatedKeyAs)
-        ? { [instantiatedKeyAs.const]: instantiatedProperty }
+function MappedVariant(context, state, identifier, variant, as, property) {
+    const variantContext = Memory.Assign(context, { [identifier['name']]: variant });
+    const instantiatedAs = InstantiateType(variantContext, state, as);
+    const canonicalAs = CanonicalAs(instantiatedAs);
+    const instantiatedProperty = InstantiateType(variantContext, state, property);
+    return (IsLiteralNumber(canonicalAs) || IsLiteralString(canonicalAs)
+        ? { [canonicalAs.const]: instantiatedProperty }
         : {});
 }
-function MappedProperties(context, state, identifier, keys, as, type) {
-    return keys.reduce((result, left) => {
-        return { ...result, ...MappedProperty(context, state, identifier, left, as, type) };
-    }, {});
+function MappedProperties(context, state, identifier, variants, as, property) {
+    return variants.reduce((result, left) => {
+        return [...result, MappedVariant(context, state, identifier, left, as, property)];
+    }, []);
+}
+function MappedObjects(properties) {
+    return properties.reduce((result, left) => {
+        return [...result, Object(left)];
+    }, []);
 }
-function MappedAction(context, state, identifier, key, as, type) {
-    const keys = MappedKeys(key);
-    const mapped = MappedProperties(context, state, identifier, keys, as, type);
-    const result = Object(mapped);
+function MappedAction(context, state, identifier, type, as, property) {
+    const variants = MappedVariants(type);
+    const mappedProperties = MappedProperties(context, state, identifier, variants, as, property);
+    const mappedObjects = MappedObjects(mappedProperties);
+    const result = EvaluateIntersect(mappedObjects);
     return result;
 }
-function MappedImmediate(context, state, identifier, key, as, property, options) {
-    const instantiatedKey = InstantiateType(context, state, key);
-    return Memory.Update(MappedAction(context, state, identifier, instantiatedKey, as, property), {}, options);
+function MappedImmediate(context, state, identifier, type, as, property, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(MappedAction(context, state, identifier, instantiatedType, as, property), {}, options);
 }
-export function MappedInstantiate(context, state, identifier, key, as, property, options) {
-    return (CanInstantiate(context, [key])
-        ? MappedImmediate(context, state, identifier, key, as, property, options)
-        : MappedDeferred(identifier, key, as, property, options));
+export function MappedInstantiate(context, state, identifier, type, as, property, options) {
+    return (CanInstantiate(context, [type])
+        ? MappedImmediate(context, state, identifier, type, as, property, options)
+        : MappedDeferred(identifier, type, as, property, options));
 }

package/build/type/engine/mapped/{mapped-keys.d.mts → mapped-variants.d.mts}

@@ -5,10 +5,11 @@ import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TEnumValuesToVariants } from '../enum/index.mjs';
 import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
-type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Decoded>> = Result;
+type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema[] = TFromType<Decoded>> = Result;
 type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
 type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<string | number> ? [Type] : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+    Type
 ])> = Result;
-export type TMappedKeys<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
-export declare function MappedKeys<Type extends TSchema>(type: Type): TMappedKeys<Type>;
+export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
+export declare function MappedVariants<Type extends TSchema>(type: Type): TMappedVariants<Type>;
 export {};

package/build/type/engine/mapped/{mapped-keys.mjs → mapped-variants.mjs}

@@ -20,10 +20,10 @@ function FromType(type) {
         IsLiteralString(type) || IsLiteralNumber(type) ? [type] :
             IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
                 IsUnion(type) ? FromUnion(type.anyOf) :
-                    []);
+                    [type]);
     return result;
 }
-export function MappedKeys(type) {
+export function MappedVariants(type) {
     const result = FromType(type);
     return result;
 }

package/build/type/script/mapping.d.mts

@@ -274,7 +274,7 @@ export type TMappedOptionalMapping<Input extends [unknown, unknown] | [unknown]
 export declare function MappedOptionalMapping(input: [unknown, unknown] | [unknown] | []): unknown;
 export type TMappedAsMapping<Input extends [unknown, unknown] | []> = (Input extends ['as', infer Type extends T.TSchema] ? [Type] : []);
 export declare function MappedAsMapping(input: [unknown, unknown] | []): unknown;
-export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Union extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Type extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? C.TMappedDeferred<T.TIdentifier<Key>, Union, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Type>>> : C.TMappedDeferred<T.TIdentifier<Key>, Union, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Type>>>) : never);
+export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Type extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Property extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? C.TMappedDeferred<T.TIdentifier<Key>, Type, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>> : C.TMappedDeferred<T.TIdentifier<Key>, Type, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>>) : never);
 export declare function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TReferenceMapping<Input extends string, Result extends T.TSchema = T.TRef<Input>> = Result;
 export declare function ReferenceMapping(input: string): unknown;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.9",
+  "version": "1.1.10",
   "keywords": [
     "typescript",
     "jsonschema"