@depup/typebox 1.1.6-depup.0

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,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TPattern } from '../../script/parser.mjs';
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
+export type TParsePatternIntoTypes<Pattern extends string, Parsed extends [TSchema[], string] | [] = TPattern<Pattern>, Result extends TSchema[] = Parsed extends [infer Types extends TSchema[], string] ? Types : []> = Result;
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
+export declare function ParsePatternIntoTypes<Pattern extends string>(pattern: Pattern): TParsePatternIntoTypes<Pattern>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Pattern } from '../../script/parser.mjs';
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
+export function ParsePatternIntoTypes(pattern) {
+    const parsed = Pattern(pattern);
+    const result = Guard.IsEqual(parsed.length, 2)
+        ? parsed[0]
+        : []; // Failed to Parse
+    return result;
+}

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/readonly-type/from-array.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TImmutableAdd } from '../../types/_immutable.mjs';
+export type TFromArray<Type extends TSchema, Result extends TSchema = TImmutableAdd<TArray<Type>>> = Result;
+export declare function FromArray<Type extends TSchema>(type: Type): TFromArray<Type>;

package/build/type/engine/readonly-type/from-array.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Array } from '../../types/array.mjs';
+import { Immutable } from '../../types/_immutable.mjs';
+export function FromArray(type) {
+    const result = Immutable(Array(type));
+    return result;
+}

package/build/type/engine/readonly-type/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/readonly-type/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/readonly-type/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/readonly-type/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/readonly-type/from-object.d.mts

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Tuple } from '../../types/tuple.mjs';
+import { Immutable } from '../../types/_immutable.mjs';
+export function FromTuple(types) {
+    const result = Immutable(Tuple(types));
+    return result;
+}

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

@@ -0,0 +1,16 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.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 TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromArray } from './from-array.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> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : 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 TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,22 @@
+// deno-fmt-ignore-file
+import { IsArray } from '../../types/array.mjs';
+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 { FromArray } from './from-array.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 (IsArray(type) ? FromArray(type.items) :
+        IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsObject(type) ? FromObject(type.properties) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        IsUnion(type) ? FromUnion(type.anyOf) :
+                            type);
+}

package/build/type/engine/readonly-type/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/readonly-type/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/readonly-type/index.d.mts

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

package/build/type/engine/readonly-type/index.mjs

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

package/build/type/engine/readonly-type/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 TReadonlyTypeDeferred } from '../../action/readonly-type.mjs';
+import { type TFromType } from './from-type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TReadonlyTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
+export type TReadonlyTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TReadonlyTypeImmediate<Context, State, Type> : TReadonlyTypeDeferred<Type>;
+export declare function ReadonlyTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TReadonlyTypeInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/readonly-type/instantiate.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { ReadonlyTypeDeferred } from '../../action/readonly-type.mjs';
+import { FromType } from './from-type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function ReadonlyTypeImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(FromType(instantiatedType), {}, options);
+}
+export function ReadonlyTypeInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? ReadonlyTypeImmediate(context, state, type, options)
+        : ReadonlyTypeDeferred(type, 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>;

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { EnumValuesToUnion } from '../enum/enum-to-union.mjs';
+import { FromKey } from './from-key.mjs';
+export function FromEnumKey(values, value) {
+    const unionKey = EnumValuesToUnion(values);
+    const result = FromKey(unionKey, value);
+    return result;
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TRecord, IntegerKey } from '../../types/record.mjs';
+export type TFromIntegerKey<Key extends TInteger, Value extends TSchema, Result extends TSchema = TRecord<typeof IntegerKey, Value>> = Result;
+export declare function FromIntegerKey<Key extends TInteger, Value extends TSchema>(key: Key, value: Value): TFromIntegerKey<Key, Value>;

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

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { IntegerKey } from '../../types/record.mjs';
+import { CreateRecord } from './record-create.mjs';
+export function FromIntegerKey(key, value) {
+    const result = CreateRecord(IntegerKey, value);
+    return result;
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TFromKey } from './from-key.mjs';
+export type TFromIntersectKey<Types extends TSchema[], Value extends TSchema, EvaluatedKey extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromKey<EvaluatedKey, Value>> = Result;
+export declare function FromIntersectKey<Types extends TSchema[], Value extends TSchema>(types: [...Types], value: Value): TFromIntersectKey<Types, Value>;

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { FromKey } from './from-key.mjs';
+export function FromIntersectKey(types, value) {
+    const evaluatedKey = EvaluateIntersect(types);
+    const result = FromKey(evaluatedKey, value);
+    return result;
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteralValue } from '../../types/literal.mjs';
+import { type TObject } from '../../types/object.mjs';
+export type TFromLiteralKey<Key extends TLiteralValue, Value extends TSchema, Result extends TSchema = (Key extends string | number ? TObject<{
+    [_ in Key]: Value;
+}> : Key extends false ? TObject<{
+    false: Value;
+}> : Key extends true ? TObject<{
+    true: Value;
+}> : TObject<{}>)> = Result;
+export declare function FromLiteralKey<Key extends TLiteralValue, Value extends TSchema>(key: Key, value: Value): TFromLiteralKey<Key, Value>;

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

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+export function FromLiteralKey(key, value) {
+    return (Guard.IsString(key) || Guard.IsNumber(key) ? Object({ [key]: value }) :
+        Guard.IsEqual(key, false) ? Object({ false: value }) :
+            Guard.IsEqual(key, true) ? Object({ true: value }) :
+                Object({}));
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TRecord, NumberKey } from '../../types/record.mjs';
+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/type/engine/record/from-key-number.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { NumberKey } from '../../types/record.mjs';
+import { CreateRecord } from './record-create.mjs';
+export function FromNumberKey(key, value) {
+    const result = CreateRecord(NumberKey, value);
+    return result;
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TRecord, StringKey } from '../../types/record.mjs';
+import { type TString } from '../../types/string.mjs';
+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/type/engine/record/from-key-string.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { StringKey } from '../../types/record.mjs';
+import { CreateRecord } from './record-create.mjs';
+export 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 (Guard.HasPropertyKey(key, 'pattern') && (Guard.IsString(key.pattern) || key.pattern instanceof RegExp)
+        ? CreateRecord(key.pattern.toString(), value)
+        : CreateRecord(StringKey, value));
+}

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

@@ -0,0 +1,8 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TFromKey } from './from-key.mjs';
+import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
+import { type TIsTemplateLiteralFinite } from '../template-literal/is-finite.mjs';
+import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
+export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<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/type/engine/record/from-key-template-literal.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { FromKey } from './from-key.mjs';
+import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
+import { IsTemplateLiteralFinite } from '../template-literal/is-finite.mjs';
+import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { CreateRecord } from './record-create.mjs';
+export function FromTemplateKey(pattern, value) {
+    const types = ParsePatternIntoTypes(pattern);
+    const finite = IsTemplateLiteralFinite(types);
+    const result = finite ? FromKey(TemplateLiteralDecode(pattern), value) : CreateRecord(pattern, value);
+    return result;
+}