@openclaw/msteams 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/typebox/build/type/extends/object.mjs

@@ -7,6 +7,8 @@ import { IsOptional } from '../types/_optional.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsNever } from '../types/never.mjs';
 import { IsObject, Object } from '../types/object.mjs';
+import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
+import { Union, IsUnion } from '../types/union.mjs';
 import { ExtendsLeft } from './extends_left.mjs';
 import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
@@ -80,8 +82,28 @@ function ExtendsProperties(inferred, left, right) {
 function ExtendsObjectToObject(inferred, left, right) {
     return ExtendsProperties(inferred, left, right);
 }
+function RecordMergeInferred(left, right) {
+    return Guard.Keys(right).reduce((result, key) => {
+        return {
+            ...result, [key]: Guard.HasPropertyKey(left, key)
+                ? IsUnion(result[key])
+                    // @ts-ignore 5.0.4 cannot see `.anyOf`
+                    ? Union([...result[key].anyOf, right[key]])
+                    : Union([left[key], right[key]])
+                : right[key]
+        };
+    }, left);
+}
+function ExtendsRecordComparer(properties, keys, type, result) {
+    return Guard.ShiftLeft(keys, (left, right) => Result.Match(ExtendsLeft({}, properties[left], type), inferred => ExtendsRecordComparer(properties, right, type, RecordMergeInferred(result, inferred)), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(result));
+}
+function ExtendsObjectToRecord(inferred, properties, _pattern, value) {
+    const keys = Guard.Keys(properties);
+    const result = ExtendsRecordComparer(properties, keys, value, inferred);
+    return result;
+}
 export function ExtendsObject(inferred, left, right) {
-    return (IsObject(right)
-        ? ExtendsObjectToObject(inferred, left, right.properties)
-        : ExtendsRight(inferred, Object(left), right));
+    return (IsRecord(right) ? ExtendsObjectToRecord(inferred, left, RecordPattern(right), RecordValue(right)) :
+        IsObject(right) ? ExtendsObjectToObject(inferred, left, right.properties) :
+            ExtendsRight(inferred, Object(left), right));
 }

package/node_modules/typebox/build/type/extends/parameters.mjs

@@ -16,12 +16,12 @@ function ParameterCompare(inferred, left, leftRest, right, rightRest) {
     );
 }
 function ParameterRight(inferred, left, leftRest, rightRest) {
-    return Guard.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
+    return Guard.ShiftLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
         ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
         : Result.ExtendsFalse()); // 'fail: left was required'
 }
 function ParametersLeft(inferred, left, rightRest) {
-    return Guard.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
+    return Guard.ShiftLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
 }
 export function ExtendsParameters(inferred, left, right) {
     return ParametersLeft(inferred, left, right);

package/node_modules/typebox/build/type/extends/record.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TRecordPatternToType, type TRecord } from '../types/record.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export type TFromObject<Inferred extends TProperties, Properties extends TProperties> = keyof Properties extends never ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse;
+type TFromRecord<Inferred extends TProperties, _LeftKey extends TSchema, LeftValue extends TSchema, _RightKey extends TSchema, RightValue extends TSchema> = (TExtendsLeft<Inferred, LeftValue, RightValue>);
+export type TExtendsRecord<Inferred extends TProperties, LeftPattern extends string, LeftValue extends TSchema, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TFromRecord<Inferred, TRecordPatternToType<LeftPattern>, LeftValue, TRecordPatternToType<Pattern>, Value> : Right extends TObject<infer Properties extends TProperties> ? TFromObject<Inferred, Properties> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export declare function ExtendsRecord<Inferred extends TProperties, Pattern extends string, Value extends TSchema, Right extends TSchema>(inferred: Inferred, leftPattern: Pattern, leftValue: Value, right: Right): TExtendsRecord<Inferred, Pattern, Value, Right>;
+export {};

package/node_modules/typebox/build/type/extends/record.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsAny } from '../types/any.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { IsObject } from '../types/object.mjs';
+import { IsRecord, RecordPatternToType, RecordPattern, RecordValue } from '../types/record.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+function FromObject(inferred, properties) {
+    return (Guard.IsEqual(Guard.Keys(properties).length, 0)
+        ? Result.ExtendsTrue(inferred)
+        : Result.ExtendsFalse());
+}
+function FromRecord(inferred, _leftKey, leftValue, _rightKey, rightValue) {
+    return ExtendsLeft(inferred, leftValue, rightValue);
+}
+export function ExtendsRecord(inferred, leftPattern, leftValue, right) {
+    return (IsRecord(right) ? FromRecord(inferred, RecordPatternToType(leftPattern), leftValue, RecordPatternToType(RecordPattern(right)), RecordValue(right)) :
+        IsObject(right) ? FromObject(inferred, right.properties) :
+            IsAny(right) ? Result.ExtendsTrue(inferred) :
+                IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                    Result.ExtendsFalse());
+}

package/node_modules/typebox/build/type/extends/template_literal.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
-import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-export type TExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema, Decoded extends TSchema = TTemplateLiteralDecode<Left>> = TExtendsLeft<Inferred, Decoded, Right>;
-export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTemplateLiteral<Inferred, Left, Right>;
+import { type TEvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
+export type TExtendsTemplateLiteral<Inferred extends TProperties, Pattern extends string, Right extends TSchema, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Pattern extends string, Right extends TSchema>(inferred: Inferred, left: Pattern, right: Right): TExtendsTemplateLiteral<Inferred, Pattern, Right>;

package/node_modules/typebox/build/type/extends/template_literal.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { ExtendsLeft } from './extends_left.mjs';
-import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+import { EvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 export function ExtendsTemplateLiteral(inferred, left, right) {
-    const decoded = TemplateLiteralDecode(left);
-    return ExtendsLeft(inferred, decoded, right);
+    const evaluated = EvaluateTemplateLiteral(left);
+    return ExtendsLeft(inferred, evaluated, right);
 }

package/node_modules/typebox/build/type/extends/tuple.d.mts

@@ -6,6 +6,7 @@ import { type TExtendsLeft } from './extends_left.mjs';
 import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 import { type TInstantiateElements } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 import { type TTryRestInferable, type TTryInferable, type TInferable, type TInferTupleResult, type TInferUnionResult } from './inference.mjs';
 type TReverse<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReverse<Right, [Left, ...Result]> : Result);
 type TApplyReverse<Types extends TSchema[], Reversed extends boolean> = Reversed extends true ? TReverse<Types> : Types;
@@ -14,12 +15,8 @@ type TElementsCompare<Inferred extends TProperties, Reversed extends boolean, Le
 type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], Inferable extends TInferable | undefined = TTryRestInferable<Right>> = (Inferable extends TInferable ? TInferTupleResult<Inferred, Inferable['name'], TApplyReverse<LeftRest, Reversed>, Inferable['type']> : LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsCompare<Inferred, Reversed, Head, Tail, Right, RightRest> : Result.TExtendsFalse);
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
-type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, {
-    callstack: [];
-}, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
+type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
 type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
-export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, {
-    callstack: [];
-}, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
+export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -7,6 +7,7 @@ import { ExtendsLeft } from './extends_left.mjs';
 import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 import { InstantiateElements } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 // ----------------------------------------------------------------------------
 // Inference
 // ----------------------------------------------------------------------------
@@ -31,10 +32,10 @@ function ElementsLeft(inferred, reversed, leftRest, right, rightRest) {
     // Rest Inferrable Right Means we delegate to TInferTupleResult to Generate a Result
     IsInferable(inferable)
         ? InferTupleResult(inferred, inferable['name'], ApplyReverse(leftRest, reversed), inferable['type'])
-        : Guard.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
+        : Guard.ShiftLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
 }
 function ElementsRight(inferred, reversed, leftRest, rightRest) {
-    return Guard.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
+    return Guard.ShiftLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
         ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
         : Result.ExtendsFalse()); // 'Fail: right-empty-and-left-not-empty'
 }
@@ -42,7 +43,7 @@ function Elements(inferred, reversed, leftRest, rightRest) {
     return ElementsRight(inferred, reversed, leftRest, rightRest);
 }
 function ExtendsTupleToTuple(inferred, left, right) {
-    const instantiatedRight = InstantiateElements(inferred, { callstack: [] }, right);
+    const instantiatedRight = InstantiateElements(inferred, State([], []), right);
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
@@ -50,10 +51,10 @@ function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
-    const instantiatedLeft = InstantiateElements(inferred, { callstack: [] }, left);
+    const instantiatedLeft = InstantiateElements(inferred, State([], []), left);
     return (IsTuple(right) ? ExtendsTupleToTuple(inferred, instantiatedLeft, right.items) :
         IsArray(right) ? ExtendsTupleToArray(inferred, instantiatedLeft, right.items) :
             ExtendsRight(inferred, Tuple(instantiatedLeft), right));

package/node_modules/typebox/build/type/extends/union.mjs

@@ -8,10 +8,10 @@ import * as Result from './result.mjs';
 // ----------------------------------------------------------------------------
 import { IsInferable, TryInferable, InferUnionResult } from './inference.mjs';
 function ExtendsUnionSome(inferred, type, unionTypes) {
-    return Guard.TakeLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
+    return Guard.ShiftLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
 }
 function ExtendsUnionLeft(inferred, left, right) {
-    return Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 export function ExtendsUnion(inferred, left, right) {
     const inferrable = TryInferable(right);

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

@@ -1,85 +1,70 @@
 import { Memory } from '../../system/memory/index.mjs';
-import * as C from '../action/index.mjs';
 import * as T from '../types/index.mjs';
+import * as S from '../action/index.mjs';
 type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = ([
     Target,
     Parameters
 ] extends ['Array', [infer Type extends T.TSchema]] ? T.TArray<Type> : [
     Target,
     Parameters
-] extends ['AsyncIterator', [infer Type extends T.TSchema]] ? T.TAsyncIterator<Type> : [
+] extends ['Capitalize', [infer Type extends T.TSchema]] ? S.TCapitalizeDeferred<Type> : [
     Target,
     Parameters
-] extends ['Promise', [infer Type extends T.TSchema]] ? T.TPromise<Type> : [
+] extends ['ConstructorParameters', [infer Type extends T.TSchema]] ? S.TConstructorParametersDeferred<Type> : [
     Target,
     Parameters
-] extends ['Iterator', [infer Type extends T.TSchema]] ? T.TIterator<Type> : [
+] extends ['Evaluate', [infer Type extends T.TSchema]] ? S.TEvaluateDeferred<Type> : [
     Target,
     Parameters
-] extends ['Awaited', [infer Type extends T.TSchema]] ? C.TAwaitedDeferred<Type> : [
+] extends ['Exclude', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? S.TExcludeDeferred<Left, Right> : [
     Target,
     Parameters
-] extends ['Capitalize', [infer Type extends T.TSchema]] ? C.TCapitalizeDeferred<Type> : [
+] extends ['Extract', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? S.TExtractDeferred<Left, Right> : [
     Target,
     Parameters
-] extends ['ConstructorParameters', [infer Type extends T.TSchema]] ? C.TConstructorParametersDeferred<Type> : [
+] extends ['Index', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? S.TIndexDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['Evaluate', [infer Type extends T.TSchema]] ? C.TEvaluateDeferred<Type> : [
+] extends ['InstanceType', [infer Type extends T.TSchema]] ? S.TInstanceTypeDeferred<Type> : [
     Target,
     Parameters
-] extends ['Exclude', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? C.TExcludeDeferred<Left, Right> : [
+] extends ['KeyOf', [infer Type extends T.TSchema]] ? S.TKeyOfDeferred<Type> : [
     Target,
     Parameters
-] extends ['Extract', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? C.TExtractDeferred<Left, Right> : [
+] extends ['Lowercase', [infer Type extends T.TSchema]] ? S.TLowercaseDeferred<Type> : [
     Target,
     Parameters
-] extends ['Index', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TIndexDeferred<Type, Indexer> : [
+] extends ['NonNullable', [infer Type extends T.TSchema]] ? S.TNonNullableDeferred<Type> : [
     Target,
     Parameters
-] extends ['InstanceType', [infer Type extends T.TSchema]] ? C.TInstanceTypeDeferred<Type> : [
+] extends ['Omit', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? S.TOmitDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['KeyOf', [infer Type extends T.TSchema]] ? C.TKeyOfDeferred<Type> : [
+] extends ['Parameters', [infer Type extends T.TSchema]] ? S.TParametersDeferred<Type> : [
     Target,
     Parameters
-] extends ['Lowercase', [infer Type extends T.TSchema]] ? C.TLowercaseDeferred<Type> : [
+] extends ['Partial', [infer Type extends T.TSchema]] ? S.TPartialDeferred<Type> : [
     Target,
     Parameters
-] extends ['NonNullable', [infer Type extends T.TSchema]] ? C.TNonNullableDeferred<Type> : [
+] extends ['Pick', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? S.TPickDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['Omit', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TOmitDeferred<Type, Indexer> : [
-    Target,
-    Parameters
-] extends ['Options', [infer Type extends T.TSchema, infer Options extends T.TSchema]] ? C.TOptionsDeferred<Type, Options> : [
-    Target,
-    Parameters
-] extends ['Parameters', [infer Type extends T.TSchema]] ? C.TParametersDeferred<Type> : [
-    Target,
-    Parameters
-] extends ['Partial', [infer Type extends T.TSchema]] ? C.TPartialDeferred<Type> : [
-    Target,
-    Parameters
-] extends ['Pick', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TPickDeferred<Type, Indexer> : [
-    Target,
-    Parameters
-] extends ['Readonly', [infer Type extends T.TSchema]] ? C.TReadonlyObjectDeferred<Type> : [
+] extends ['Readonly', [infer Type extends T.TSchema]] ? S.TReadonlyObjectDeferred<Type> : [
     Target,
     Parameters
 ] extends ['Record', [infer Key extends T.TSchema, infer Value extends T.TSchema]] ? T.TRecordDeferred<Key, Value> : [
     Target,
     Parameters
-] extends ['Required', [infer Type extends T.TSchema]] ? C.TRequiredDeferred<Type> : [
+] extends ['Required', [infer Type extends T.TSchema]] ? S.TRequiredDeferred<Type> : [
     Target,
     Parameters
-] extends ['ReturnType', [infer Type extends T.TSchema]] ? C.TReturnTypeDeferred<Type> : [
+] extends ['ReturnType', [infer Type extends T.TSchema]] ? S.TReturnTypeDeferred<Type> : [
     Target,
     Parameters
-] extends ['Uncapitalize', [infer Type extends T.TSchema]] ? C.TUncapitalizeDeferred<Type> : [
+] extends ['Uncapitalize', [infer Type extends T.TSchema]] ? S.TUncapitalizeDeferred<Type> : [
     Target,
     Parameters
-] extends ['Uppercase', [infer Type extends T.TSchema]] ? C.TUppercaseDeferred<Type> : T.TCallConstruct<T.TRef<Target>, Parameters>);
+] extends ['Uppercase', [infer Type extends T.TSchema]] ? S.TUppercaseDeferred<Type> : T.TCallConstruct<T.TRef<Target>, Parameters>);
 type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (Input extends [infer Left, ...infer Right] ? Left extends [infer Item, infer _] ? TDelimitedDecode<Right, [...Result, Item]> : TDelimitedDecode<Right, [...Result, Left]> : Result);
 type TDelimited<Input extends [unknown, unknown]> = Input extends [infer Left extends unknown[], infer Right extends unknown[]] ? TDelimitedDecode<[...Left, ...Right]> : [];
 export type TGenericParameterExtendsEqualsMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer Name extends string, 'extends', infer Extends extends T.TSchema, '=', infer Equals extends T.TSchema] ? T.TParameter<Name, Extends, Equals> : never);
@@ -132,8 +117,14 @@ export type TKeywordVoidMapping<Input extends 'void'> = (T.TVoid);
 export declare function KeywordVoidMapping(input: 'void'): unknown;
 export type TKeywordThisMapping<Input extends 'this'> = (T.TThis);
 export declare function KeywordThisMapping(input: 'this'): unknown;
-export type TKeywordMapping<Input extends unknown> = Input;
-export declare function KeywordMapping(input: unknown): unknown;
+export type TLiteralBigIntMapping<Input extends string> = (Input extends `${infer Value extends bigint}` ? T.TLiteral<Value> : never);
+export declare function LiteralBigIntMapping(input: string): unknown;
+export type TLiteralBooleanMapping<Input extends 'true' | 'false'> = (Input extends 'true' ? T.TLiteral<true> : T.TLiteral<false>);
+export declare function LiteralBooleanMapping(input: 'true' | 'false'): unknown;
+export type TLiteralNumberMapping<Input extends string> = (Input extends `${infer Value extends number}` ? T.TLiteral<Value> : never);
+export declare function LiteralNumberMapping(input: string): unknown;
+export type TLiteralStringMapping<Input extends string> = (Input extends T.TLiteralValue ? T.TLiteral<Input> : never);
+export declare function LiteralStringMapping(input: string): unknown;
 export type TTemplateInterpolateMapping<Input extends [unknown, unknown, unknown]> = Input extends ['${', infer Type extends T.TSchema, '}'] ? Type : never;
 export declare function TemplateInterpolateMapping(input: [unknown, unknown, unknown]): unknown;
 export type TTemplateSpanMapping<Input extends string, Result extends T.TSchema = T.TLiteral<Input>> = Result;
@@ -145,16 +136,8 @@ export type TTemplateLiteralTypesMapping<Input extends [unknown, unknown, unknow
 export declare function TemplateLiteralTypesMapping(input: [unknown, unknown, unknown]): unknown;
 export type TTemplateLiteralMapping<Input extends unknown> = (Input extends infer Types extends T.TSchema[] ? T.TTemplateLiteralDeferred<Types> : never);
 export declare function TemplateLiteralMapping(input: unknown): unknown;
-export type TLiteralBigIntMapping<Input extends string> = (Input extends `${infer Value extends bigint}` ? T.TLiteral<Value> : never);
-export declare function LiteralBigIntMapping(input: string): unknown;
-export type TLiteralBooleanMapping<Input extends 'true' | 'false'> = (Input extends 'true' ? T.TLiteral<true> : T.TLiteral<false>);
-export declare function LiteralBooleanMapping(input: 'true' | 'false'): unknown;
-export type TLiteralNumberMapping<Input extends string> = (Input extends `${infer Value extends number}` ? T.TLiteral<Value> : never);
-export declare function LiteralNumberMapping(input: string): unknown;
-export type TLiteralStringMapping<Input extends string> = (Input extends T.TLiteralValue ? T.TLiteral<Input> : never);
-export declare function LiteralStringMapping(input: string): unknown;
-export type TLiteralMapping<Input extends unknown> = (Input);
-export declare function LiteralMapping(input: unknown): unknown;
+export type TDependentMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]> = (Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema, 'else', infer Else extends T.TSchema] ? T.TDependent<If, Then, Else> : Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema] ? T.TDependent<If, Then, T.TUnknown> : never);
+export declare function DependentMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]): unknown;
 export type TKeyOfMapping<Input extends [unknown] | []> = (Input extends [unknown] ? true : false);
 export declare function KeyOfMapping(input: [unknown] | []): unknown;
 type TIndexArrayMappingReduce<Input extends unknown[], Result extends unknown[] = []> = (Input extends [infer Left extends unknown, ...infer Right extends unknown[]] ? Left extends ['[', infer Type extends T.TSchema, ']'] ? TIndexArrayMappingReduce<Right, [...Result, [Type]]> : TIndexArrayMappingReduce<Right, [...Result, []]> : Result);
@@ -164,12 +147,12 @@ export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, u
 export declare function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | []): unknown;
 export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> = (Input extends ['(', infer Type extends T.TSchema, ')'] ? Type : Input extends infer Type extends T.TSchema ? Type : never);
 export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown): unknown;
-export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer Options extends Record<PropertyKey, unknown>] ? Options : []);
+export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer WithObject extends Record<PropertyKey, unknown>] ? WithObject : []);
 export declare function WithMapping(input: [unknown, unknown] | []): unknown;
-type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<C.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
-type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? C.TConditionalDeferred<Type, Right, True, False> : Type);
-type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? C.TOptionsDeferred<Type, With> : Type);
-export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
+type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<S.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
+type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? S.TConditionalDeferred<Type, Right, True, False> : Type);
+type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? S.TWithDeferred<Type, With> : Type);
+export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<S.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
 export declare function FactorMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (Operator extends '&' ? (Schema extends T.TIntersect<infer Types extends T.TSchema[]> ? T.TIntersect<[Left, ...Types]> : T.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends T.TUnion<infer Types extends T.TSchema[]> ? T.TUnion<[Left, ...Types]> : T.TUnion<[Left, Schema]>) : never) : never) : Left);
 export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | []> = (Input);
@@ -180,7 +163,7 @@ export type TExprTailMapping<Input extends [unknown, unknown, unknown] | []> = (
 export declare function ExprTailMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TExprMapping<Input extends [unknown, unknown]> = (Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]] ? TExprBinaryMapping<Left, Rest> : []);
 export declare function ExprMapping(input: [unknown, unknown]): unknown;
-export type TExprReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? T.TImmutableAdd<Type> : never);
+export type TExprReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? S.TAddImmutableDeferred<Type> : never);
 export declare function ExprReadonlyMapping(input: [unknown, unknown]): unknown;
 export type TExprPipeMapping<Input extends [unknown, unknown]> = (Input extends ['|', infer Type extends T.TSchema] ? Type : never);
 export declare function ExprPipeMapping(input: [unknown, unknown]): unknown;
@@ -208,13 +191,13 @@ export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown,
     [_ in Key]: ([
         IsReadonly,
         IsOptional
-    ] extends [true, true] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : [
+    ] extends [true, true] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : [
         IsReadonly,
         IsOptional
-    ] extends [true, false] ? T.TReadonlyAdd<Type> : [
+    ] extends [true, false] ? S.TAddReadonlyDeferred<Type> : [
         IsReadonly,
         IsOptional
-    ] extends [false, true] ? T.TOptionalAdd<Type> : Type);
+    ] extends [false, true] ? S.TAddOptionalDeferred<Type> : Type);
 } : never);
 export declare function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown]> = (Input);
@@ -234,13 +217,13 @@ export type TPropertiesMapping<Input extends [unknown, unknown, unknown], Result
 export declare function PropertiesMapping(input: [unknown, unknown, unknown]): unknown;
 export type T_Object_Mapping<Input extends unknown> = (Input extends [infer Properties extends T.TProperties, infer _PatternProperties extends T.TProperties] ? T.TObject<Properties> : never);
 export declare function _Object_Mapping(input: unknown): unknown;
-export type TElementNamedMapping<Input extends [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : Input extends [string, /**/ ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<Type> : Input extends [string, '?', ':', /*      */ infer Type extends T.TSchema] ? T.TOptionalAdd<Type> : Input extends [string, /**/ ':', /*      */ infer Type extends T.TSchema] ? Type : never);
+export type TElementNamedMapping<Input extends [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : Input extends [string, /**/ ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : Input extends [string, '?', ':', /*      */ infer Type extends T.TSchema] ? S.TAddOptionalDeferred<Type> : Input extends [string, /**/ ':', /*      */ infer Type extends T.TSchema] ? Type : never);
 export declare function ElementNamedMapping(input: [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyOptionalMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema, '?'] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : never);
+export type TElementReadonlyOptionalMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema, '?'] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
 export declare function ElementReadonlyOptionalMapping(input: [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<Type> : never);
+export type TElementReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : never);
 export declare function ElementReadonlyMapping(input: [unknown, unknown]): unknown;
-export type TElementOptionalMapping<Input extends [unknown, unknown]> = (Input extends [infer Type extends T.TSchema, '?'] ? T.TOptionalAdd<Type> : never);
+export type TElementOptionalMapping<Input extends [unknown, unknown]> = (Input extends [infer Type extends T.TSchema, '?'] ? S.TAddOptionalDeferred<Type> : never);
 export declare function ElementOptionalMapping(input: [unknown, unknown]): unknown;
 export type TElementBaseMapping<Input extends unknown> = (Input);
 export declare function ElementBaseMapping(input: unknown): unknown;
@@ -248,13 +231,13 @@ export type TElementMapping<Input extends [unknown, unknown] | [unknown]> = (Inp
 export declare function ElementMapping(input: [unknown, unknown] | [unknown]): unknown;
 export type TElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
 export declare function ElementListMapping(input: [unknown, unknown]): unknown;
-export type TTupleMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never);
-export declare function TupleMapping(input: [unknown, unknown, unknown]): unknown;
-export type TParameterReadonlyOptionalMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : never);
+export type T_Tuple_Mapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never);
+export declare function _Tuple_Mapping(input: [unknown, unknown, unknown]): unknown;
+export type TParameterReadonlyOptionalMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
 export declare function ParameterReadonlyOptionalMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
-export type TParameterReadonlyMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<Type> : never);
+export type TParameterReadonlyMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : never);
 export declare function ParameterReadonlyMapping(input: [unknown, unknown, unknown, unknown]): unknown;
-export type TParameterOptionalMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', infer Type extends T.TSchema] ? T.TOptionalAdd<Type> : never);
+export type TParameterOptionalMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', infer Type extends T.TSchema] ? S.TAddOptionalDeferred<Type> : never);
 export declare function ParameterOptionalMapping(input: [unknown, unknown, unknown, unknown]): unknown;
 export type TParameterTypeMapping<Input extends [unknown, unknown, unknown]> = (Input extends [string, ':', infer Type extends T.TSchema] ? Type : never);
 export declare function ParameterTypeMapping(input: [unknown, unknown, unknown]): unknown;
@@ -266,54 +249,56 @@ export type TParameterListMapping<Input extends [unknown, unknown]> = (TDelimite
 export declare function ParameterListMapping(input: [unknown, unknown]): unknown;
 export type T_Function_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['(', infer ParameterList extends T.TSchema[], ')', '=>', infer ReturnType extends T.TSchema] ? T.TFunction<ParameterList, ReturnType> : never);
 export declare function _Function_Mapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
-export type TConstructorMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema] ? T.TConstructor<ParameterList, InstanceType> : never);
-export declare function ConstructorMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
+export type T_Constructor_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema] ? T.TConstructor<ParameterList, InstanceType> : never);
+export declare function _Constructor_Mapping(input: [unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
 type TModifierOperation = 'add' | 'remove' | 'none';
-type TApplyReadonly<Readonly extends TModifierOperation, Type extends T.TSchema> = (Readonly extends 'remove' ? C.TReadonlyRemoveAction<Type> : Readonly extends 'add' ? C.TReadonlyAddAction<Type> : Type);
+type TApplyReadonly<Readonly extends TModifierOperation, Type extends T.TSchema> = (Readonly extends 'remove' ? S.TRemoveReadonlyDeferred<Type> : Readonly extends 'add' ? S.TAddReadonlyDeferred<Type> : Type);
 export type TMappedReadonlyMapping<Input extends [unknown, unknown] | [unknown] | []> = (Input extends ['-', 'readonly'] ? 'remove' : Input extends ['+', 'readonly'] ? 'add' : Input extends ['readonly'] ? 'add' : 'none');
 export declare function MappedReadonlyMapping(input: [unknown, unknown] | [unknown] | []): unknown;
-type TApplyOptional<Optional extends TModifierOperation, Type extends T.TSchema> = (Optional extends 'remove' ? C.TOptionalRemoveAction<Type> : Optional extends 'add' ? C.TOptionalAddAction<Type> : Type);
+type TApplyOptional<Optional extends TModifierOperation, Type extends T.TSchema> = (Optional extends 'remove' ? S.TRemoveOptionalDeferred<Type> : Optional extends 'add' ? S.TAddOptionalDeferred<Type> : Type);
 export type TMappedOptionalMapping<Input extends [unknown, unknown] | [unknown] | []> = (Input extends ['-', '?'] ? 'remove' : Input extends ['+', '?'] ? 'add' : Input extends ['?'] ? 'add' : 'none');
 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 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 T_Mapped_Mapping<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] ? S.TMappedDeferred<T.TIdentifier<Key>, Type, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>> : S.TMappedDeferred<T.TIdentifier<Key>, Type, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>>) : never);
+export declare function _Mapped_Mapping(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;
-export type TOptionsMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['Options', '<', infer Type extends T.TSchema, ',', infer Options extends T.TSchemaOptions, '>'] ? C.TOptionsDeferred<Type, Options> : never);
-export declare function OptionsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
-export type TJsonNumberMapping<Input extends string> = (Input extends `${infer Value extends number}` ? Value : never);
-export declare function JsonNumberMapping(input: string): unknown;
-export type TJsonBooleanMapping<Input extends 'true' | 'false'> = (Input extends 'true' ? true : false);
-export declare function JsonBooleanMapping(input: 'true' | 'false'): unknown;
-export type TJsonStringMapping<Input extends string> = (Input);
-export declare function JsonStringMapping(input: string): unknown;
-export type TJsonNullMapping<Input extends 'null'> = (null);
-export declare function JsonNullMapping(input: 'null'): unknown;
-export type TJsonPropertyMapping<Input extends [unknown, unknown, unknown]> = (Input extends [infer Key extends string, ':', infer Value extends unknown] ? {
+export type TWithBigIntMapping<Input extends string> = (Input extends `${infer Value extends bigint}` ? Value : never);
+export declare function WithBigIntMapping(input: string): unknown;
+export type TWithNumberMapping<Input extends string> = (Input extends `${infer Value extends number}` ? Value : never);
+export declare function WithNumberMapping(input: string): unknown;
+export type TWithBooleanMapping<Input extends 'true' | 'false'> = (Input extends 'true' ? true : false);
+export declare function WithBooleanMapping(input: 'true' | 'false'): unknown;
+export type TWithStringMapping<Input extends string> = (Input);
+export declare function WithStringMapping(input: string): unknown;
+export type TWithNullMapping<Input extends 'null'> = (null);
+export declare function WithNullMapping(input: 'null'): unknown;
+export type TWithUndefinedMapping<Input extends 'undefined'> = undefined;
+export declare function WithUndefinedMapping(input: 'undefined'): unknown;
+export type TWithPropertyMapping<Input extends [unknown, unknown, unknown]> = (Input extends [infer Key extends string, ':', infer Value extends unknown] ? {
     [_ in Key]: Value;
 } : never);
-export declare function JsonPropertyMapping(input: [unknown, unknown, unknown]): unknown;
-export type TJsonPropertyListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function JsonPropertyListMapping(input: [unknown, unknown]): unknown;
-type TJsonObjectMappingReduce<PropertyList extends Record<PropertyKey, unknown>[], Result extends Record<PropertyKey, unknown> = {}> = (PropertyList extends [infer Left extends Record<PropertyKey, unknown>, ...infer Right extends Record<PropertyKey, unknown>[]] ? TJsonObjectMappingReduce<Right, Memory.TAssign<Result, Left>> : {
+export declare function WithPropertyMapping(input: [unknown, unknown, unknown]): unknown;
+export type TWithPropertyListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
+export declare function WithPropertyListMapping(input: [unknown, unknown]): unknown;
+type TWithObjectMappingReduce<PropertyList extends Record<PropertyKey, unknown>[], Result extends Record<PropertyKey, unknown> = {}> = (PropertyList extends [infer Left extends Record<PropertyKey, unknown>, ...infer Right extends Record<PropertyKey, unknown>[]] ? TWithObjectMappingReduce<Right, Memory.TAssign<Result, Left>> : {
     [Key in keyof Result]: Result[Key];
 });
-export type TJsonObjectMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['{', infer PropertyList extends Record<PropertyKey, unknown>[], '}'] ? TJsonObjectMappingReduce<PropertyList> : {});
-export declare function JsonObjectMapping(input: [unknown, unknown, unknown]): unknown;
-export type TJsonElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function JsonElementListMapping(input: [unknown, unknown]): unknown;
-export type TJsonArrayMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Elements extends unknown[], ']'] ? Elements : never);
-export declare function JsonArrayMapping(input: [unknown, unknown, unknown]): unknown;
-export type TJsonMapping<Input extends unknown> = (Input);
-export declare function JsonMapping(input: unknown): unknown;
+export type TWithObjectMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['{', infer PropertyList extends Record<PropertyKey, unknown>[], '}'] ? TWithObjectMappingReduce<PropertyList> : {});
+export declare function WithObjectMapping(input: [unknown, unknown, unknown]): unknown;
+export type TWithElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
+export declare function WithElementListMapping(input: [unknown, unknown]): unknown;
+export type TWithArrayMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Elements extends unknown[], ']'] ? Elements : never);
+export declare function WithArrayMapping(input: [unknown, unknown, unknown]): unknown;
+export type TWithValueMapping<Input extends unknown> = (Input);
+export declare function WithValueMapping(input: unknown): unknown;
 export type TPatternBigIntMapping<Input extends '-?(?:0|[1-9][0-9]*)n'> = (T.TBigInt);
 export declare function PatternBigIntMapping(input: '-?(?:0|[1-9][0-9]*)n'): unknown;
 export type TPatternStringMapping<Input extends '.*'> = (T.TString);
 export declare function PatternStringMapping(input: '.*'): unknown;
-export type TPatternNumberMapping<Input extends '-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?'> = (T.TNumber);
-export declare function PatternNumberMapping(input: '-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?'): unknown;
+export type TPatternNumberMapping<Input extends '-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?'> = (T.TNumber);
+export declare function PatternNumberMapping(input: '-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?'): unknown;
 export type TPatternIntegerMapping<Input extends '-?(?:0|[1-9][0-9]*)'> = (T.TInteger);
 export declare function PatternIntegerMapping(input: '-?(?:0|[1-9][0-9]*)'): unknown;
 export type TPatternNeverMapping<Input extends '(?!)'> = (T.TNever);
@@ -338,11 +323,11 @@ export declare function InterfaceDeclarationHeritageListMapping(input: [unknown,
 export type TInterfaceDeclarationHeritageMapping<Input extends [unknown, unknown] | []> = (Input extends ['extends', infer Heritage extends T.TSchema[]] ? Heritage : []);
 export declare function InterfaceDeclarationHeritageMapping(input: [unknown, unknown] | []): unknown;
 export type TInterfaceDeclarationGenericMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['interface', infer Name extends string, infer Parameters extends T.TParameter[], infer Heritage extends T.TSchema[], infer Properties extends [T.TProperties, T.TProperties]] ? {
-    [_ in Name]: T.TGeneric<Parameters, C.TInterfaceDeferred<Heritage, Properties[0]>>;
+    [_ in Name]: T.TGeneric<Parameters, S.TInterfaceDeferred<Heritage, Properties[0]>>;
 } : never);
 export declare function InterfaceDeclarationGenericMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TInterfaceDeclarationMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends ['interface', infer Name extends string, infer Heritage extends T.TSchema[], infer Properties extends [T.TProperties, T.TProperties]] ? {
-    [_ in Name]: C.TInterfaceDeferred<Heritage, Properties[0]>;
+    [_ in Name]: S.TInterfaceDeferred<Heritage, Properties[0]>;
 } : never);
 export declare function InterfaceDeclarationMapping(input: [unknown, unknown, unknown, unknown]): unknown;
 export type TTypeAliasDeclarationGenericMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['type', infer Name extends string, infer Parameters extends T.TParameter[], '=', infer Type extends T.TSchema] ? {
@@ -361,7 +346,7 @@ export type TModuleDeclarationListMapping<Input extends [unknown, unknown]> = (T
 export declare function ModuleDeclarationListMapping(input: [unknown, unknown]): unknown;
 export type TModuleDeclarationMapping<Input extends [unknown, unknown, unknown]> = (Input extends [null, infer ModuleDeclaration extends T.TProperties, null] ? ModuleDeclaration : never);
 export declare function ModuleDeclarationMapping(input: [unknown, unknown, unknown]): unknown;
-export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends [T.TProperties, T.TProperties]] ? C.TModuleDeferred<Memory.TAssign<ModuleDeclaration, ModuleDeclarationList[0]>> : never);
+export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends [T.TProperties, T.TProperties]] ? S.TModuleDeferred<Memory.TAssign<ModuleDeclaration, ModuleDeclarationList[0]>> : never);
 export declare function ModuleMapping(input: [unknown, unknown]): unknown;
 export type TScriptMapping<Input extends unknown> = (Input);
 export declare function ScriptMapping(input: unknown): unknown;