typebox 1.0.31 → 1.0.33

package/build/cjs/type/engine/instantiate.js

@@ -0,0 +1,173 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanInstantiate = CanInstantiate;
+exports.InstantiateProperties = InstantiateProperties;
+exports.InstantiateElements = InstantiateElements;
+exports.InstantiateTypes = InstantiateTypes;
+exports.InstantiateType = InstantiateType;
+exports.Instantiate = Instantiate;
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+const _optional_1 = require("../types/_optional");
+const _readonly_1 = require("../types/_readonly");
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+const schema_1 = require("../types/schema");
+const array_1 = require("../types/array");
+const async_iterator_1 = require("../types/async-iterator");
+const constructor_1 = require("../types/constructor");
+const deferred_1 = require("../types/deferred");
+const function_1 = require("../types/function");
+const call_1 = require("../types/call");
+const intersect_1 = require("../types/intersect");
+const iterator_1 = require("../types/iterator");
+const object_1 = require("../types/object");
+const promise_1 = require("../types/promise");
+const record_1 = require("../types/record");
+const tuple_1 = require("../types/tuple");
+const union_1 = require("../types/union");
+const ref_1 = require("../types/ref");
+const rest_1 = require("../types/rest");
+// ------------------------------------------------------------------
+// Modifier Actions
+// ------------------------------------------------------------------
+const _readonly_2 = require("../action/_readonly");
+const _optional_2 = require("../action/_optional");
+// ------------------------------------------------------------------
+// Instantiate
+// ------------------------------------------------------------------
+const instantiate_1 = require("./awaited/instantiate");
+const instantiate_2 = require("./call/instantiate");
+const instantiate_3 = require("./intrinsics/instantiate");
+const index_2 = require("./conditional/index");
+const instantiate_4 = require("./constructor-parameters/instantiate");
+const instantiate_5 = require("./evaluate/instantiate");
+const instantiate_6 = require("./exclude/instantiate");
+const instantiate_7 = require("./extract/instantiate");
+const instantiate_8 = require("./indexed/instantiate");
+const instantiate_9 = require("./instance-type/instantiate");
+const instantiate_10 = require("./interface/instantiate");
+const instantiate_11 = require("./keyof/instantiate");
+const instantiate_12 = require("./intrinsics/instantiate");
+const instantiate_13 = require("./mapped/instantiate");
+const instantiate_14 = require("./module/instantiate");
+const instantiate_15 = require("./non-nullable/instantiate");
+const instantiate_16 = require("./omit/instantiate");
+const instantiate_17 = require("./options/instantiate");
+const instantiate_18 = require("./parameters/instantiate");
+const instantiate_19 = require("./partial/instantiate");
+const instantiate_20 = require("./pick/instantiate");
+const instantiate_21 = require("./record/instantiate");
+const instantiate_22 = require("./ref/instantiate");
+const instantiate_23 = require("./required/instantiate");
+const instantiate_24 = require("./return-type/instantiate");
+const instantiate_25 = require("./template-literal/instantiate");
+const instantiate_26 = require("./intrinsics/instantiate");
+const instantiate_27 = require("./intrinsics/instantiate");
+const index_3 = require("./rest/index");
+function CanInstantiateRef(context, ref) {
+    return (ref in context);
+}
+function CanInstantiateType(context, type) {
+    return ((0, intersect_1.IsIntersect)(type) ? CanInstantiate(context, type.allOf) :
+        (0, union_1.IsUnion)(type) ? CanInstantiate(context, type.anyOf) :
+            (0, ref_1.IsRef)(type) ? CanInstantiateRef(context, type.$ref) :
+                true);
+}
+function CanInstantiate(context, types) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? CanInstantiateType(context, left)
+            ? CanInstantiate(context, right)
+            : false
+        : true);
+}
+function ModifierActions(type, readonly, optional) {
+    return ((0, _readonly_2.IsReadonlyRemoveAction)(type) ? ModifierActions(type.type, 'remove', optional) :
+        (0, _optional_2.IsOptionalRemoveAction)(type) ? ModifierActions(type.type, readonly, 'remove') :
+            (0, _readonly_2.IsReadonlyAddAction)(type) ? ModifierActions(type.type, 'add', optional) :
+                (0, _optional_2.IsOptionalAddAction)(type) ? ModifierActions(type.type, readonly, 'add') :
+                    [type, readonly, optional]);
+}
+function ApplyReadonly(action, type) {
+    return (index_1.Guard.IsEqual(action, 'remove') ? (0, _readonly_1.ReadonlyRemove)(type) :
+        index_1.Guard.IsEqual(action, 'add') ? (0, _readonly_1.ReadonlyAdd)(type) :
+            type);
+}
+function ApplyOptional(action, type) {
+    return (index_1.Guard.IsEqual(action, 'remove') ? (0, _optional_1.OptionalRemove)(type) :
+        index_1.Guard.IsEqual(action, 'add') ? (0, _optional_1.OptionalAdd)(type) :
+            type);
+}
+function InstantiateProperties(context, state, properties) {
+    return index_1.Guard.Keys(properties).reduce((result, key) => {
+        return { ...result, [key]: InstantiateType(context, state, properties[key]) };
+    }, {});
+}
+function InstantiateElements(context, state, types) {
+    const elements = InstantiateTypes(context, state, types);
+    const result = (0, index_3.RestSpread)(elements);
+    return result;
+}
+function InstantiateTypes(context, state, types) {
+    return types.map(type => InstantiateType(context, state, type));
+}
+function InstantiateDeferred(context, state, action, parameters, options) {
+    return (index_1.Guard.IsEqual(action, 'Awaited') ? (0, instantiate_1.AwaitedInstantiate)(context, state, parameters[0], options) :
+        index_1.Guard.IsEqual(action, 'Capitalize') ? (0, instantiate_3.CapitalizeInstantiate)(context, state, parameters[0], options) :
+            index_1.Guard.IsEqual(action, 'Conditional') ? (0, index_2.ConditionalInstantiate)(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                index_1.Guard.IsEqual(action, 'ConstructorParameters') ? (0, instantiate_4.ConstructorParametersInstantiate)(context, state, parameters[0], options) :
+                    index_1.Guard.IsEqual(action, 'Evaluate') ? (0, instantiate_5.EvaluateInstantiate)(context, state, parameters[0], options) :
+                        index_1.Guard.IsEqual(action, 'Exclude') ? (0, instantiate_6.ExcludeInstantiate)(context, state, parameters[0], parameters[1], options) :
+                            index_1.Guard.IsEqual(action, 'Extract') ? (0, instantiate_7.ExtractInstantiate)(context, state, parameters[0], parameters[1], options) :
+                                index_1.Guard.IsEqual(action, 'Index') ? (0, instantiate_8.IndexInstantiate)(context, state, parameters[0], parameters[1], options) :
+                                    index_1.Guard.IsEqual(action, 'InstanceType') ? (0, instantiate_9.InstanceTypeInstantiate)(context, state, parameters[0], options) :
+                                        index_1.Guard.IsEqual(action, 'Interface') ? (0, instantiate_10.InterfaceInstantiate)(context, state, parameters[0], parameters[1], options) :
+                                            index_1.Guard.IsEqual(action, 'KeyOf') ? (0, instantiate_11.KeyOfInstantiate)(context, state, parameters[0], options) :
+                                                index_1.Guard.IsEqual(action, 'Lowercase') ? (0, instantiate_12.LowercaseInstantiate)(context, state, parameters[0], options) :
+                                                    index_1.Guard.IsEqual(action, 'Mapped') ? (0, instantiate_13.MappedInstantiate)(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                                        index_1.Guard.IsEqual(action, 'Module') ? (0, instantiate_14.ModuleInstantiate)(context, state, parameters[0], options) :
+                                                            index_1.Guard.IsEqual(action, 'NonNullable') ? (0, instantiate_15.NonNullableInstantiate)(context, state, parameters[0], options) :
+                                                                index_1.Guard.IsEqual(action, 'Pick') ? (0, instantiate_20.PickInstantiate)(context, state, parameters[0], parameters[1], options) :
+                                                                    index_1.Guard.IsEqual(action, 'Options') ? (0, instantiate_17.OptionsInstantiate)(context, state, parameters[0], parameters[1]) :
+                                                                        index_1.Guard.IsEqual(action, 'Parameters') ? (0, instantiate_18.ParametersInstantiate)(context, state, parameters[0], options) :
+                                                                            index_1.Guard.IsEqual(action, 'Partial') ? (0, instantiate_19.PartialInstantiate)(context, state, parameters[0], options) :
+                                                                                index_1.Guard.IsEqual(action, 'Omit') ? (0, instantiate_16.OmitInstantiate)(context, state, parameters[0], parameters[1], options) :
+                                                                                    index_1.Guard.IsEqual(action, 'Record') ? (0, instantiate_21.RecordInstantiate)(context, state, parameters[0], parameters[1], options) :
+                                                                                        index_1.Guard.IsEqual(action, 'Required') ? (0, instantiate_23.RequiredInstantiate)(context, state, parameters[0], options) :
+                                                                                            index_1.Guard.IsEqual(action, 'ReturnType') ? (0, instantiate_24.ReturnTypeInstantiate)(context, state, parameters[0], options) :
+                                                                                                index_1.Guard.IsEqual(action, 'TemplateLiteral') ? (0, instantiate_25.TemplateLiteralInstantiate)(context, state, parameters[0], options) :
+                                                                                                    index_1.Guard.IsEqual(action, 'Uncapitalize') ? (0, instantiate_26.UncapitalizeInstantiate)(context, state, parameters[0], options) :
+                                                                                                        index_1.Guard.IsEqual(action, 'Uppercase') ? (0, instantiate_27.UppercaseInstantiate)(context, state, parameters[0], options) :
+                                                                                                            (0, deferred_1.Deferred)(action, parameters, options));
+}
+function InstantiateType(context, state, input) {
+    const modifierActions = ModifierActions(input, (0, _readonly_1.IsReadonly)(input) ? 'add' : 'none', (0, _optional_1.IsOptional)(input) ? 'add' : 'none');
+    const type = modifierActions[0];
+    const instantiated = ((0, ref_1.IsRef)(type) ? (0, instantiate_22.RefInstantiate)(context, state, type.$ref) :
+        (0, array_1.IsArray)(type) ? (0, array_1.Array)(InstantiateType(context, state, type.items), (0, array_1.ArrayOptions)(type)) :
+            (0, async_iterator_1.IsAsyncIterator)(type) ? (0, async_iterator_1.AsyncIterator)(InstantiateType(context, state, type.iteratorItems), (0, async_iterator_1.AsyncIteratorOptions)(type)) :
+                (0, call_1.IsCall)(type) ? (0, instantiate_2.CallInstantiate)(context, state, type.target, type.arguments) :
+                    (0, constructor_1.IsConstructor)(type) ? (0, constructor_1.Constructor)(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), (0, constructor_1.ConstructorOptions)(type)) :
+                        (0, deferred_1.IsDeferred)(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) :
+                            (0, function_1.IsFunction)(type) ? (0, function_1.Function)(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), (0, function_1.FunctionOptions)(type)) :
+                                (0, intersect_1.IsIntersect)(type) ? (0, intersect_1.Intersect)(InstantiateTypes(context, state, type.allOf), (0, intersect_1.IntersectOptions)(type)) :
+                                    (0, iterator_1.IsIterator)(type) ? (0, iterator_1.Iterator)(InstantiateType(context, state, type.iteratorItems), (0, iterator_1.IteratorOptions)(type)) :
+                                        (0, object_1.IsObject)(type) ? (0, object_1.Object)(InstantiateProperties(context, state, type.properties), (0, object_1.ObjectOptions)(type)) :
+                                            (0, promise_1.IsPromise)(type) ? (0, promise_1.Promise)(InstantiateType(context, state, type.item), (0, promise_1.PromiseOptions)(type)) :
+                                                (0, record_1.IsRecord)(type) ? (0, record_1.RecordFromPattern)((0, record_1.RecordPattern)(type), InstantiateType(context, state, (0, record_1.RecordValue)(type))) :
+                                                    (0, rest_1.IsRest)(type) ? (0, rest_1.Rest)(InstantiateType(context, state, type.items)) :
+                                                        (0, tuple_1.IsTuple)(type) ? (0, tuple_1.Tuple)(InstantiateElements(context, state, type.items), (0, tuple_1.TupleOptions)(type)) :
+                                                            (0, union_1.IsUnion)(type) ? (0, union_1.Union)(InstantiateTypes(context, state, type.anyOf), (0, union_1.UnionOptions)(type)) :
+                                                                type);
+    return ApplyReadonly(modifierActions[1], ApplyOptional(modifierActions[2], instantiated));
+}
+/** Instantiates computed schematics using the given context and type. */
+function Instantiate(context, type) {
+    return InstantiateType(context, { callstack: [] }, type);
+}

package/build/cjs/type/engine/interface/index.d.ts

@@ -0,0 +1 @@
+export * from './instantiate';

package/build/cjs/type/engine/interface/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instantiate"), exports);

package/build/cjs/type/engine/interface/instantiate.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TObject } from '../../types/object';
+import { type TEvaluateIntersect } from '../evaluate/evaluate';
+import { type TInterfaceDeferred } from '../../action/index';
+import { type TState, type TCanInstantiate } from '../instantiate';
+import { type TInstantiateProperties } from '../instantiate';
+import { type TInstantiateTypes } from '../instantiate';
+type TInterfaceImmediate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
+    callstack: [];
+}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<Context, {
+    callstack: [];
+}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties> = TCanInstantiate<Context, Heritage> extends true ? TInterfaceImmediate<Context, State, Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>;
+export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
+export {};

package/build/cjs/type/engine/interface/instantiate.js

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceInstantiate = InterfaceInstantiate;
+const index_1 = require("../../../system/memory/index");
+const object_1 = require("../../types/object");
+const evaluate_1 = require("../evaluate/evaluate");
+const index_2 = require("../../action/index");
+const instantiate_1 = require("../instantiate");
+const instantiate_2 = require("../instantiate");
+const instantiate_3 = require("../instantiate");
+function InterfaceImmediate(context, state, heritage, properties, options) {
+    const instantiatedHeritage = (0, instantiate_3.InstantiateTypes)(context, { callstack: [] }, heritage);
+    const instantiatedProperties = (0, instantiate_2.InstantiateProperties)(context, { callstack: [] }, properties);
+    const evaluatedInterface = (0, evaluate_1.EvaluateIntersect)([...instantiatedHeritage, (0, object_1.Object)(instantiatedProperties)]);
+    return index_1.Memory.Update(evaluatedInterface, {}, options);
+}
+function InterfaceInstantiate(context, state, heritage, properties, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, heritage)
+        ? InterfaceImmediate(context, state, heritage, properties, options)
+        : (0, index_2.InterfaceDeferred)(heritage, properties, options));
+}

package/build/cjs/type/engine/intrinsics/from-literal.d.ts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TMappingType, type TMappingFunc, type TApplyMapping } from './mapping';
+export type TFromLiteral<Mapping extends TMappingType, Value extends TLiteralValue> = (Value extends string ? TLiteral<TApplyMapping<Mapping, Value>> : TLiteral<Value>);
+export declare function FromLiteral(mapping: TMappingFunc, value: TLiteralValue): TSchema;

package/build/cjs/type/engine/intrinsics/from-literal.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromLiteral = FromLiteral;
+const index_1 = require("../../../guard/index");
+const literal_1 = require("../../types/literal");
+const mapping_1 = require("./mapping");
+function FromLiteral(mapping, value) {
+    return (index_1.Guard.IsString(value)
+        ? (0, literal_1.Literal)((0, mapping_1.ApplyMapping)(mapping, value))
+        : (0, literal_1.Literal)(value));
+}

package/build/cjs/type/engine/intrinsics/from-template-literal.d.ts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema';
+import { type TMappingType, type TMappingFunc } from './mapping';
+import { type TTemplateLiteralDecode } from '../template-literal/decode';
+import { type TFromType } from './from-type';
+export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Mapping, Decoded>> = Result;
+export declare function FromTemplateLiteral(mapping: TMappingFunc, pattern: string): TSchema;

package/build/cjs/type/engine/intrinsics/from-template-literal.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTemplateLiteral = FromTemplateLiteral;
+const decode_1 = require("../template-literal/decode");
+const from_type_1 = require("./from-type");
+function FromTemplateLiteral(mapping, pattern) {
+    const decoded = (0, decode_1.TemplateLiteralDecode)(pattern);
+    const result = (0, from_type_1.FromType)(mapping, decoded);
+    return result;
+}

package/build/cjs/type/engine/intrinsics/from-type.d.ts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TTemplateLiteral } from '../../types/template-literal';
+import { type TUnion } from '../../types/union';
+import { type TMappingType, type TMappingFunc } from './mapping';
+import { type TFromLiteral } from './from-literal';
+import { type TFromTemplateLiteral } from './from-template-literal';
+import { type TFromUnion } from './from-union';
+export type TFromType<Mapping extends TMappingType, Type extends TSchema> = (Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Mapping, Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Mapping, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Mapping, Types> : Type);
+export declare function FromType(mapping: TMappingFunc, type: TSchema): TSchema;

package/build/cjs/type/engine/intrinsics/from-type.js

@@ -0,0 +1,16 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromType = FromType;
+const literal_1 = require("../../types/literal");
+const template_literal_1 = require("../../types/template-literal");
+const union_1 = require("../../types/union");
+const from_literal_1 = require("./from-literal");
+const from_template_literal_1 = require("./from-template-literal");
+const from_union_1 = require("./from-union");
+function FromType(mapping, type) {
+    return ((0, literal_1.IsLiteral)(type) ? (0, from_literal_1.FromLiteral)(mapping, type.const) :
+        (0, template_literal_1.IsTemplateLiteral)(type) ? (0, from_template_literal_1.FromTemplateLiteral)(mapping, type.pattern) :
+            (0, union_1.IsUnion)(type) ? (0, from_union_1.FromUnion)(mapping, type.anyOf) :
+                type);
+}

package/build/cjs/type/engine/intrinsics/from-union.d.ts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema';
+import { type TUnion } from '../../types/union';
+import { type TMappingType, type TMappingFunc } from './mapping';
+import { type TFromType } from './from-type';
+export type TFromUnion<Mapping extends TMappingType, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Mapping, Right, [...Result, TFromType<Mapping, Left>]> : TUnion<Result>);
+export declare function FromUnion(mapping: TMappingFunc, types: TSchema[]): TSchema;

package/build/cjs/type/engine/intrinsics/from-union.js

@@ -0,0 +1,10 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromUnion = FromUnion;
+const union_1 = require("../../types/union");
+const from_type_1 = require("./from-type");
+function FromUnion(mapping, types) {
+    const result = types.map(type => (0, from_type_1.FromType)(mapping, type));
+    return (0, union_1.Union)(result);
+}

package/build/cjs/type/engine/intrinsics/index.d.ts

@@ -0,0 +1 @@
+export * from './instantiate';

package/build/cjs/type/engine/intrinsics/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instantiate"), exports);

package/build/cjs/type/engine/intrinsics/instantiate.d.ts

@@ -0,0 +1,34 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TMappingType } from './mapping';
+import { type TFromType } from './from-type';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+import { type TCapitalizeDeferred } from '../../action/capitalize';
+import { type TLowercaseDeferred } from '../../action/lowercase';
+import { type TUncapitalizeDeferred } from '../../action/uncapitalize';
+import { type TUppercaseDeferred } from '../../action/uppercase';
+interface TCapitalizeMapping extends TMappingType {
+    output: Capitalize<this['input']>;
+}
+interface TLowercaseMapping extends TMappingType {
+    output: Lowercase<this['input']>;
+}
+interface TUncapitalizeMapping extends TMappingType {
+    output: Uncapitalize<this['input']>;
+}
+interface TUppercaseMapping extends TMappingType {
+    output: Uppercase<this['input']>;
+}
+type TCapitalizeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TCapitalizeMapping, InstantiatedType>;
+export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TCapitalizeImmediate<Context, State, Type> : TCapitalizeDeferred<Type>;
+export declare function CapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TCapitalizeInstantiate<Context, State, Type>;
+type TLowercaseImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TLowercaseMapping, InstantiatedType>;
+export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TLowercaseImmediate<Context, State, Type> : TLowercaseDeferred<Type>;
+export declare function LowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TLowercaseInstantiate<Context, State, Type>;
+type TUncapitalizeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TUncapitalizeMapping, InstantiatedType>;
+export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TUncapitalizeImmediate<Context, State, Type> : TUncapitalizeDeferred<Type>;
+export declare function UncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUncapitalizeInstantiate<Context, State, Type>;
+type TUppercaseImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TUppercaseMapping, InstantiatedType>;
+export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TUppercaseImmediate<Context, State, Type> : TUppercaseDeferred<Type>;
+export declare function UppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUppercaseInstantiate<Context, State, Type>;
+export {};

package/build/cjs/type/engine/intrinsics/instantiate.js

@@ -0,0 +1,54 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapitalizeInstantiate = CapitalizeInstantiate;
+exports.LowercaseInstantiate = LowercaseInstantiate;
+exports.UncapitalizeInstantiate = UncapitalizeInstantiate;
+exports.UppercaseInstantiate = UppercaseInstantiate;
+const index_1 = require("../../../system/memory/index");
+const from_type_1 = require("./from-type");
+const instantiate_1 = require("../instantiate");
+const capitalize_1 = require("../../action/capitalize");
+const lowercase_1 = require("../../action/lowercase");
+const uncapitalize_1 = require("../../action/uncapitalize");
+const uppercase_1 = require("../../action/uppercase");
+const CapitalizeMapping = (input) => input[0].toUpperCase() + input.slice(1);
+const LowercaseMapping = (input) => input.toLowerCase();
+const UncapitalizeMapping = (input) => input[0].toLowerCase() + input.slice(1);
+const UppercaseMapping = (input) => input.toUpperCase();
+function CapitalizeImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update((0, from_type_1.FromType)(CapitalizeMapping, instantiatedType), {}, options);
+}
+function CapitalizeInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? CapitalizeImmediate(context, state, type, options)
+        : (0, capitalize_1.CapitalizeDeferred)(type, options));
+}
+function LowercaseImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update((0, from_type_1.FromType)(LowercaseMapping, instantiatedType), {}, options);
+}
+function LowercaseInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? LowercaseImmediate(context, state, type, options)
+        : (0, lowercase_1.LowercaseDeferred)(type, options));
+}
+function UncapitalizeImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update((0, from_type_1.FromType)(UncapitalizeMapping, instantiatedType), {}, options);
+}
+function UncapitalizeInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? UncapitalizeImmediate(context, state, type, options)
+        : (0, uncapitalize_1.UncapitalizeDeferred)(type, options));
+}
+function UppercaseImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update((0, from_type_1.FromType)(UppercaseMapping, instantiatedType), {}, options);
+}
+function UppercaseInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? UppercaseImmediate(context, state, type, options)
+        : (0, uppercase_1.UppercaseDeferred)(type, options));
+}

package/build/cjs/type/engine/intrinsics/mapping.js

@@ -0,0 +1,7 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplyMapping = ApplyMapping;
+function ApplyMapping(mapping, value) {
+    return mapping(value);
+}

package/build/cjs/type/engine/keyof/from-array.d.ts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/index';
+import { type TNumber } from "../../types/number";
+export type TFromArray<_Type extends TSchema> = TNumber;
+export declare function FromArray<_Type extends TSchema>(_type: _Type): TFromArray<_Type>;

package/build/cjs/type/engine/keyof/from-array.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromArray = FromArray;
+const number_1 = require("../../types/number");
+function FromArray(_type) {
+    return (0, number_1.Number)();
+}

package/build/cjs/type/engine/keyof/from-object.d.ts

@@ -0,0 +1,10 @@
+import { type TUnreachable } from '../../../system/unreachable/index';
+import { type TSchema } from '../../types/index';
+import { type TUnionToTuple } from '../helpers/index';
+import { type TProperties } from '../../types/properties';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TEvaluateUnion } from '../evaluate/evaluate';
+type TFromPropertyKeys<Keys extends PropertyKey[], Result extends TSchema[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends TLiteralValue ? TFromPropertyKeys<Right, [...Result, TLiteral<Left>]> : TUnreachable : Result);
+export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;
+export {};

package/build/cjs/type/engine/keyof/from-object.js

@@ -0,0 +1,23 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromObject = FromObject;
+const index_1 = require("../../../system/unreachable/index");
+const index_2 = require("../../../guard/index");
+const literal_1 = require("../../types/literal");
+const keys_1 = require("../helpers/keys");
+const evaluate_1 = require("../evaluate/evaluate");
+function FromPropertyKeys(keys) {
+    const result = keys.reduce((result, left) => {
+        return (0, literal_1.IsLiteralValue)(left)
+            ? [...result, (0, literal_1.Literal)((0, keys_1.ConvertToIntegerKey)(left))]
+            : (0, index_1.Unreachable)();
+    }, []);
+    return result;
+}
+function FromObject(properties) {
+    const propertyKeys = index_2.Guard.Keys(properties);
+    const variants = FromPropertyKeys(propertyKeys);
+    const result = (0, evaluate_1.EvaluateUnion)(variants);
+    return result;
+}

package/build/cjs/type/engine/keyof/from-record.d.ts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/index';
+import { type TRecord, type TRecordKey } from '../../types/record';
+export type TFromRecord<Type extends TRecord, Result extends TSchema = TRecordKey<Type>> = Result;
+export declare function FromRecord<Type extends TRecord>(type: Type): TFromRecord<Type>;

package/build/cjs/type/engine/keyof/from-record.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromRecord = FromRecord;
+const record_1 = require("../../types/record");
+function FromRecord(type) {
+    return (0, record_1.RecordKey)(type);
+}

package/build/cjs/type/engine/keyof/from-tuple.d.ts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/index';
+import { type TLiteral } from '../../types/literal';
+import { type TEvaluateUnion } from '../evaluate/evaluate';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnion<Result>);
+export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/build/cjs/type/engine/keyof/from-tuple.js

@@ -0,0 +1,10 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTuple = FromTuple;
+const literal_1 = require("../../types/literal");
+const evaluate_1 = require("../evaluate/evaluate");
+function FromTuple(types) {
+    const result = types.map((_, index) => (0, literal_1.Literal)(index));
+    return (0, evaluate_1.EvaluateUnion)(result);
+}

package/build/cjs/type/engine/keyof/index.d.ts

@@ -0,0 +1 @@
+export * from './instantiate';

package/build/cjs/type/engine/keyof/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instantiate"), exports);

package/build/cjs/type/engine/keyof/instantiate.d.ts

@@ -0,0 +1,25 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TArray } from '../../types/array';
+import { type TCyclic } from '../../types/cyclic';
+import { type TIntersect } from '../../types/intersect';
+import { type TNever } from '../../types/never';
+import { type TObject } from '../../types/object';
+import { type TRecord } from '../../types/record';
+import { type TTuple } from '../../types/tuple';
+import { type TUnion } from '../../types/union';
+import { type TKeyOfDeferred } from '../../action/keyof';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+import { type TCollapseToObject } from '../object/index';
+import { type TFromArray } from "./from-array";
+import { type TFromObject } from './from-object';
+import { type TFromRecord } from './from-record';
+import { type TFromTuple } from './from-tuple';
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+export type TKeyOfAction<Type extends TSchema, Normalized extends TSchema = TNormalizeType<Type>> = (Normalized extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Normalized extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Normalized extends TRecord ? TFromRecord<Normalized> : Normalized extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : TNever);
+export declare function KeyOfAction<Type extends TSchema>(type: Type): TKeyOfAction<Type>;
+export type TKeyOfImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;
+export declare function KeyOfImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TKeyOfImmediate<Context, State, Type>;
+export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TKeyOfImmediate<Context, State, Type> : TKeyOfDeferred<Type>;
+export declare function KeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TKeyOfInstantiate<Context, State, Type>;
+export {};