typebox 1.0.31 → 1.0.33

package/build/cjs/type/engine/record/from-key-literal.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromLiteralKey = FromLiteralKey;
+const index_1 = require("../../../guard/index");
+const object_1 = require("../../types/object");
+function FromLiteralKey(key, value) {
+    return (index_1.Guard.IsString(key) || index_1.Guard.IsNumber(key) ? (0, object_1.Object)({ [key]: value }) :
+        index_1.Guard.IsEqual(key, false) ? (0, object_1.Object)({ false: value }) :
+            index_1.Guard.IsEqual(key, true) ? (0, object_1.Object)({ true: value }) :
+                (0, object_1.Object)({}));
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema';
+import { type TNumber } from '../../types/number';
+import { type TRecord, NumberKey } from '../../types/record';
+export type TFromNumberKey<Key extends TNumber, Value extends TSchema, Result extends TSchema = TRecord<typeof NumberKey, Value>> = Result;
+export declare function FromNumberKey<Key extends TNumber, Value extends TSchema>(key: Key, value: Value): TFromNumberKey<Key, Value>;

package/build/cjs/type/engine/record/from-key-number.js

@@ -0,0 +1,10 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromNumberKey = FromNumberKey;
+const record_1 = require("../../types/record");
+const record_create_1 = require("./record-create");
+function FromNumberKey(key, value) {
+    const result = (0, record_create_1.CreateRecord)(record_1.NumberKey, value);
+    return result;
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema';
+import { type TRecord, StringKey } from '../../types/record';
+import { type TString } from '../../types/string';
+export type TFromStringKey<_Key extends TSchema, Value extends TSchema, Result extends TSchema = TRecord<typeof StringKey, Value>> = Result;
+export declare function FromStringKey<Key extends TString, Value extends TSchema>(key: Key, value: Value): TFromStringKey<Key, Value>;

package/build/cjs/type/engine/record/from-key-string.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromStringKey = FromStringKey;
+const index_1 = require("../../../guard/index");
+const record_1 = require("../../types/record");
+const record_create_1 = require("./record-create");
+function FromStringKey(key, value) {
+    // special case: override for string with raw pattern. We do not observe inference for the
+    // raw string patterns, but as a pattern (assuming non-never) is in the set of string, we
+    // allow overriding. Callers will need to narrow to the pattern manually. TB legacy.
+    return (index_1.Guard.HasPropertyKey(key, 'pattern') && (index_1.Guard.IsString(key.pattern) || key.pattern instanceof RegExp)
+        ? (0, record_create_1.CreateRecord)(key.pattern.toString(), value)
+        : (0, record_create_1.CreateRecord)(record_1.StringKey, value));
+}

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

@@ -0,0 +1,8 @@
+import { type TSchema } from '../../types/schema';
+import { type TRecord } from '../../types/record';
+import { type TFromKey } from './from-key';
+import { type TParsePatternIntoTypes } from '../patterns/pattern';
+import { type TTemplateLiteralFinite } from '../template-literal/finite';
+import { type TTemplateLiteralDecode } from '../template-literal/decode';
+export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TTemplateLiteralDecode<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
+export declare function FromTemplateKey<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TFromTemplateKey<Pattern, Value>;

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

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTemplateKey = FromTemplateKey;
+const from_key_1 = require("./from-key");
+const pattern_1 = require("../patterns/pattern");
+const finite_1 = require("../template-literal/finite");
+const decode_1 = require("../template-literal/decode");
+const record_create_1 = require("./record-create");
+function FromTemplateKey(pattern, value) {
+    const types = (0, pattern_1.ParsePatternIntoTypes)(pattern);
+    const finite = (0, finite_1.TemplateLiteralFinite)(types);
+    const result = finite ? (0, from_key_1.FromKey)((0, decode_1.TemplateLiteralDecode)(pattern), value) : (0, record_create_1.CreateRecord)(pattern, value);
+    return result;
+}

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema';
+import { type TLiteral } from '../../types/literal';
+import { type TNumber } from '../../types/number';
+import { type TInteger } from '../../types/integer';
+import { type TObject } from '../../types/object';
+import { type TProperties } from '../../types/properties';
+import { type TString } from '../../types/string';
+import { type TRecord, StringKey } from '../../types/record';
+import { type TFlatten } from '../evaluate/flatten';
+type TStringOrNumberCheck<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TString | TNumber | TInteger ? true : TStringOrNumberCheck<Right> : false);
+type TTryBuildRecord<Types extends TSchema[], Value extends TSchema, Result extends TSchema | undefined = (TStringOrNumberCheck<Types> extends true ? TRecord<typeof StringKey, Value> : undefined)> = Result;
+type TCreateProperties<Variants extends TSchema[], Value extends TSchema, Result extends TProperties = {}> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TLiteral<string | number> ? TCreateProperties<Right, Value, Result & {
+    [_ in Left['const']]: Value;
+}> : TCreateProperties<Right, Value, Result> : {
+    [Key in keyof Result]: Result[Key];
+});
+type TCreateObject<Variants extends TSchema[], Value extends TSchema, Properties extends TProperties = TCreateProperties<Variants, Value>, Result extends TSchema = TObject<Properties>> = Result;
+export type TFromUnionKey<Types extends TSchema[], Value extends TSchema, Flattened extends TSchema[] = TFlatten<Types>, Record extends TSchema | undefined = TTryBuildRecord<Flattened, Value>, Result extends TSchema = (Record extends TSchema ? Record : TCreateObject<Flattened, Value>)> = Result;
+export declare function FromUnionKey<Types extends TSchema[], Value extends TSchema>(types: [...Types], value: Value): TFromUnionKey<Types, Value>;
+export {};

package/build/cjs/type/engine/record/from-key-union.js

@@ -0,0 +1,42 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromUnionKey = FromUnionKey;
+const index_1 = require("../../../guard/index");
+const schema_1 = require("../../types/schema");
+const literal_1 = require("../../types/literal");
+const number_1 = require("../../types/number");
+const integer_1 = require("../../types/integer");
+const object_1 = require("../../types/object");
+const string_1 = require("../../types/string");
+const record_1 = require("../../types/record");
+const flatten_1 = require("../evaluate/flatten");
+const record_create_1 = require("./record-create");
+function StringOrNumberCheck(types) {
+    return types.some(type => (0, string_1.IsString)(type) || (0, number_1.IsNumber)(type) || (0, integer_1.IsInteger)(type));
+}
+function TryBuildRecord(types, value) {
+    return (index_1.Guard.IsEqual(StringOrNumberCheck(types), true)
+        ? (0, record_create_1.CreateRecord)(record_1.StringKey, value)
+        : undefined);
+}
+function CreateProperties(types, value) {
+    return types.reduce((result, left) => {
+        return (0, literal_1.IsLiteral)(left) && (index_1.Guard.IsString(left.const) || index_1.Guard.IsNumber(left.const))
+            ? { ...result, [left.const]: value }
+            : result;
+    }, {});
+}
+function CreateObject(types, value) {
+    const properties = CreateProperties(types, value);
+    const result = (0, object_1.Object)(properties);
+    return result;
+}
+function FromUnionKey(types, value) {
+    const flattened = (0, flatten_1.Flatten)(types);
+    const record = TryBuildRecord(flattened, value);
+    return ((0, schema_1.IsSchema)(record) // maybe IsRecord?
+        ? record
+        : CreateObject(flattened, value));
+}

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

@@ -0,0 +1,24 @@
+import { type TSchema } from '../../types/schema';
+import { type TAny } from '../../types/any';
+import { type TBoolean } from '../../types/boolean';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TIntersect } from '../../types/intersect';
+import { type TInteger } from '../../types/integer';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TNumber } from '../../types/number';
+import { type TObject } from '../../types/object';
+import { type TString } from '../../types/string';
+import { type TTemplateLiteral } from '../../types/template-literal';
+import { type TUnion } from '../../types/union';
+import { type TFromAnyKey } from './from-key-any';
+import { type TFromBooleanKey } from './from-key-boolean';
+import { type TFromEnumKey } from './from-key-enum';
+import { type TFromIntegerKey } from './from-key-integer';
+import { type TFromIntersectKey } from './from-key-intersect';
+import { type TFromLiteralKey } from './from-key-literal';
+import { type TFromNumberKey } from './from-key-number';
+import { type TFromStringKey } from './from-key-string';
+import { type TFromTemplateKey } from './from-key-template-literal';
+import { type TFromUnionKey } from './from-key-union';
+export type TFromKey<Key extends TSchema, Value extends TSchema, Result extends TSchema = (Key extends TAny ? TFromAnyKey<Value> : Key extends TBoolean ? TFromBooleanKey<Value> : Key extends TEnum<infer Values extends TEnumValue[]> ? TFromEnumKey<Values, Value> : Key extends TInteger ? TFromIntegerKey<Key, Value> : Key extends TIntersect<infer Types extends TSchema[]> ? TFromIntersectKey<Types, Value> : Key extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteralKey<LiteralValue, Value> : Key extends TNumber ? TFromNumberKey<Key, Value> : Key extends TString ? TFromStringKey<Key, Value> : Key extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateKey<Pattern, Value> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Value> : TObject<{}>)> = Result;
+export declare function FromKey<Key extends TSchema, Value extends TSchema>(key: Key, value: Value): TFromKey<Key, Value>;

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

@@ -0,0 +1,43 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromKey = FromKey;
+const any_1 = require("../../types/any");
+const boolean_1 = require("../../types/boolean");
+const enum_1 = require("../../types/enum");
+const intersect_1 = require("../../types/intersect");
+const integer_1 = require("../../types/integer");
+const literal_1 = require("../../types/literal");
+const number_1 = require("../../types/number");
+const object_1 = require("../../types/object");
+const string_1 = require("../../types/string");
+const template_literal_1 = require("../../types/template-literal");
+const union_1 = require("../../types/union");
+// ------------------------------------------------------------------
+// Keys and Deferred
+// ------------------------------------------------------------------
+const from_key_any_1 = require("./from-key-any");
+const from_key_boolean_1 = require("./from-key-boolean");
+const from_key_enum_1 = require("./from-key-enum");
+const from_key_integer_1 = require("./from-key-integer");
+const from_key_intersect_1 = require("./from-key-intersect");
+const from_key_literal_1 = require("./from-key-literal");
+const from_key_number_1 = require("./from-key-number");
+const from_key_string_1 = require("./from-key-string");
+const from_key_template_literal_1 = require("./from-key-template-literal");
+const from_key_union_1 = require("./from-key-union");
+function FromKey(key, value) {
+    const result = ((0, any_1.IsAny)(key) ? (0, from_key_any_1.FromAnyKey)(value) :
+        (0, boolean_1.IsBoolean)(key) ? (0, from_key_boolean_1.FromBooleanKey)(value) :
+            (0, enum_1.IsEnum)(key) ? (0, from_key_enum_1.FromEnumKey)(key.enum, value) :
+                (0, integer_1.IsInteger)(key) ? (0, from_key_integer_1.FromIntegerKey)(key, value) :
+                    (0, intersect_1.IsIntersect)(key) ? (0, from_key_intersect_1.FromIntersectKey)(key.allOf, value) :
+                        (0, literal_1.IsLiteral)(key) ? (0, from_key_literal_1.FromLiteralKey)(key.const, value) :
+                            (0, number_1.IsNumber)(key) ? (0, from_key_number_1.FromNumberKey)(key, value) :
+                                (0, union_1.IsUnion)(key) ? (0, from_key_union_1.FromUnionKey)(key.anyOf, value) :
+                                    (0, string_1.IsString)(key) ? (0, from_key_string_1.FromStringKey)(key, value) :
+                                        (0, template_literal_1.IsTemplateLiteral)(key) ? (0, from_key_template_literal_1.FromTemplateKey)(key.pattern, value) :
+                                            (0, object_1.Object)({}));
+    return result;
+}

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

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

package/build/cjs/type/engine/record/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/record/instantiate.d.ts

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TRecordDeferred } from '../../types/record';
+import { type TFromKey } from './from-key';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TRecordImmediate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema, InstantatedKey extends TSchema = TInstantiateType<Context, State, Key>, InstantiatedValue extends TSchema = TInstantiateType<Context, State, Value>, Result extends TSchema = TFromKey<InstantatedKey, InstantiatedValue>> = Result;
+export type TRecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema> = TCanInstantiate<Context, [Key]> extends true ? TRecordImmediate<Context, State, Key, Value> : TRecordDeferred<Key, Value>;
+export declare function RecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema>(context: Context, state: State, key: Key, value: Value, options: TSchemaOptions): TRecordInstantiate<Context, State, Key, Value>;
+export {};

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

@@ -0,0 +1,19 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordInstantiate = RecordInstantiate;
+const index_1 = require("../../../system/memory/index");
+const record_1 = require("../../types/record");
+const from_key_1 = require("./from-key");
+const instantiate_1 = require("../instantiate");
+function RecordImmediate(context, state, key, value, options) {
+    const instanstiatedKey = (0, instantiate_1.InstantiateType)(context, state, key);
+    const instantiatedValue = (0, instantiate_1.InstantiateType)(context, state, value);
+    return index_1.Memory.Update((0, from_key_1.FromKey)(instanstiatedKey, instantiatedValue), {}, options);
+}
+function RecordInstantiate(context, state, key, value, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [key])
+        ? RecordImmediate(context, state, key, value, options)
+        : (0, record_1.RecordDeferred)(key, value, options));
+}

package/build/cjs/type/engine/record/record-create.d.ts

@@ -0,0 +1,3 @@
+import { type TSchema } from '../../types/schema';
+import { type TRecord } from '../../types/record';
+export declare function CreateRecord<Key extends string, Value extends TSchema>(key: Key, value: Value): TRecord<Key, Value>;

package/build/cjs/type/engine/record/record-create.js

@@ -0,0 +1,10 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRecord = CreateRecord;
+const index_1 = require("../../../system/memory/index");
+function CreateRecord(key, value) {
+    const type = 'object';
+    const patternProperties = { [key]: value };
+    return index_1.Memory.Create({ ['~kind']: 'Record' }, { type, patternProperties });
+}

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

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

package/build/cjs/type/engine/ref/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/ref/instantiate.d.ts

@@ -0,0 +1,6 @@
+import { TProperties } from '../../types/properties';
+import { type TRef } from '../../types/ref';
+import { type TState, type TInstantiateType } from '../instantiate';
+import { type TCyclicCheck } from '../cyclic/check';
+export type TRefInstantiate<Context extends TProperties, State extends TState, Ref extends string> = (Ref extends keyof Context ? TCyclicCheck<[Ref], Context, Context[Ref]> extends true ? TRef<Ref> : TInstantiateType<Context, State, Context[Ref]> : TRef<Ref>);
+export declare function RefInstantiate<Context extends TProperties, State extends TState, Ref extends string>(context: Context, state: State, ref: Ref): TRefInstantiate<Context, State, Ref>;

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

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefInstantiate = RefInstantiate;
+const ref_1 = require("../../types/ref");
+const instantiate_1 = require("../instantiate");
+const check_1 = require("../cyclic/check");
+function RefInstantiate(context, state, ref) {
+    return (ref in context
+        ? (0, check_1.CyclicCheck)([ref], context, context[ref])
+            ? (0, ref_1.Ref)(ref)
+            : (0, instantiate_1.InstantiateType)(context, state, context[ref])
+        : (0, ref_1.Ref)(ref));
+}

package/build/cjs/type/engine/required/from-cyclic.d.ts

@@ -0,0 +1,10 @@
+import { Memory } from '../../../system/memory/index';
+import { type TSchema } from '../../types/schema';
+import { type TCyclic } from '../../types/cyclic';
+import { type TProperties } from '../../types/properties';
+import { type TFromType } from './from-type';
+import { type TCyclicTarget } from '../cyclic/target';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
+    [_ in Ref]: Partial;
+}>, Ref>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/cjs/type/engine/required/from-cyclic.js

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromCyclic = FromCyclic;
+const index_1 = require("../../../system/memory/index");
+const cyclic_1 = require("../../types/cyclic");
+const from_type_1 = require("./from-type");
+const target_1 = require("../cyclic/target");
+function FromCyclic(defs, ref) {
+    const target = (0, target_1.CyclicTarget)(defs, ref);
+    const partial = (0, from_type_1.FromType)(target);
+    const result = (0, cyclic_1.Cyclic)(index_1.Memory.Assign(defs, { [ref]: partial }), ref);
+    return result;
+}

package/build/cjs/type/engine/required/from-intersect.d.ts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema';
+import { type TFromType } from './from-type';
+import { type TEvaluateIntersect } from '../evaluate/evaluate';
+export type TFromIntersect<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, [...Result, TFromType<Left>]> : TEvaluateIntersect<Result>);
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/build/cjs/type/engine/required/from-intersect.js

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

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

@@ -0,0 +1,8 @@
+import { type TSchema } from '../../types/schema';
+import { type TObject } from '../../types/object';
+import { type TOptionalRemove } from '../../types/_optional';
+import { type TProperties } from '../../types/properties';
+export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
+    [Key in keyof Properties]: TOptionalRemove<Properties[Key]>;
+}, Result extends TSchema = TObject<Mapped>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

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

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromObject = FromObject;
+const index_1 = require("../../../guard/index");
+const object_1 = require("../../types/object");
+const _optional_1 = require("../../types/_optional");
+function FromObject(properties) {
+    const mapped = index_1.Guard.Keys(properties).reduce((result, left) => {
+        return { ...result, [left]: (0, _optional_1.OptionalRemove)(properties[left]) };
+    }, {});
+    const result = (0, object_1.Object)(mapped);
+    return result;
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema';
+import { type TCyclic } from '../../types/cyclic';
+import { type TIntersect } from '../../types/intersect';
+import { type TObject } from '../../types/object';
+import { type TProperties } from '../../types/properties';
+import { type TUnion } from '../../types/union';
+import { type TFromCyclic } from './from-cyclic';
+import { type TFromIntersect } from './from-intersect';
+import { type TFromUnion } from './from-union';
+import { type TFromObject } from './from-object';
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,19 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromType = FromType;
+const cyclic_1 = require("../../types/cyclic");
+const intersect_1 = require("../../types/intersect");
+const object_1 = require("../../types/object");
+const union_1 = require("../../types/union");
+const from_cyclic_1 = require("./from-cyclic");
+const from_intersect_1 = require("./from-intersect");
+const from_union_1 = require("./from-union");
+const from_object_1 = require("./from-object");
+function FromType(type) {
+    return ((0, cyclic_1.IsCyclic)(type) ? (0, from_cyclic_1.FromCyclic)(type.$defs, type.$ref) :
+        (0, intersect_1.IsIntersect)(type) ? (0, from_intersect_1.FromIntersect)(type.allOf) :
+            (0, union_1.IsUnion)(type) ? (0, from_union_1.FromUnion)(type.anyOf) :
+                (0, object_1.IsObject)(type) ? (0, from_object_1.FromObject)(type.properties) :
+                    (0, object_1.Object)({}));
+}

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

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

package/build/cjs/type/engine/required/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(types) {
+    const result = types.map(type => (0, from_type_1.FromType)(type));
+    return (0, union_1.Union)(result);
+}

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

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

package/build/cjs/type/engine/required/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/required/instantiate.d.ts

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TFromType } from './from-type';
+import { type TRequiredDeferred } from '../../action/required';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TRequiredImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
+export type TRequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TRequiredImmediate<Context, State, Type> : TRequiredDeferred<Type>;
+export declare function RequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRequiredInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,17 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredInstantiate = RequiredInstantiate;
+const index_1 = require("../../../system/memory/index");
+const from_type_1 = require("./from-type");
+const required_1 = require("../../action/required");
+const instantiate_1 = require("../instantiate");
+function RequiredImmediate(context, state, type, options) {
+    const instaniatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update((0, from_type_1.FromType)(instaniatedType), {}, options);
+}
+function RequiredInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? RequiredImmediate(context, state, type, options)
+        : (0, required_1.RequiredDeferred)(type, options));
+}

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

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

package/build/cjs/type/engine/rest/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("./spread"), exports);

package/build/cjs/type/engine/rest/spread.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema';
+import { type TInfer } from '../../types/infer';
+import { type TNever } from '../../types/never';
+import { type TRest } from '../../types/rest';
+import { type TRef } from '../../types/ref';
+import { type TTuple } from '../../types/tuple';
+type TSpreadElement<Type extends TSchema, Result extends TSchema[] = (Type extends TRest<infer Rest extends TSchema> ? (Rest extends TTuple<infer Elements extends TSchema[]> ? TRestSpread<Elements> : Rest extends TInfer<string, TSchema> ? [Type] : Rest extends TRef<string> ? [Type] : [
+    TNever
+]) : [Type])> = Result;
+export type TRestSpread<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TRestSpread<Right, [...Result, ...TSpreadElement<Left>]> : Result);
+export declare function RestSpread<Types extends TSchema[]>(types: [...Types]): TRestSpread<Types>;
+export {};

package/build/cjs/type/engine/rest/spread.js

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestSpread = RestSpread;
+const infer_1 = require("../../types/infer");
+const never_1 = require("../../types/never");
+const rest_1 = require("../../types/rest");
+const ref_1 = require("../../types/ref");
+const tuple_1 = require("../../types/tuple");
+function SpreadElement(type) {
+    const result = ((0, rest_1.IsRest)(type) ? ((0, tuple_1.IsTuple)(type.items) ? RestSpread(type.items.items) :
+        (0, infer_1.IsInfer)(type.items) ? [type] :
+            (0, ref_1.IsRef)(type.items) ? [type] :
+                [(0, never_1.Never)()]) : [type]);
+    return result;
+}
+function RestSpread(types) {
+    const result = types.reduce((result, left) => {
+        return [...result, ...SpreadElement(left)];
+    }, []);
+    return result;
+}

package/build/cjs/type/engine/return-type/index.d.ts

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

package/build/cjs/type/engine/return-type/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/return-type/instantiate.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TFunction } from '../../types/function';
+import { type TNever } from '../../types/never';
+import { type TReturnTypeDeferred } from '../../action/return-type';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TReturnTypeAction<Type extends TSchema> = Type extends TFunction<TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever;
+type TReturnTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TReturnTypeAction<InstantiatedType>;
+export type TReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TReturnTypeImmediate<Context, State, Type> : TReturnTypeDeferred<Type>;
+export declare function ReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TReturnTypeInstantiate<Context, State, Type>;
+export {};