typebox 0.0.1 → 1.0.0-rc

package/build/type/engine/object/from-cyclic.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+import { CyclicTarget } from '../cyclic/target.mjs';
+export function FromCyclic(defs, ref) {
+    const target = CyclicTarget(defs, ref);
+    const result = FromType(target);
+    return result;
+}

package/build/type/engine/object/from-intersect.d.mts

@@ -0,0 +1,14 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from-type.mjs';
+type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, LeftProperties extends TProperties = {
+    [Key in LeftKeys]: Left[Key];
+}, RightProperties extends TProperties = {
+    [Key in RightKeys]: Right[Key];
+}, Result extends TProperties = Memory.TAssign<LeftProperties, RightProperties>> = Result;
+export type TFromIntersect<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, TCollapseIntersectProperties<Result, TFromType<Left>>> : {
+    [Key in keyof Result]: Result[Key];
+});
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;
+export {};

package/build/type/engine/object/from-intersect.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+function CollapseIntersectProperties(left, right) {
+    const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));
+    const rightKeys = Guard.Keys(right).filter((key) => !Guard.HasPropertyKey(left, key));
+    const leftProperties = leftKeys.reduce((result, key) => Memory.Assign(result, { [key]: left[key] }), {});
+    const rightProperties = rightKeys.reduce((result, key) => Memory.Assign(result, { [key]: right[key] }), {});
+    const result = Memory.Assign(leftProperties, rightProperties);
+    return result;
+}
+export function FromIntersect(types) {
+    return types.reduce((result, left) => {
+        return CollapseIntersectProperties(result, FromType(left));
+    }, {});
+}

package/build/type/engine/object/from-object.d.mts

@@ -0,0 +1,3 @@
+import { type TProperties } from '../../types/properties.mjs';
+export type TFromObject<Properties extends TProperties> = (Properties);
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

package/build/type/engine/object/from-object.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromObject(properties) {
+    return properties;
+}

package/build/type/engine/object/from-tuple.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TTupleToObject } from '../tuple/to-object.mjs';
+import { type TFromType } from './from-type.mjs';
+export type TFromTuple<Types extends TSchema[], Object extends TSchema = TTupleToObject<TTuple<Types>>, Result extends TSchema = TFromType<Object>> = Result;
+export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/build/type/engine/object/from-tuple.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Tuple } from '../../types/tuple.mjs';
+import { TupleToObject } from '../tuple/to-object.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTuple(types) {
+    const object = TupleToObject(Tuple(types));
+    const result = FromType(object);
+    return result;
+}

package/build/type/engine/object/from-type.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from-cyclic.mjs';
+import { type TFromIntersect } from './from-intersect.mjs';
+import { type TFromObject } from './from-object.mjs';
+import { type TFromTuple } from './from-tuple.mjs';
+import { type TFromUnion } from './from-union.mjs';
+export type TFromType<Type extends TSchema, Result extends TProperties = (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 TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/build/type/engine/object/from-type.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { FromUnion } from './from-union.mjs';
+export function FromType(type) {
+    return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+        IsIntersect(type) ? FromIntersect(type.allOf) :
+            IsUnion(type) ? FromUnion(type.anyOf) :
+                IsTuple(type) ? FromTuple(type.items) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        {});
+}

package/build/type/engine/object/from-union.d.mts

@@ -0,0 +1,12 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TFromType } from './from-type.mjs';
+type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
+    [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]>;
+}> = Result;
+type TReduceVariants<Types extends TSchema[], Result extends TProperties> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TCollapseUnionProperties<Result, TFromType<Left>>> : Result);
+export type TFromUnion<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TFromType<Left>> : TUnreachable);
+export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;
+export {};

package/build/type/engine/object/from-union.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { IsSchema } from '../../types/schema.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { FromType } from './from-type.mjs';
+function CollapseUnionProperties(left, right) {
+    const sharedKeys = Guard.Keys(left).filter((key) => key in right);
+    const result = sharedKeys.reduce((result, key) => {
+        return { ...result, [key]: EvaluateIntersect([left[key], right[key]]) };
+    }, {});
+    return result;
+}
+function ReduceVariants(types, result) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? ReduceVariants(right, CollapseUnionProperties(result, FromType(left)))
+        : result);
+}
+export function FromUnion(types) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? ReduceVariants(right, FromType(left))
+        : Unreachable());
+}
+// deno-coverage-ignore-stop

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { type TToIndexable } from '../indexable/to-indexable.mjs';
+import { type TOmitDeferred } from '../../action/omit.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TNormalKeys<Keys extends string[], UnionKeys extends string = Keys[number], Result extends string | number = (UnionKeys extends `${infer Value extends number}` ? UnionKeys | Value : UnionKeys)> = Result;
+type TFromKeys<Properties extends TProperties, Keys extends string[], Omitted extends TProperties = Omit<Properties, TNormalKeys<Keys>>, Result extends TProperties = {
+    [Key in keyof Omitted]: Omitted[Key];
+}> = Result;
+type TOmitAction<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, IndexableKeys extends string[] = TToIndexableKeys<Indexer>, Omitted extends TProperties = TFromKeys<Indexable, IndexableKeys>, Result extends TSchema = TObject<Omitted>> = Result;
+type TOmitImmediate<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>, Result extends TSchema = TOmitAction<InstantiatedType, InstantiatedIndexer>> = Result;
+export type TOmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TOmitImmediate<Context, State, Type, Indexer> : TOmitDeferred<Type, Indexer>;
+export declare function OmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TOmitInstantiate<Context, State, Type, Indexer>;
+export {};

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

@@ -0,0 +1,31 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { ToIndexable } from '../indexable/to-indexable.mjs';
+import { OmitDeferred } from '../../action/omit.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? result : { ...result, [key]: properties[key] };
+    }, {});
+    return result;
+}
+function OmitAction(type, indexer) {
+    const indexable = ToIndexable(type);
+    const indexableKeys = ToIndexableKeys(indexer);
+    const omitted = FromKeys(indexable, indexableKeys);
+    const result = Object(omitted);
+    return result;
+}
+function OmitImmediate(context, state, type, indexer, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    const instantiatedIndexer = InstantiateType(context, state, indexer);
+    return Memory.Update(OmitAction(instantiatedType, instantiatedIndexer), {}, options);
+}
+export function OmitInstantiate(context, state, type, indexer, options) {
+    return (CanInstantiate(context, [type, indexer])
+        ? OmitImmediate(context, state, type, indexer, options)
+        : OmitDeferred(type, indexer, options));
+}

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TState, type TInstantiateType, TCanInstantiate } from '../instantiate.mjs';
+import { type TOptionsDeferred, type TOptions } from '../../action/options.mjs';
+type TOptionsImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, Result extends TSchema = TOptions<InstantiatedType, Options>> = Result;
+export type TOptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TOptionsImmediate<Context, State, Type, Options> : TOptionsDeferred<Type, Options>;
+export declare function OptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema>(context: Context, state: State, type: Type, options: Options): TOptionsInstantiate<Context, State, Type, Options>;
+export {};

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

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { CanInstantiate, InstantiateType } from '../instantiate.mjs';
+import { OptionsDeferred } from '../../action/options.mjs';
+function OptionsImmediate(context, state, type, options) {
+    const instaniatedType = InstantiateType(context, state, type);
+    return Memory.Update(instaniatedType, {}, options);
+}
+export function OptionsInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? OptionsImmediate(context, state, type, options)
+        : OptionsDeferred(type, options));
+}

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TParametersDeferred } from '../../action/parameters.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TParametersAction<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ extends TSchema> ? TInstantiateType<{}, {
+    callstack: [];
+}, TTuple<Parameters>> : TNever);
+type TParametersImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantatedType>;
+export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = (TCanInstantiate<Context, [Type]> extends true ? TParametersImmediate<Context, State, Type> : TParametersDeferred<Type>);
+export declare function ParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TParametersInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { Never } from '../../types/never.mjs';
+import { Tuple } from '../../types/tuple.mjs';
+import { ParametersDeferred } from '../../action/parameters.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function ParametersAction(type) {
+    return (IsFunction(type)
+        ? InstantiateType({}, { callstack: [] }, Tuple(type.parameters)) // spread-rest
+        : Never());
+}
+function ParametersImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(ParametersAction(instantiatedType), {}, options);
+}
+export function ParametersInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? ParametersImmediate(context, state, type, options)
+        : ParametersDeferred(type, options));
+}

package/build/type/engine/partial/from-cyclic.d.mts

@@ -0,0 +1,10 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from-type.mjs';
+import { type TCyclicTarget } from '../cyclic/target.mjs';
+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/type/engine/partial/from-cyclic.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Cyclic } from '../../types/cyclic.mjs';
+import { FromType } from './from-type.mjs';
+import { CyclicTarget } from '../cyclic/target.mjs';
+export function FromCyclic(defs, ref) {
+    const target = CyclicTarget(defs, ref);
+    const partial = FromType(target);
+    const result = Cyclic(Memory.Assign(defs, { [ref]: partial }), ref);
+    return result;
+}

package/build/type/engine/partial/from-intersect.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from-type.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+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/type/engine/partial/from-intersect.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+export function FromIntersect(types) {
+    const result = types.map(type => FromType(type));
+    return EvaluateIntersect(result);
+}

package/build/type/engine/partial/from-object.d.mts

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

package/build/type/engine/partial/from-object.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { Optional } from '../../types/_optional.mjs';
+export function FromObject(properties) {
+    const mapped = Guard.Keys(properties).reduce((result, left) => {
+        return { ...result, [left]: Optional(properties[left]) };
+    }, {});
+    const result = Object(mapped);
+    return result;
+}

package/build/type/engine/partial/from-type.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from-cyclic.mjs';
+import { type TFromIntersect } from './from-intersect.mjs';
+import { type TFromUnion } from './from-union.mjs';
+import { type TFromObject } from './from-object.mjs';
+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/type/engine/partial/from-type.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { Object, IsObject } from '../../types/object.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromUnion } from './from-union.mjs';
+import { FromObject } from './from-object.mjs';
+export function FromType(type) {
+    return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+        IsIntersect(type) ? FromIntersect(type.allOf) :
+            IsUnion(type) ? FromUnion(type.anyOf) :
+                IsObject(type) ? FromObject(type.properties) :
+                    Object({}));
+}

package/build/type/engine/partial/from-union.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromType } from './from-type.mjs';
+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/type/engine/partial/from-union.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Union } from '../../types/union.mjs';
+import { FromType } from './from-type.mjs';
+export function FromUnion(types) {
+    const result = types.map(type => FromType(type));
+    return Union(result);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { PartialDeferred } from '../../action/partial.mjs';
+import { FromType } from './from-type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function PartialImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(FromType(instantiatedType), {}, options);
+}
+export function PartialInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? PartialImmediate(context, state, type, options)
+        : PartialDeferred(type, options));
+}

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

@@ -0,0 +1,2 @@
+export * from './pattern.mjs';
+export * from './template.mjs';

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

@@ -0,0 +1,2 @@
+export * from './pattern.mjs';
+export * from './template.mjs';

package/build/type/engine/patterns/pattern.d.mts

@@ -0,0 +1,7 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TPattern } from '../../script/parser.mjs';
+/** Parses a Pattern into a sequence of TemplateLiteral types */
+export type TParsePatternIntoTypes<Pattern extends string, Parsed extends [TSchema[], string] | [] = TPattern<Pattern>, Result extends TSchema[] = Parsed extends [infer Types extends TSchema[], string] ? Types : TUnreachable> = Result;
+/** Parses a Pattern into a sequence of TemplateLiteral types */
+export declare function ParsePatternIntoTypes<Pattern extends string>(pattern: Pattern): TParsePatternIntoTypes<Pattern>;

package/build/type/engine/patterns/pattern.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Pattern } from '../../script/parser.mjs';
+/** Parses a Pattern into a sequence of TemplateLiteral types */
+export function ParsePatternIntoTypes(pattern) {
+    const parsed = Pattern(pattern);
+    const result = Guard.IsEqual(parsed.length, 2)
+        ? parsed[0]
+        : Unreachable(); // []
+    return result;
+}
+// deno-coverage-ignore-stop

package/build/type/engine/patterns/template.d.mts

@@ -0,0 +1,7 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TTemplateLiteralTypes } from '../../script/parser.mjs';
+/** Parses a Template into TemplateLiteral types */
+export type TParseTemplateIntoTypes<Template extends string, Parsed extends [TSchema[], string] | [] = TTemplateLiteralTypes<`\`${Template}\``>, Result extends TSchema = Parsed extends [infer Types extends TSchema[], string] ? Types : TUnreachable> = Result;
+/** Parses a Template into a TemplateLiteral types */
+export declare function ParseTemplateIntoTypes<Template extends string>(template: Template): TParseTemplateIntoTypes<Template>;

package/build/type/engine/patterns/template.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { TemplateLiteralTypes } from '../../script/parser.mjs';
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - symmetric unreachable
+//
+// Parser is parsing regular expression for strings and will return 
+// at least 1 TLiteral at a minumum.
+//
+// ------------------------------------------------------------------
+/** Parses a Template into a TemplateLiteral types */
+export function ParseTemplateIntoTypes(template) {
+    const parsed = TemplateLiteralTypes(`\`${template}\``);
+    const result = Guard.IsEqual(parsed.length, 2)
+        ? parsed[0]
+        : Unreachable(); // []
+    return result;
+}
+// deno-coverage-ignore-stop

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { type TToIndexable } from '../indexable/to-indexable.mjs';
+import { type TPickDeferred } from '../../action/pick.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TComparable<Indexable extends TProperties> = keyof Indexable extends string | number ? `${keyof Indexable}` : never;
+type TFromKeys<Indexable extends TProperties, Keys extends string[], Result extends TProperties = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends TComparable<Indexable> ? TFromKeys<Indexable, Right, Memory.TAssign<Result, {
+    [_ in Left]: Indexable[Left];
+}>> : TFromKeys<Indexable, Right, Result> : Result);
+type TPickAction<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, Keys extends string[] = TToIndexableKeys<Indexer>, Applied extends TProperties = TFromKeys<Indexable, Keys>, Result extends TSchema = TObject<Applied>> = Result;
+type TPickImmediate<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>> = TPickAction<InstantiatedType, InstantiatedIndexer>;
+export type TPickInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TPickImmediate<Context, State, Type, Indexer> : TPickDeferred<Type, Indexer>;
+export declare function PickInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TPickInstantiate<Context, State, Type, Indexer>;
+export {};

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

@@ -0,0 +1,31 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { ToIndexable } from '../indexable/to-indexable.mjs';
+import { PickDeferred } from '../../action/pick.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? Memory.Assign(result, { [key]: properties[key] }) : result;
+    }, {});
+    return result;
+}
+function PickAction(type, indexer) {
+    const indexable = ToIndexable(type);
+    const keys = ToIndexableKeys(indexer);
+    const applied = FromKeys(indexable, keys);
+    const result = Object(applied);
+    return result;
+}
+function PickImmediate(context, state, type, indexer, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    const instantiatedIndexer = InstantiateType(context, state, indexer);
+    return Memory.Update(PickAction(instantiatedType, instantiatedIndexer), {}, options);
+}
+export function PickInstantiate(context, state, type, indexer, options) {
+    return (CanInstantiate(context, [type, indexer])
+        ? PickImmediate(context, state, type, indexer, options)
+        : PickDeferred(type, indexer, options));
+}

package/build/type/engine/record/from-key-any.d.mts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TRecord, StringKey } from '../../types/record.mjs';
+export type TFromAnyKey<Value extends TSchema, Result extends TSchema = TRecord<typeof StringKey, Value>> = Result;
+export declare function FromAnyKey<Value extends TSchema>(value: Value): TFromAnyKey<Value>;

package/build/type/engine/record/from-key-any.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { StringKey } from '../../types/record.mjs';
+import { CreateRecord } from './record-create.mjs';
+export function FromAnyKey(value) {
+    return CreateRecord(StringKey, value);
+}

package/build/type/engine/record/from-key-boolean.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TObject } from '../../types/object.mjs';
+export type TFromBooleanKey<Value extends TSchema, Result extends TSchema = TObject<{
+    true: Value;
+    false: Value;
+}>> = Result;
+export declare function FromBooleanKey<Value extends TSchema>(value: Value): TFromBooleanKey<Value>;

package/build/type/engine/record/from-key-boolean.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { Object } from '../../types/object.mjs';
+export function FromBooleanKey(value) {
+    return Object({ true: value, false: value });
+}

package/build/type/engine/record/from-key-enum.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TEnumValuesToUnion } from '../enum/enum-to-union.mjs';
+import { type TFromKey } from './from-key.mjs';
+export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEnumValuesToUnion<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
+export declare function FromEnumKey<Values extends TEnumValue[], Value extends TSchema>(values: [...Values], value: Value): TFromEnumKey<Values, Value>;