typebox 1.1.39 → 1.2.0

package/build/guard/guard.d.mts

@@ -59,9 +59,9 @@ export declare function HasPropertyKey<Key extends PropertyKey>(value: object, k
 export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
 /** Returns object entries as `[string, Value][]` */
 export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
 export declare function Keys(value: Record<PropertyKey, unknown>): string[];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
 export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
 /** Returns the property values for the given object via `Object.values()` */
 export declare function Values(value: Record<PropertyKey, unknown>): unknown[];

package/build/guard/guard.mjs

@@ -185,11 +185,11 @@ export function EntriesRegExp(value) {
 export function Entries(value) {
     return Object.entries(value);
 }
-/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
 export function Keys(value) {
     return Object.getOwnPropertyNames(value);
 }
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
 export function Symbols(value) {
     return Object.getOwnPropertySymbols(value);
 }

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

@@ -16,7 +16,6 @@ export * from './mapped.mjs';
 export * from './module.mjs';
 export * from './non_nullable.mjs';
 export * from './omit.mjs';
-export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
@@ -25,3 +24,4 @@ export * from './required.mjs';
 export * from './return_type.mjs';
 export * from './uncapitalize.mjs';
 export * from './uppercase.mjs';
+export * from './with.mjs';

package/build/type/action/index.mjs

@@ -16,7 +16,6 @@ export * from './mapped.mjs';
 export * from './module.mjs';
 export * from './non_nullable.mjs';
 export * from './omit.mjs';
-export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
@@ -25,3 +24,4 @@ export * from './required.mjs';
 export * from './return_type.mjs';
 export * from './uncapitalize.mjs';
 export * from './uppercase.mjs';
+export * from './with.mjs';

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

@@ -0,0 +1,21 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TWithAction } from '../engine/with/instantiate.mjs';
+/** Creates a deferred With action. */
+export type TWithDeferred<Type extends TSchema, Options extends TSchema> = (TDeferred<'With', [Type, Options]>);
+/** Creates a deferred With action. */
+export declare function WithDeferred<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TWithDeferred<Type, Options>;
+/** Applies annotation options to the given type. */
+export type TWith<Type extends TSchema, Options extends TSchema> = (Type & Options);
+/** Applies annotation options to the given type. */
+export declare function With<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TWithAction<Type, Options>;
+/**
+ * @deprecated Type.TOptions\<T\> has been renamed to Type.TWith\<T\>. This type will be removed in the
+ * next version of TypeBox.
+ */
+export type TOptions<Type extends TSchema, Options extends TSchema> = TWith<Type, Options>;
+/**
+ * @deprecated Type.Options\<T\> has been renamed to Type.With\<T\>. This type will be removed in the
+ * next version of TypeBox.
+ */
+export declare function Options<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TOptions<Type, Options>;

package/build/type/action/with.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { WithAction } from '../engine/with/instantiate.mjs';
+/** Creates a deferred With action. */
+export function WithDeferred(type, options) {
+    return Deferred('With', [type, options], {});
+}
+/** Applies annotation options to the given type. */
+export function With(type, options) {
+    return WithAction(type, options);
+}
+/**
+ * @deprecated Type.Options\<T\> has been renamed to Type.With\<T\>. This type will be removed in the
+ * next version of TypeBox.
+ */
+export function Options(type, options) {
+    return With(type, options);
+}
+// deno-coverage-ignore-stop

package/build/type/engine/enum/index.d.mts

@@ -1,2 +1 @@
-export * from './enum_to_union.mjs';
 export * from './typescript_enum_to_enum_values.mjs';

package/build/type/engine/enum/index.mjs

@@ -1,2 +1 @@
-export * from './enum_to_union.mjs';
 export * from './typescript_enum_to_enum_values.mjs';

package/build/type/engine/evaluate/evaluate.d.mts

@@ -1,14 +1,26 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
 import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TNever } from '../../types/never.mjs';
+import { type TExcludeOperation } from '../exclude/operation.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
+export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersect extends TSchema = TIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersect, Excluded]>> = Result;
+export declare function EvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TEvaluateDependent<If, Then, Else>;
+export type TEvaluateEnum<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEvaluateEnum<Right, [...Result, TLiteral<Left>]> : TEvaluateUnion<Result>);
+export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values]): TEvaluateEnum<Values>;
 export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
 export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
+export type TEvaluateTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TEvaluateType<Evaluated>> = Result;
+export declare function EvaluateTemplateLiteral<Pattern extends string>(pattern: Pattern): TEvaluateTemplateLiteral<Pattern>;
 export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
 export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
-export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
+export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TEvaluateDependent<If, Then, Else> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
 export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
 export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
 export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;

package/build/type/engine/evaluate/evaluate.mjs

@@ -1,23 +1,47 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsIntersect } from '../../types/intersect.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { Literal } from '../../types/literal.mjs';
+import { IsIntersect, Intersect } from '../../types/intersect.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
-import { Union, IsUnion } from '../../types/union.mjs';
-import { Never } from '../../types/never.mjs';
+import { ExcludeOperation } from '../exclude/operation.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+export function EvaluateDependent(if_, then_, else_) {
+    const intersect = Intersect([if_, then_]);
+    const excluded = ExcludeOperation(else_, if_);
+    const result = EvaluateUnion([intersect, excluded]);
+    return result;
+}
+export function EvaluateEnum(values) {
+    const result = values.map(value => Literal(value));
+    return EvaluateUnion(result);
+}
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
     const result = Broaden(distribution);
     return result;
 }
+export function EvaluateTemplateLiteral(pattern) {
+    const evaluated = TemplateLiteralDecode(pattern);
+    const result = EvaluateType(evaluated);
+    return result;
+}
 export function EvaluateUnion(types) {
     const result = Broaden(types);
     return result;
 }
 export function EvaluateType(type) {
-    return (IsIntersect(type) ? EvaluateIntersect(type.allOf) :
-        IsUnion(type) ? EvaluateUnion(type.anyOf) :
-            type);
+    return (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
+        IsEnum(type) ? EvaluateEnum(type.enum) :
+            IsIntersect(type) ? EvaluateIntersect(type.allOf) :
+                IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
+                    IsUnion(type) ? EvaluateUnion(type.anyOf) :
+                        type);
 }
 export function EvaluateUnionFast(types) {
     const result = (Guard.IsEqual(types.length, 1) ? types[0] :

package/build/type/engine/exclude/operation.d.mts

@@ -1,11 +1,10 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
-type TExcludeUnionLeft<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnionLeft<Tail, Right, [...Result, ...TExcludeTypeLeft<Head, Right>]> : Result);
-type TExcludeTypeLeft<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
-export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnionLeft<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnionLeft<TFlatten<Types>, Right> : TExcludeTypeLeft<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [] : [Left]> = Result;
+type TExcludeUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
+export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExcludeUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExcludeOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExcludeOperation<Left, Right>;
 export {};

package/build/type/engine/exclude/operation.mjs

@@ -1,24 +1,23 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
-import { IsEnum } from '../../types/enum.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
-function ExcludeUnionLeft(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeTypeLeft(head, right)];
-    }, []);
-}
-function ExcludeTypeLeft(left, right) {
+import { EvaluateType } from '../evaluate/evaluate.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+function ExcludeType(left, right) {
     const check = Extends({}, left, right);
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
     return result;
 }
+function ExcludeUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExcludeType(head, right)];
+    }, []);
+}
 export function ExcludeOperation(left, right) {
-    const remaining = (IsEnum(left) ? ExcludeUnionLeft(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExcludeUnionLeft(Flatten(left.anyOf), right) :
-            ExcludeTypeLeft(left, right));
+    const evaluated = EvaluateType(left);
+    const canonical = IsUnion(evaluated) ? evaluated.anyOf : [evaluated];
+    const remaining = ExcludeUnion(canonical, right);
     const result = EvaluateUnion(remaining);
     return result;
 }

package/build/type/engine/extract/operation.d.mts

@@ -1,11 +1,10 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
-type TExtractUnionLeft<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnionLeft<Tail, Right, [...Result, ...TExtractTypeLeft<Head, Right>]> : Result);
-type TExtractTypeLeft<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
-export type TExtractOperation<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnionLeft<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnionLeft<TFlatten<Types>, Right> : TExtractTypeLeft<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
+type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
 export {};

package/build/type/engine/extract/operation.mjs

@@ -1,24 +1,23 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
-import { IsEnum } from '../../types/enum.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
-function ExtractUnionLeft(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractTypeLeft(head, right)];
-    }, []);
-}
-function ExtractTypeLeft(left, right) {
+import { EvaluateType } from '../evaluate/evaluate.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+function ExtractType(left, right) {
     const check = Extends({}, left, right);
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
     return result;
 }
+function ExtractUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExtractType(head, right)];
+    }, []);
+}
 export function ExtractOperation(left, right) {
-    const remaining = (IsEnum(left) ? ExtractUnionLeft(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExtractUnionLeft(Flatten(left.anyOf), right) :
-            ExtractTypeLeft(left, right));
+    const evaluated = EvaluateType(left);
+    const canonical = IsUnion(evaluated) ? evaluated.anyOf : [evaluated];
+    const remaining = ExtractUnion(canonical, right);
     const result = EvaluateUnion(remaining);
     return result;
 }

package/build/type/engine/index.d.mts

@@ -18,7 +18,6 @@ export * from './module/index.mjs';
 export * from './non_nullable/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './options/index.mjs';
 export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
@@ -29,3 +28,4 @@ export * from './ref/index.mjs';
 export * from './required/index.mjs';
 export * from './return_type/index.mjs';
 export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

package/build/type/engine/index.mjs

@@ -24,7 +24,6 @@ export * from './module/index.mjs';
 export * from './non_nullable/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './options/index.mjs';
 export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
@@ -35,3 +34,4 @@ export * from './ref/index.mjs';
 export * from './required/index.mjs';
 export * from './return_type/index.mjs';
 export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

package/build/type/engine/indexable/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/build/type/engine/indexable/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/indexable/from_enum.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TEnumValue } from '../../types/enum.mjs';
-import { type TEnumValuesToVariants } from '../enum/enum_to_union.mjs';
-import { type TFromUnion } from './from_union.mjs';
-export type TFromEnum<Values extends TEnumValue[], Variants extends TSchema[] = TEnumValuesToVariants<Values>, Result extends string[] = TFromUnion<Variants>> = Result;
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+export type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends string[] = TFromType<Evaluated>> = Result;
 export declare function FromEnum<Values extends TEnumValue[]>(values: [...Values]): TFromEnum<Values>;

package/build/type/engine/indexable/from_enum.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { EnumValuesToVariants } from '../enum/enum_to_union.mjs';
-import { FromUnion } from './from_union.mjs';
+import { FromType } from './from_type.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
 export function FromEnum(values) {
-    const variants = EnumValuesToVariants(values);
-    const result = FromUnion(variants);
+    const evaluated = EvaluateEnum(values);
+    const result = FromType(evaluated);
     return result;
 }

package/build/type/engine/indexable/from_template_literal.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { type TFromType } from './from_type.mjs';
-export type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends string[] = TFromType<Decoded>> = Result;
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+export type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends string[] = TFromType<Evaluated>> = Result;
 export declare function FromTemplateLiteral<Pattern extends string>(pattern: Pattern): TFromTemplateLiteral<Pattern>;

package/build/type/engine/indexable/from_template_literal.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { FromType } from './from_type.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 export function FromTemplateLiteral(pattern) {
-    const decoded = TemplateLiteralDecode(pattern);
-    const result = FromType(decoded);
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(evaluated);
     return result;
 }

package/build/type/engine/indexable/from_type.d.mts

@@ -1,5 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
@@ -7,11 +8,12 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromEnum } from './from_enum.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromLiteral } from './from_literal.mjs';
 import { type TFromTemplateLiteral } from './from_template_literal.mjs';
 import { type TFromUnion } from './from_union.mjs';
-export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
 ])> = Result;
 export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;

package/build/type/engine/indexable/from_type.mjs

@@ -1,11 +1,13 @@
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromEnum } from './from_enum.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromLiteral } from './from_literal.mjs';
@@ -13,10 +15,11 @@ import { FromTemplateLiteral } from './from_template_literal.mjs';
 import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsEnum(type) ? FromEnum(type.enum) :
-            IsIntersect(type) ? FromIntersect(type.allOf) :
-                IsLiteral(type) ? FromLiteral(type.const) :
-                    IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
-                        IsUnion(type) ? FromUnion(type.anyOf) :
-                            []);
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsEnum(type) ? FromEnum(type.enum) :
+                IsIntersect(type) ? FromIntersect(type.allOf) :
+                    IsLiteral(type) ? FromLiteral(type.const) :
+                        IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
+                            IsUnion(type) ? FromUnion(type.anyOf) :
+                                []);
 }

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

@@ -1,5 +1,6 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
@@ -7,7 +8,7 @@ import { type TState, type TInstantiateType, type TCanInstantiate } from '../ins
 import { type TIndexDeferred } from '../../action/indexed.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
 import { type TFromType } from './from_type.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TDependent | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
 export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
 export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;

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

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
@@ -8,7 +9,7 @@ import { IndexDeferred } from '../../action/indexed.mjs';
 import { CollapseToObject } from '../object/index.mjs';
 import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
+    const result = (IsCyclic(type) || IsDependent(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
         type);
     return result;
 }

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

@@ -9,6 +9,7 @@ import { type TDeferred } from '../types/deferred.mjs';
 import { type TFunction } from '../types/function.mjs';
 import { type TCall } from '../types/call.mjs';
 import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDependent } from '../types/dependent.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
 import { type TIterator } from '../types/iterator.mjs';
 import { type TObject } from '../types/object.mjs';
@@ -38,7 +39,6 @@ import { type TMappedInstantiate } from './mapped/instantiate.mjs';
 import { type TModuleInstantiate } from './module/instantiate.mjs';
 import { type TNonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { type TOmitInstantiate } from './omit/instantiate.mjs';
-import { type TOptionsInstantiate } from './options/instantiate.mjs';
 import { type TParametersInstantiate } from './parameters/instantiate.mjs';
 import { type TPartialInstantiate } from './partial/instantiate.mjs';
 import { type TPickInstantiate } from './pick/instantiate.mjs';
@@ -50,6 +50,7 @@ import { type TReturnTypeInstantiate } from './return_type/instantiate.mjs';
 import { type TTemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
 import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TWithInstantiate } from './with/instantiate.mjs';
 import { type TRestSpread } from './rest/index.mjs';
 export interface TState {
     callstack: string[];
@@ -123,9 +124,6 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
     Action,
     Parameters
-] extends ['Options', [infer Type extends TSchema, infer Options extends TSchema]] ? TOptionsInstantiate<Context, State, Type, Options> : [
-    Action,
-    Parameters
 ] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
     Action,
     Parameters
@@ -153,8 +151,11 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
     Action,
     Parameters
-] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
-export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, Immutable extends boolean = Input extends TImmutable ? true : false, Modifiers extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = Modifiers[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = Immutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<Modifiers[1], TApplyOptional<Modifiers[2], WithImmutable>>> = WithModifiers;
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
+export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, Immutable extends boolean = Input extends TImmutable ? true : false, Modifiers extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = Modifiers[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = Immutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<Modifiers[1], TApplyOptional<Modifiers[2], WithImmutable>>> = WithModifiers;
 export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
 /** Instantiates computed schematics using the given context and type. */
 export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {