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

package/build/import/type/guard/type.mjs

@@ -80,303 +80,304 @@ function IsOptionalFormat(value) {
 function IsOptionalSchema(value) {
     return ValueGuard.IsUndefined(value) || TSchema(value);
 }
-export function TReadonly(schema) {
-    return ValueGuard.IsObject(schema) && schema[ReadonlyKind] === 'Readonly';
-}
-export function TOptional(schema) {
-    return ValueGuard.IsObject(schema) && schema[OptionalKind] === 'Optional';
-}
-export function TAny(schema) {
-    return (TKindOf(schema, 'Any') &&
-        IsOptionalString(schema.$id));
-}
-export function TArray(schema) {
-    return (TKindOf(schema, 'Array') &&
-        schema.type === 'array' &&
-        IsOptionalString(schema.$id) &&
-        TSchema(schema.items) &&
-        IsOptionalNumber(schema.minItems) &&
-        IsOptionalNumber(schema.maxItems) &&
-        IsOptionalBoolean(schema.uniqueItems) &&
-        IsOptionalSchema(schema.contains) &&
-        IsOptionalNumber(schema.minContains) &&
-        IsOptionalNumber(schema.maxContains));
-}
-export function TAsyncIterator(schema) {
-    return (TKindOf(schema, 'AsyncIterator') &&
-        schema.type === 'AsyncIterator' &&
-        IsOptionalString(schema.$id) &&
-        TSchema(schema.items));
-}
-export function TBigInt(schema) {
-    return (TKindOf(schema, 'BigInt') &&
-        schema.type === 'bigint' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalBigInt(schema.exclusiveMaximum) &&
-        IsOptionalBigInt(schema.exclusiveMinimum) &&
-        IsOptionalBigInt(schema.maximum) &&
-        IsOptionalBigInt(schema.minimum) &&
-        IsOptionalBigInt(schema.multipleOf));
-}
-export function TBoolean(schema) {
-    return (TKindOf(schema, 'Boolean') &&
-        schema.type === 'boolean' &&
-        IsOptionalString(schema.$id));
-}
-export function TConstructor(schema) {
-    return (TKindOf(schema, 'Constructor') &&
-        schema.type === 'Constructor' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsArray(schema.parameters) &&
-        schema.parameters.every(schema => TSchema(schema)) &&
-        TSchema(schema.returns));
-}
-export function TDate(schema) {
-    return (TKindOf(schema, 'Date') &&
-        schema.type === 'Date' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
-        IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-        IsOptionalNumber(schema.maximumTimestamp) &&
-        IsOptionalNumber(schema.minimumTimestamp) &&
-        IsOptionalNumber(schema.multipleOfTimestamp));
-}
-export function TFunction(schema) {
-    return (TKindOf(schema, 'Function') &&
-        schema.type === 'Function' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsArray(schema.parameters) &&
-        schema.parameters.every(schema => TSchema(schema)) &&
-        TSchema(schema.returns));
-}
-export function TInteger(schema) {
-    return (TKindOf(schema, 'Integer') &&
-        schema.type === 'integer' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.exclusiveMaximum) &&
-        IsOptionalNumber(schema.exclusiveMinimum) &&
-        IsOptionalNumber(schema.maximum) &&
-        IsOptionalNumber(schema.minimum) &&
-        IsOptionalNumber(schema.multipleOf));
-}
-export function TProperties(schema) {
-    return (ValueGuard.IsObject(schema) &&
-        Object.entries(schema).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema)));
-}
-export function TIntersect(schema) {
-    return (TKindOf(schema, 'Intersect') &&
-        (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
-        ValueGuard.IsArray(schema.allOf) &&
-        schema.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
-        IsOptionalString(schema.type) &&
-        (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
-        IsOptionalString(schema.$id));
-}
-export function TIterator(schema) {
-    return (TKindOf(schema, 'Iterator') &&
-        schema.type === 'Iterator' &&
-        IsOptionalString(schema.$id) &&
-        TSchema(schema.items));
-}
-export function TKindOf(schema, kind) {
-    return ValueGuard.IsObject(schema) && Kind in schema && schema[Kind] === kind;
-}
-export function TLiteralString(schema) {
-    return TLiteral(schema) && ValueGuard.IsString(schema.const);
-}
-export function TLiteralNumber(schema) {
-    return TLiteral(schema) && ValueGuard.IsNumber(schema.const);
-}
-export function TLiteralBoolean(schema) {
-    return TLiteral(schema) && ValueGuard.IsBoolean(schema.const);
-}
-export function TLiteral(schema) {
-    return (TKindOf(schema, 'Literal') &&
-        IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
-        ValueGuard.IsNumber(schema.const) ||
-        ValueGuard.IsString(schema.const)));
-}
-export function TMappedKey(schema) {
-    return (TKindOf(schema, 'MappedKey') &&
-        ValueGuard.IsArray(schema.keys) &&
-        schema.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
-}
-export function TMappedResult(schema) {
-    return (TKindOf(schema, 'MappedResult') &&
-        TProperties(schema.properties));
-}
-export function TNever(schema) {
-    return (TKindOf(schema, 'Never') &&
-        ValueGuard.IsObject(schema.not) &&
-        Object.getOwnPropertyNames(schema.not).length === 0);
-}
-export function TNot(schema) {
-    return (TKindOf(schema, 'Not') &&
-        TSchema(schema.not));
-}
-export function TNull(schema) {
-    return (TKindOf(schema, 'Null') &&
-        schema.type === 'null' &&
-        IsOptionalString(schema.$id));
-}
-export function TNumber(schema) {
-    return (TKindOf(schema, 'Number') &&
-        schema.type === 'number' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.exclusiveMaximum) &&
-        IsOptionalNumber(schema.exclusiveMinimum) &&
-        IsOptionalNumber(schema.maximum) &&
-        IsOptionalNumber(schema.minimum) &&
-        IsOptionalNumber(schema.multipleOf));
-}
-export function TObject(schema) {
-    return (TKindOf(schema, 'Object') &&
-        schema.type === 'object' &&
-        IsOptionalString(schema.$id) &&
-        TProperties(schema.properties) &&
-        IsAdditionalProperties(schema.additionalProperties) &&
-        IsOptionalNumber(schema.minProperties) &&
-        IsOptionalNumber(schema.maxProperties));
-}
-export function TPromise(schema) {
-    return (TKindOf(schema, 'Promise') &&
-        schema.type === 'Promise' &&
-        IsOptionalString(schema.$id) &&
-        TSchema(schema.item));
-}
-export function TRecord(schema) {
-    return (TKindOf(schema, 'Record') &&
-        schema.type === 'object' &&
-        IsOptionalString(schema.$id) &&
-        IsAdditionalProperties(schema.additionalProperties) &&
-        ValueGuard.IsObject(schema.patternProperties) &&
+export function TReadonly(value) {
+    return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
+}
+export function TOptional(value) {
+    return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
+}
+export function TAny(value) {
+    return (TKindOf(value, 'Any') &&
+        IsOptionalString(value.$id));
+}
+export function TArray(value) {
+    return (TKindOf(value, 'Array') &&
+        value.type === 'array' &&
+        IsOptionalString(value.$id) &&
+        TSchema(value.items) &&
+        IsOptionalNumber(value.minItems) &&
+        IsOptionalNumber(value.maxItems) &&
+        IsOptionalBoolean(value.uniqueItems) &&
+        IsOptionalSchema(value.contains) &&
+        IsOptionalNumber(value.minContains) &&
+        IsOptionalNumber(value.maxContains));
+}
+export function TAsyncIterator(value) {
+    return (TKindOf(value, 'AsyncIterator') &&
+        value.type === 'AsyncIterator' &&
+        IsOptionalString(value.$id) &&
+        TSchema(value.items));
+}
+export function TBigInt(value) {
+    return (TKindOf(value, 'BigInt') &&
+        value.type === 'bigint' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalBigInt(value.exclusiveMaximum) &&
+        IsOptionalBigInt(value.exclusiveMinimum) &&
+        IsOptionalBigInt(value.maximum) &&
+        IsOptionalBigInt(value.minimum) &&
+        IsOptionalBigInt(value.multipleOf));
+}
+export function TBoolean(value) {
+    return (TKindOf(value, 'Boolean') &&
+        value.type === 'boolean' &&
+        IsOptionalString(value.$id));
+}
+export function TConstructor(value) {
+    return (TKindOf(value, 'Constructor') &&
+        value.type === 'Constructor' &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsArray(value.parameters) &&
+        value.parameters.every(schema => TSchema(schema)) &&
+        TSchema(value.returns));
+}
+export function TDate(value) {
+    return (TKindOf(value, 'Date') &&
+        value.type === 'Date' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
+        IsOptionalNumber(value.exclusiveMinimumTimestamp) &&
+        IsOptionalNumber(value.maximumTimestamp) &&
+        IsOptionalNumber(value.minimumTimestamp) &&
+        IsOptionalNumber(value.multipleOfTimestamp));
+}
+export function TFunction(value) {
+    return (TKindOf(value, 'Function') &&
+        value.type === 'Function' &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsArray(value.parameters) &&
+        value.parameters.every(schema => TSchema(schema)) &&
+        TSchema(value.returns));
+}
+export function TInteger(value) {
+    return (TKindOf(value, 'Integer') &&
+        value.type === 'integer' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximum) &&
+        IsOptionalNumber(value.exclusiveMinimum) &&
+        IsOptionalNumber(value.maximum) &&
+        IsOptionalNumber(value.minimum) &&
+        IsOptionalNumber(value.multipleOf));
+}
+export function TProperties(value) {
+    return (ValueGuard.IsObject(value) &&
+        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema)));
+}
+export function TIntersect(value) {
+    return (TKindOf(value, 'Intersect') &&
+        (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
+        ValueGuard.IsArray(value.allOf) &&
+        value.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
+        IsOptionalString(value.type) &&
+        (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
+        IsOptionalString(value.$id));
+}
+export function TIterator(value) {
+    return (TKindOf(value, 'Iterator') &&
+        value.type === 'Iterator' &&
+        IsOptionalString(value.$id) &&
+        TSchema(value.items));
+}
+export function TKindOf(value, kind) {
+    return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind;
+}
+export function TLiteralString(value) {
+    return TLiteral(value) && ValueGuard.IsString(value.const);
+}
+export function TLiteralNumber(value) {
+    return TLiteral(value) && ValueGuard.IsNumber(value.const);
+}
+export function TLiteralBoolean(value) {
+    return TLiteral(value) && ValueGuard.IsBoolean(value.const);
+}
+export function TLiteral(value) {
+    return (TKindOf(value, 'Literal') &&
+        IsOptionalString(value.$id) && TLiteralValue(value.const));
+}
+export function TLiteralValue(value) {
+    return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
+}
+export function TMappedKey(value) {
+    return (TKindOf(value, 'MappedKey') &&
+        ValueGuard.IsArray(value.keys) &&
+        value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
+}
+export function TMappedResult(value) {
+    return (TKindOf(value, 'MappedResult') &&
+        TProperties(value.properties));
+}
+export function TNever(value) {
+    return (TKindOf(value, 'Never') &&
+        ValueGuard.IsObject(value.not) &&
+        Object.getOwnPropertyNames(value.not).length === 0);
+}
+export function TNot(value) {
+    return (TKindOf(value, 'Not') &&
+        TSchema(value.not));
+}
+export function TNull(value) {
+    return (TKindOf(value, 'Null') &&
+        value.type === 'null' &&
+        IsOptionalString(value.$id));
+}
+export function TNumber(value) {
+    return (TKindOf(value, 'Number') &&
+        value.type === 'number' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximum) &&
+        IsOptionalNumber(value.exclusiveMinimum) &&
+        IsOptionalNumber(value.maximum) &&
+        IsOptionalNumber(value.minimum) &&
+        IsOptionalNumber(value.multipleOf));
+}
+export function TObject(value) {
+    return (TKindOf(value, 'Object') &&
+        value.type === 'object' &&
+        IsOptionalString(value.$id) &&
+        TProperties(value.properties) &&
+        IsAdditionalProperties(value.additionalProperties) &&
+        IsOptionalNumber(value.minProperties) &&
+        IsOptionalNumber(value.maxProperties));
+}
+export function TPromise(value) {
+    return (TKindOf(value, 'Promise') &&
+        value.type === 'Promise' &&
+        IsOptionalString(value.$id) &&
+        TSchema(value.item));
+}
+export function TRecord(value) {
+    return (TKindOf(value, 'Record') &&
+        value.type === 'object' &&
+        IsOptionalString(value.$id) &&
+        IsAdditionalProperties(value.additionalProperties) &&
+        ValueGuard.IsObject(value.patternProperties) &&
         ((schema) => {
             const keys = Object.getOwnPropertyNames(schema.patternProperties);
             return (keys.length === 1 &&
                 IsPattern(keys[0]) &&
                 ValueGuard.IsObject(schema.patternProperties) &&
                 TSchema(schema.patternProperties[keys[0]]));
-        })(schema));
-}
-export function TRecursive(schema) {
-    return ValueGuard.IsObject(schema) && Hint in schema && schema[Hint] === 'Recursive';
-}
-export function TRef(schema) {
-    return (TKindOf(schema, 'Ref') &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsString(schema.$ref));
-}
-export function TString(schema) {
-    return (TKindOf(schema, 'String') &&
-        schema.type === 'string' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.minLength) &&
-        IsOptionalNumber(schema.maxLength) &&
-        IsOptionalPattern(schema.pattern) &&
-        IsOptionalFormat(schema.format));
-}
-export function TSymbol(schema) {
-    return (TKindOf(schema, 'Symbol') &&
-        schema.type === 'symbol' &&
-        IsOptionalString(schema.$id));
-}
-export function TTemplateLiteral(schema) {
-    return (TKindOf(schema, 'TemplateLiteral') &&
-        schema.type === 'string' &&
-        ValueGuard.IsString(schema.pattern) &&
-        schema.pattern[0] === '^' &&
-        schema.pattern[schema.pattern.length - 1] === '$');
-}
-export function TThis(schema) {
-    return (TKindOf(schema, 'This') &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsString(schema.$ref));
-}
-export function TTransform(schema) {
-    return ValueGuard.IsObject(schema) && TransformKind in schema;
-}
-export function TTuple(schema) {
-    return (TKindOf(schema, 'Tuple') &&
-        schema.type === 'array' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsNumber(schema.minItems) &&
-        ValueGuard.IsNumber(schema.maxItems) &&
-        schema.minItems === schema.maxItems &&
-        ((ValueGuard.IsUndefined(schema.items) &&
-            ValueGuard.IsUndefined(schema.additionalItems) &&
-            schema.minItems === 0) || (ValueGuard.IsArray(schema.items) &&
-            schema.items.every(schema => TSchema(schema)))));
-}
-export function TUndefined(schema) {
-    return (TKindOf(schema, 'Undefined') &&
-        schema.type === 'undefined' &&
-        IsOptionalString(schema.$id));
-}
-export function TUnionLiteral(schema) {
-    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
-}
-export function TUnion(schema) {
-    return (TKindOf(schema, 'Union') &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsObject(schema) &&
-        ValueGuard.IsArray(schema.anyOf) &&
-        schema.anyOf.every(schema => TSchema(schema)));
-}
-export function TUint8Array(schema) {
-    return (TKindOf(schema, 'Uint8Array') &&
-        schema.type === 'Uint8Array' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.minByteLength) &&
-        IsOptionalNumber(schema.maxByteLength));
-}
-export function TUnknown(schema) {
-    return (TKindOf(schema, 'Unknown') &&
-        IsOptionalString(schema.$id));
-}
-export function TUnsafe(schema) {
-    return TKindOf(schema, 'Unsafe');
-}
-export function TVoid(schema) {
-    return (TKindOf(schema, 'Void') &&
-        schema.type === 'void' &&
-        IsOptionalString(schema.$id));
-}
-export function TKind(schema) {
-    return ValueGuard.IsObject(schema) && Kind in schema && ValueGuard.IsString(schema[Kind]) && !KnownTypes.includes(schema[Kind]);
-}
-export function TSchema(schema) {
-    return (ValueGuard.IsObject(schema)) && (TAny(schema) ||
-        TArray(schema) ||
-        TBoolean(schema) ||
-        TBigInt(schema) ||
-        TAsyncIterator(schema) ||
-        TConstructor(schema) ||
-        TDate(schema) ||
-        TFunction(schema) ||
-        TInteger(schema) ||
-        TIntersect(schema) ||
-        TIterator(schema) ||
-        TLiteral(schema) ||
-        TMappedKey(schema) ||
-        TMappedResult(schema) ||
-        TNever(schema) ||
-        TNot(schema) ||
-        TNull(schema) ||
-        TNumber(schema) ||
-        TObject(schema) ||
-        TPromise(schema) ||
-        TRecord(schema) ||
-        TRef(schema) ||
-        TString(schema) ||
-        TSymbol(schema) ||
-        TTemplateLiteral(schema) ||
-        TThis(schema) ||
-        TTuple(schema) ||
-        TUndefined(schema) ||
-        TUnion(schema) ||
-        TUint8Array(schema) ||
-        TUnknown(schema) ||
-        TUnsafe(schema) ||
-        TVoid(schema) ||
-        TKind(schema));
+        })(value));
+}
+export function TRecursive(value) {
+    return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
+}
+export function TRef(value) {
+    return (TKindOf(value, 'Ref') &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsString(value.$ref));
+}
+export function TString(value) {
+    return (TKindOf(value, 'String') &&
+        value.type === 'string' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.minLength) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalPattern(value.pattern) &&
+        IsOptionalFormat(value.format));
+}
+export function TSymbol(value) {
+    return (TKindOf(value, 'Symbol') &&
+        value.type === 'symbol' &&
+        IsOptionalString(value.$id));
+}
+export function TTemplateLiteral(value) {
+    return (TKindOf(value, 'TemplateLiteral') &&
+        value.type === 'string' &&
+        ValueGuard.IsString(value.pattern) &&
+        value.pattern[0] === '^' &&
+        value.pattern[value.pattern.length - 1] === '$');
+}
+export function TThis(value) {
+    return (TKindOf(value, 'This') &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsString(value.$ref));
+}
+export function TTransform(value) {
+    return ValueGuard.IsObject(value) && TransformKind in value;
+}
+export function TTuple(value) {
+    return (TKindOf(value, 'Tuple') &&
+        value.type === 'array' &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsNumber(value.minItems) &&
+        ValueGuard.IsNumber(value.maxItems) &&
+        value.minItems === value.maxItems &&
+        ((ValueGuard.IsUndefined(value.items) &&
+            ValueGuard.IsUndefined(value.additionalItems) &&
+            value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
+            value.items.every(schema => TSchema(schema)))));
+}
+export function TUndefined(value) {
+    return (TKindOf(value, 'Undefined') &&
+        value.type === 'undefined' &&
+        IsOptionalString(value.$id));
+}
+export function TUnionLiteral(value) {
+    return TUnion(value) && value.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+}
+export function TUnion(value) {
+    return (TKindOf(value, 'Union') &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsObject(value) &&
+        ValueGuard.IsArray(value.anyOf) &&
+        value.anyOf.every(schema => TSchema(schema)));
+}
+export function TUint8Array(value) {
+    return (TKindOf(value, 'Uint8Array') &&
+        value.type === 'Uint8Array' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.minByteLength) &&
+        IsOptionalNumber(value.maxByteLength));
+}
+export function TUnknown(value) {
+    return (TKindOf(value, 'Unknown') &&
+        IsOptionalString(value.$id));
+}
+export function TUnsafe(value) {
+    return TKindOf(value, 'Unsafe');
+}
+export function TVoid(value) {
+    return (TKindOf(value, 'Void') &&
+        value.type === 'void' &&
+        IsOptionalString(value.$id));
+}
+export function TKind(value) {
+    return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+export function TSchema(value) {
+    return (ValueGuard.IsObject(value)) && (TAny(value) ||
+        TArray(value) ||
+        TBoolean(value) ||
+        TBigInt(value) ||
+        TAsyncIterator(value) ||
+        TConstructor(value) ||
+        TDate(value) ||
+        TFunction(value) ||
+        TInteger(value) ||
+        TIntersect(value) ||
+        TIterator(value) ||
+        TLiteral(value) ||
+        TMappedKey(value) ||
+        TMappedResult(value) ||
+        TNever(value) ||
+        TNot(value) ||
+        TNull(value) ||
+        TNumber(value) ||
+        TObject(value) ||
+        TPromise(value) ||
+        TRecord(value) ||
+        TRef(value) ||
+        TString(value) ||
+        TSymbol(value) ||
+        TTemplateLiteral(value) ||
+        TThis(value) ||
+        TTuple(value) ||
+        TUndefined(value) ||
+        TUnion(value) ||
+        TUint8Array(value) ||
+        TUnknown(value) ||
+        TUnsafe(value) ||
+        TVoid(value) ||
+        TKind(value));
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema } from '../schema/index.mjs';
-import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { Ensure, Evaluate, Assert } from '../helpers/index.mjs';
 import { type TArray } from '../array/index.mjs';
 import { type TAsyncIterator } from '../async-iterator/index.mjs';
 import { type TConstructor } from '../constructor/index.mjs';
@@ -8,19 +8,22 @@ import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TNever } from '../never/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-import type { TMappedResult } from './mapped-result.mjs';
+import { type TMappedResult } from './mapped-result.mjs';
 import type { TMappedKey } from './mapped-key.mjs';
-type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TNever);
+type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TMappedResult<P>);
 declare function FromMappedResult<K extends PropertyKey, P extends TProperties>(K: K, P: P): FromMappedResult<K, P>;
-type FromMappedKey<K extends PropertyKey, _ extends PropertyKey[]> = (K extends TLiteralValue ? TLiteral<K> : TLiteral<'never'>);
-declare function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, _: [...P]): TLiteral<TLiteralValue>;
+type MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]> = (P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+    [_ in L]: TLiteral<Assert<L, TLiteralValue>>;
+} & MappedKeyToMappedResultProperties<K, R> : {});
+declare function MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): MappedKeyToMappedResultProperties<K, P>;
+type FromMappedKey<K extends PropertyKey, P extends PropertyKey[], R extends TProperties = MappedKeyToMappedResultProperties<K, P>> = (FromMappedResult<K, R>);
+declare function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): FromMappedResult<K, MappedKeyToMappedResultProperties<K, P>>;
 type FromRest<K extends PropertyKey, T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchemaType<K, L>, ...FromRest<K, R>] : [];
 declare function FromRest<K extends PropertyKey, T extends TSchema[]>(K: K, T: [...T]): FromRest<K, T>;
 type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{