typebox 1.0.45 → 1.0.47

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

@@ -20,6 +20,7 @@ export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
+export * from './readonly-type.mjs';
 export * from './required.mjs';
 export * from './return-type.mjs';
 export * from './uncapitalize.mjs';

package/build/type/action/index.mjs

@@ -20,6 +20,7 @@ export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
+export * from './readonly-type.mjs';
 export * from './required.mjs';
 export * from './return-type.mjs';
 export * from './uncapitalize.mjs';

package/build/type/action/readonly-type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export type TReadonlyTypeDeferred<Type extends TSchema> = (TDeferred<'ReadonlyType', [Type]>);
+/** Creates a deferred ReadonlyType action. */
+export declare function ReadonlyTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"ReadonlyType", [Type]>;
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export type TReadonlyType<Type extends TSchema> = (TInstantiate<{}, TReadonlyTypeDeferred<Type>>);
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export declare function ReadonlyType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyType<Type>;

package/build/type/action/readonly-type.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export function ReadonlyTypeDeferred(type, options = {}) {
+    return Deferred('ReadonlyType', [type], options);
+}
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export function ReadonlyType(type, options = {}) {
+    return Instantiate({}, ReadonlyTypeDeferred(type, options));
+}

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

@@ -23,6 +23,7 @@ export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
+export * from './readonly-type/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';

package/build/type/engine/index.mjs

@@ -29,6 +29,7 @@ export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
+export * from './readonly-type/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';

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

@@ -42,6 +42,7 @@ import { type TOptionsInstantiate } from './options/instantiate.mjs';
 import { type TParametersInstantiate } from './parameters/instantiate.mjs';
 import { type TPartialInstantiate } from './partial/instantiate.mjs';
 import { type TPickInstantiate } from './pick/instantiate.mjs';
+import { type TReadonlyTypeInstantiate } from './readonly-type/instantiate.mjs';
 import { type TRecordInstantiate } from './record/instantiate.mjs';
 import { type TRefInstantiate } from './ref/instantiate.mjs';
 import { type TRequiredInstantiate } from './required/instantiate.mjs';
@@ -136,6 +137,9 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
     Action,
     Parameters
+] extends ['ReadonlyType', [infer Type extends TSchema]] ? TReadonlyTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
 ] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [
     Action,
     Parameters

package/build/type/engine/instantiate.mjs

@@ -55,6 +55,7 @@ import { OptionsInstantiate } from './options/instantiate.mjs';
 import { ParametersInstantiate } from './parameters/instantiate.mjs';
 import { PartialInstantiate } from './partial/instantiate.mjs';
 import { PickInstantiate } from './pick/instantiate.mjs';
+import { ReadonlyTypeInstantiate } from './readonly-type/instantiate.mjs';
 import { RecordInstantiate } from './record/instantiate.mjs';
 import { RefInstantiate } from './ref/instantiate.mjs';
 import { RequiredInstantiate } from './required/instantiate.mjs';
@@ -131,13 +132,14 @@ function InstantiateDeferred(context, state, action, parameters, options) {
                                                                         Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
                                                                             Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
                                                                                 Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                    Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                        Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
-                                                                                            Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
-                                                                                                Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
-                                                                                                    Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
-                                                                                                        Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
-                                                                                                            Deferred(action, parameters, options));
+                                                                                    Guard.IsEqual(action, 'ReadonlyType') ? ReadonlyTypeInstantiate(context, state, parameters[0], options) :
+                                                                                        Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                            Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
+                                                                                                Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
+                                                                                                    Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
+                                                                                                        Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
+                                                                                                            Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
+                                                                                                                Deferred(action, parameters, options));
 }
 export function InstantiateType(context, state, input) {
     const isImmutable = IsImmutable(input);

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/script/mapping.d.mts

@@ -64,6 +64,9 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
 ] extends ['Pick', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TPickDeferred<Type, Indexer> : [
     Target,
     Parameters
+] extends ['Readonly', [infer Type extends T.TSchema]] ? C.TReadonlyTypeDeferred<Type> : [
+    Target,
+    Parameters
 ] extends ['Record', [infer Key extends T.TSchema, infer Value extends T.TSchema]] ? T.TRecordDeferred<Key, Value> : [
     Target,
     Parameters

package/build/type/types/_readonly.d.mts

@@ -1,16 +1,16 @@
 import { type TSchema } from './schema.mjs';
-/** Removes Readaonly from the given type. */
+/** Removes a Readonly property modifier from the given type. */
 export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes Readaonly from the given type. */
+/** Removes a Readonly property modifier from the given type. */
 export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
-/** Adds Readonly to the given type. */
+/** Adds a Readonly property modifier to the given type. */
 export type TReadonlyAdd<Type extends TSchema = TSchema> = ('~readonly' extends keyof Type ? Type : TReadonly<Type>);
-/** Adds Readonly to the given type. */
+/** Adds a Readonly property modifier to the given type. */
 export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
 export type TReadonly<Type extends TSchema = TSchema> = (Type & {
     '~readonly': true;
 });
-/** Applies an Readonly modifier to the given type. */
+/** Applies an Readonly property modifier to the given type. */
 export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
 /** Returns true if the given value is a TReadonly */
 export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

package/build/type/types/_readonly.mjs

@@ -2,18 +2,18 @@
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes Readaonly from the given type. */
+/** Removes a Readonly property modifier from the given type. */
 export function ReadonlyRemove(type) {
     return Memory.Discard(type, ['~readonly']);
 }
-/** Adds Readonly to the given type. */
+/** Adds a Readonly property modifier to the given type. */
 export function ReadonlyAdd(type) {
     return Memory.Update(type, { '~readonly': true }, {});
 }
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
-/** Applies an Readonly modifier to the given type. */
+/** Applies an Readonly property modifier to the given type. */
 export function Readonly(type) {
     return ReadonlyAdd(type);
 }

package/build/type/types/template-literal.d.mts

@@ -14,11 +14,13 @@ export interface TTemplateLiteral<Pattern extends string = string> extends TSche
 export type TTemplateLiteralDeferred<Types extends TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
 /** Creates a deferred TemplateLiteral action. */
 export declare function TemplateLiteralDeferred<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralDeferred<Types>;
-export type TTemplateLiteralConstruct<Types extends TSchema[]> = (TInstantiate<{}, TTemplateLiteralDeferred<Types>>);
-export declare function TemplateLiteralConstruct<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralConstruct<Types>;
+export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TInstantiate<{}, TTemplateLiteralDeferred<Types>>> = Result;
+export declare function TemplateLiteralFromTypes<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralFromTypes<Types>;
+export type TTemplateLiteralFromString<Template extends string, Types extends TSchema[] = TParseTemplateIntoTypes<Template>, Result extends TSchema = TTemplateLiteralFromTypes<Types>> = Result;
+export declare function TemplateLiteralFromString<Template extends string>(template: Template): TTemplateLiteralFromString<Template>;
 /** Creates a TemplateLiteral type. */
-export declare function TemplateLiteral<Template extends string>(template: Template, options?: TSchemaOptions): TTemplateLiteralConstruct<TParseTemplateIntoTypes<Template>>;
+export declare function TemplateLiteral<Template extends string>(template: Template, options?: TSchemaOptions): TTemplateLiteralFromString<Template>;
 /** Creates a TemplateLiteral type. */
-export declare function TemplateLiteral<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralConstruct<Types>;
+export declare function TemplateLiteral<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralFromTypes<Types>;
 /** Returns true if the given value is TTemplateLiteral. */
 export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral;

package/build/type/types/template-literal.mjs

@@ -5,17 +5,22 @@ import { IsKind } from './schema.mjs';
 import { Deferred } from './deferred.mjs';
 import { ParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';
+import { Memory } from '../../system/system.mjs';
 /** Creates a deferred TemplateLiteral action. */
 export function TemplateLiteralDeferred(types, options = {}) {
     return Deferred('TemplateLiteral', [types], options);
 }
-export function TemplateLiteralConstruct(types, options = {}) {
-    return Instantiate({}, TemplateLiteralDeferred(types, options));
+export function TemplateLiteralFromTypes(types) {
+    return Instantiate({}, TemplateLiteralDeferred(types, {}));
+}
+export function TemplateLiteralFromString(template) {
+    const types = ParseTemplateIntoTypes(template);
+    return TemplateLiteralFromTypes(types);
 }
 /** Creates a TemplateLiteral type. */
 export function TemplateLiteral(input, options = {}) {
-    const types = Guard.IsString(input) ? ParseTemplateIntoTypes(input) : input;
-    return TemplateLiteralConstruct(types, options);
+    const type = Guard.IsString(input) ? TemplateLiteralFromString(input) : TemplateLiteralFromTypes(input);
+    return Memory.Update(type, {}, options);
 }
 // ------------------------------------------------------------------
 // Guard

package/build/typebox.d.mts

@@ -21,6 +21,7 @@ export { Options, type TOptions } from './type/action/options.mjs';
 export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters.mjs';
 export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial.mjs';
 export { Pick, type TPick, type TPickDeferred } from './type/action/pick.mjs';
+export { ReadonlyType, type TReadonlyType, type TReadonlyTypeDeferred } from './type/action/readonly-type.mjs';
 export { Required, type TRequired, type TRequiredDeferred } from './type/action/required.mjs';
 export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return-type.mjs';
 export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';

package/build/typebox.mjs

@@ -33,6 +33,7 @@ export { Options } from './type/action/options.mjs';
 export { Parameters } from './type/action/parameters.mjs';
 export { Partial } from './type/action/partial.mjs';
 export { Pick } from './type/action/pick.mjs';
+export { ReadonlyType } from './type/action/readonly-type.mjs';
 export { Required } from './type/action/required.mjs';
 export { ReturnType } from './type/action/return-type.mjs';
 export { Uncapitalize } from './type/action/uncapitalize.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "keywords": [
     "typescript",
     "jsonschema"