@sinclair/typebox 0.32.0-dev-19 → 0.32.0-dev-21

package/build/require/type/readonly/readonly.js

@@ -4,8 +4,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Readonly = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
-/** `[Json]` Creates a Readonly property */
-function Readonly(schema) {
+const index_2 = require("../discard/index");
+const readonly_from_mapped_result_1 = require("./readonly-from-mapped-result");
+const type_2 = require("../guard/type");
+function RemoveReadonly(schema) {
+    return (0, index_2.Discard)((0, type_1.CloneType)(schema), [index_1.ReadonlyKind]);
+}
+function AddReadonly(schema) {
     return { ...(0, type_1.CloneType)(schema), [index_1.ReadonlyKind]: 'Readonly' };
 }
+// prettier-ignore
+function ReadonlyWithFlag(schema, F) {
+    return (F === false
+        ? RemoveReadonly(schema)
+        : AddReadonly(schema));
+}
+/** `[Json]` Creates a Readonly property */
+function Readonly(schema, enable) {
+    const F = enable ?? true;
+    return (0, type_2.IsMappedResult)(schema) ? (0, readonly_from_mapped_result_1.ReadonlyFromMappedResult)(schema, F) : ReadonlyWithFlag(schema, F);
+}
 exports.Readonly = Readonly;

package/build/require/type/record/record.d.ts

@@ -9,13 +9,13 @@ import { type TString } from '../string/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
 import { type TEnum } from '../enum/index';
-import { TTemplateLiteral, IsTemplateLiteralFinite } from '../template-literal/index';
+import { TTemplateLiteral, TIsTemplateLiteralFinite } from '../template-literal/index';
 import { Kind } from '../symbols/index';
 type FromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
 type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
     [_ in I]: T;
 }>>>);
-type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
+type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
 declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromTemplateLiteralKey<K, T>;
 type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
     [_ in K[keyof K]]: T;

package/build/require/type/record/record.js

@@ -38,8 +38,7 @@ function RecordCreateFromKeys(K, T, options) {
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    const expression = (0, index_4.TemplateLiteralParseExact)(K.pattern);
-    return ((0, index_4.IsTemplateLiteralFinite)(expression)
+    return ((0, index_4.IsTemplateLiteralFinite)(K)
         ? RecordCreateFromKeys((0, index_6.IndexPropertyKeys)(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }

package/build/require/type/schema/schema.d.ts

@@ -20,7 +20,7 @@ export interface SchemaOptions {
 export interface TKind {
     [Kind]: string;
 }
-export interface TSchema extends SchemaOptions, TKind {
+export interface TSchema extends TKind, SchemaOptions {
     [ReadonlyKind]?: string;
     [OptionalKind]?: string;
     [Hint]?: string;

package/build/require/type/symbol/symbol.d.ts

@@ -1,6 +1,6 @@
 import { TSchema, SchemaOptions } from '../schema/index';
 import { Kind } from '../symbols/index';
-export type SymbolValue = string | number | undefined;
+export type TSymbolValue = string | number | undefined;
 export interface TSymbol extends TSchema, SchemaOptions {
     [Kind]: 'Symbol';
     static: symbol;

package/build/require/type/template-literal/finite.d.ts

@@ -6,11 +6,13 @@ import type { TNumber } from '../number/index';
 import type { TInteger } from '../integer/index';
 import type { TBigInt } from '../bigint/index';
 import type { TLiteral } from '../literal/index';
-import type { Expression } from './parser';
+import type { Expression } from './parse';
 export declare class TemplateLiteralFiniteError extends Error {
 }
-type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
-type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<R> : true;
-export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
-export declare function IsTemplateLiteralFinite(expression: Expression): boolean;
+type FromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
+type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? FromTemplateLiteralKind<L> extends false ? false : FromTemplateLiteralKinds<R> : true;
+export declare function IsTemplateLiteralExpressionFinite(expression: Expression): boolean;
+export type TIsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? FromTemplateLiteralKinds<U> : false;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export declare function IsTemplateLiteralFinite<T extends TTemplateLiteral>(schema: T): boolean;
 export {};

package/build/require/type/template-literal/finite.js

@@ -1,7 +1,8 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsTemplateLiteralFinite = exports.TemplateLiteralFiniteError = void 0;
+exports.IsTemplateLiteralFinite = exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralFiniteError = void 0;
+const parse_1 = require("./parse");
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
@@ -33,13 +34,22 @@ function IsBooleanExpression(expression) {
 function IsStringExpression(expression) {
     return expression.type === 'const' && expression.const === '.*';
 }
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
 // prettier-ignore
-function IsTemplateLiteralFinite(expression) {
-    return (IsBooleanExpression(expression) ? true :
-        IsNumberExpression(expression) || IsStringExpression(expression) ? false :
-            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
-                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
+function IsTemplateLiteralExpressionFinite(expression) {
+    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+        IsBooleanExpression(expression) ? true :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
                     (expression.type === 'const') ? true :
                         (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
 }
+exports.IsTemplateLiteralExpressionFinite = IsTemplateLiteralExpressionFinite;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+function IsTemplateLiteralFinite(schema) {
+    const expression = (0, parse_1.TemplateLiteralParseExact)(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}
 exports.IsTemplateLiteralFinite = IsTemplateLiteralFinite;

package/build/require/type/template-literal/generate.d.ts

@@ -1,15 +1,21 @@
+import { TIsTemplateLiteralFinite } from './finite';
+import type { Assert } from '../helpers/index';
+import type { TBoolean } from '../boolean/index';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import type { TLiteral, TLiteralValue } from '../literal/index';
-import type { Expression } from './parser';
+import type { Expression } from './parse';
 import type { TUnion } from '../union/index';
+export declare class TemplateLiteralGenerateError extends Error {
+}
 type StringReduceUnary<L extends string, R extends string[]> = R extends [infer A extends string, ...infer B extends string[]] ? [`${L}${A}`, ...StringReduceUnary<L, B>] : [];
 type StringReduceBinary<L extends string[], R extends string[]> = L extends [infer A extends string, ...infer B extends string[]] ? [...StringReduceUnary<A, R>, ...StringReduceBinary<B, R>] : [];
 type StringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? StringReduceMany<[StringReduceBinary<L, R>, ...Rest]> : T;
-type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? O[0] : [];
-type TemplateLiteralReduceUnion<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TemplateLiteralReduceUnion<R>] : [];
-type TemplateLiteralReduce<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...TemplateLiteralReduce<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [TemplateLiteralReduceUnion<S>, ...TemplateLiteralReduce<R>] : [] : [];
-export declare class TemplateLiteralGenerateError extends Error {
-}
-export type TemplateLiteralGenerate<T> = T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TemplateLiteralReduce<S> extends infer R extends string[][] ? StringReduce<R> : [] : [];
-export declare function TemplateLiteralGenerate(expression: Expression): IterableIterator<string>;
+type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
+type FromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...FromTemplateLiteralUnionKinds<R>] : [];
+type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...FromTemplateLiteralKinds<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [FromTemplateLiteralUnionKinds<S>, ...FromTemplateLiteralKinds<R>] : L extends TBoolean ? [['true', 'false'], ...FromTemplateLiteralKinds<R>] : [
+]) : [];
+export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<S> extends infer R extends string[][] ? StringReduce<R> : [] : []) : [];
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export declare function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T): TTemplateLiteralGenerate<T>;
 export {};

package/build/require/type/template-literal/generate.js

@@ -1,9 +1,17 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralGenerate = exports.TemplateLiteralGenerateError = void 0;
+exports.TemplateLiteralGenerate = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerateError = void 0;
+const finite_1 = require("./finite");
+const parse_1 = require("./parse");
 // ------------------------------------------------------------------
-// GenerateFromExpression
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+class TemplateLiteralGenerateError extends Error {
+}
+exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
 // ------------------------------------------------------------------
 // prettier-ignore
 function* GenerateReduce(buffer) {
@@ -17,24 +25,18 @@ function* GenerateReduce(buffer) {
 }
 // prettier-ignore
 function* GenerateAnd(expression) {
-    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
 }
 // prettier-ignore
 function* GenerateOr(expression) {
     for (const expr of expression.expr)
-        yield* TemplateLiteralGenerate(expr);
+        yield* TemplateLiteralExpressionGenerate(expr);
 }
 // prettier-ignore
 function* GenerateConst(expression) {
     return yield expression.const;
 }
-// ------------------------------------------------------------------
-// TemplateLiteralGenerateError
-// ------------------------------------------------------------------
-class TemplateLiteralGenerateError extends Error {
-}
-exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
-function* TemplateLiteralGenerate(expression) {
+function* TemplateLiteralExpressionGenerate(expression) {
     return expression.type === 'and'
         ? yield* GenerateAnd(expression)
         : expression.type === 'or'
@@ -45,4 +47,13 @@ function* TemplateLiteralGenerate(expression) {
                     throw new TemplateLiteralGenerateError('Unknown expression');
                 })();
 }
+exports.TemplateLiteralExpressionGenerate = TemplateLiteralExpressionGenerate;
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+function TemplateLiteralGenerate(schema) {
+    const expression = (0, parse_1.TemplateLiteralParseExact)(schema.pattern);
+    // prettier-ignore
+    return ((0, finite_1.IsTemplateLiteralExpressionFinite)(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}
 exports.TemplateLiteralGenerate = TemplateLiteralGenerate;

package/build/require/type/template-literal/index.d.ts

@@ -1,7 +1,7 @@
 export * from './finite';
 export * from './generate';
 export * from './syntax';
-export * from './parser';
+export * from './parse';
 export * from './pattern';
 export * from './union';
 export * from './template-literal';

package/build/require/type/template-literal/index.js

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./finite"), exports);
 __exportStar(require("./generate"), exports);
 __exportStar(require("./syntax"), exports);
-__exportStar(require("./parser"), exports);
+__exportStar(require("./parse"), exports);
 __exportStar(require("./pattern"), exports);
 __exportStar(require("./union"), exports);
 __exportStar(require("./template-literal"), exports);

package/build/require/type/template-literal/{parser.js → parse.js}

@@ -132,17 +132,22 @@ function And(pattern) {
         (expressions.length === 1) ? expressions[0] :
             { type: 'and', expr: expressions });
 }
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
 /** Parses a pattern and returns an expression tree */
-// prettier-ignore
 function TemplateLiteralParse(pattern) {
+    // prettier-ignore
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
                 { type: 'const', const: pattern });
 }
 exports.TemplateLiteralParse = TemplateLiteralParse;
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
 /** Parses a pattern and strips forward and trailing ^ and $ */
-// prettier-ignore
 function TemplateLiteralParseExact(pattern) {
     return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }

package/build/require/type/template-literal/syntax.d.ts

@@ -14,7 +14,7 @@ type FromUnion<T extends string> = UnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
-export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

package/build/require/type/template-literal/syntax.js

@@ -53,7 +53,6 @@ function* FromSyntax(syntax) {
     }
     yield (0, index_1.Literal)(syntax);
 }
-// prettier-ignore
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];

package/build/require/type/template-literal/template-literal.d.ts

@@ -9,7 +9,7 @@ import type { TString } from '../string/index';
 import type { TBoolean } from '../boolean/index';
 import type { TNever } from '../never/index';
 import type { Static } from '../static/index';
-import { TemplateLiteralSyntax } from './syntax';
+import { TTemplateLiteralSyntax } from './syntax';
 import { EmptyString } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
@@ -24,7 +24,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     pattern: string;
 }
 /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
 /** `[Json]` Creates a TemplateLiteral type */
 export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
 export {};

package/build/require/type/template-literal/template-literal.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteral = void 0;
-const pattern_1 = require("./pattern");
 const syntax_1 = require("./syntax");
+const pattern_1 = require("./pattern");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a TemplateLiteral type */

package/build/require/type/template-literal/union.d.ts

@@ -3,5 +3,5 @@ import { type TUnion } from '../union/index';
 import { type TLiteral } from '../literal/index';
 import { type TString } from '../string/index';
 import { type TNever } from '../never/index';
-/** Resolves a template literal as a TUnion */
-export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;
+/** Returns a Union from the given TemplateLiteral */
+export declare function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/build/require/type/template-literal/union.js

@@ -4,19 +4,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralToUnion = void 0;
 const index_1 = require("../union/index");
 const index_2 = require("../literal/index");
-const index_3 = require("../string/index");
 const generate_1 = require("./generate");
-const parser_1 = require("./parser");
-const finite_1 = require("./finite");
 // ------------------------------------------------------------------
 // TemplateLiteralToUnion
 // ------------------------------------------------------------------
-/** Resolves a template literal as a TUnion */
-function TemplateLiteralToUnion(template) {
-    const expression = (0, parser_1.TemplateLiteralParseExact)(template.pattern);
-    if (!(0, finite_1.IsTemplateLiteralFinite)(expression))
-        return (0, index_3.String)();
-    const literals = [...(0, generate_1.TemplateLiteralGenerate)(expression)].map((value) => (0, index_2.Literal)(value));
-    return (0, index_1.Union)(literals);
+/** Returns a Union from the given TemplateLiteral */
+function TemplateLiteralToUnion(schema) {
+    const R = (0, generate_1.TemplateLiteralGenerate)(schema);
+    const L = R.map((S) => (0, index_2.Literal)(S));
+    return (0, index_1.Union)(L);
 }
 exports.TemplateLiteralToUnion = TemplateLiteralToUnion;

package/build/require/type/type/json.d.ts

@@ -22,10 +22,10 @@ import { type TMappedKey } from '../mapped/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
 import { type TOmit, type TOmitFromMappedKey } from '../omit/index';
-import { type TOptional } from '../optional/index';
+import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
 import { type TPick, type TPickFromMappedKey } from '../pick/index';
-import { type TReadonly } from '../readonly/index';
+import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TRecordOrObject } from '../record/index';
 import { type TRecursive, type TThis } from '../recursive/index';
@@ -34,7 +34,7 @@ import { type TRequired, type TRequiredFromMappedResult } from '../required/inde
 import { type TRest } from '../rest/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
 import { type TString, type StringOptions } from '../string/index';
-import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index';
 import { TransformDecodeBuilder } from '../transform/index';
 import { type TTuple } from '../tuple/index';
 import { Union } from '../union/index';
@@ -47,9 +47,21 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
-    /** `[Json]` Creates an Optional property */
-    Optional<T extends TSchema>(schema: T): TOptional<T>;
+    Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+    /** `[Json]` Creates a Optional property */
+    Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
     /** `[Json]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
     /** `[Json]` Creates an Array type */
@@ -145,7 +157,7 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
     /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Json]` Creates a Transform type */

package/build/require/type/type/json.js

@@ -60,12 +60,12 @@ class JsonTypeBuilder {
         return (0, index_28.ReadonlyOptional)(schema);
     }
     /** `[Json]` Creates a Readonly property */
-    Readonly(schema) {
-        return (0, index_27.Readonly)(schema);
+    Readonly(schema, enable) {
+        return (0, index_27.Readonly)(schema, enable ?? true);
     }
-    /** `[Json]` Creates an Optional property */
-    Optional(schema) {
-        return (0, index_24.Optional)(schema);
+    /** `[Json]` Creates a Optional property */
+    Optional(schema, enable) {
+        return (0, index_24.Optional)(schema, enable ?? true);
     }
     // ------------------------------------------------------------------------
     // Types

package/build/require/value/cast/cast.js

@@ -97,7 +97,7 @@ function Default(schema, references, value) {
 // ------------------------------------------------------------------
 // Cast
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_5.Clone)(value);
     const created = (0, index_1.IsArray)(value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
@@ -111,7 +111,7 @@ function TArray(schema, references, value) {
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_3.Create)(schema, references);
     const required = new Set(schema.returns.required || []);
@@ -123,15 +123,15 @@ function TConstructor(schema, references, value) {
     }
     return result;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const created = (0, index_3.Create)(schema, references);
     const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
     return (0, index_4.Check)(schema, references, mapped) ? mapped : (0, index_3.Create)(schema, references);
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
@@ -154,7 +154,7 @@ function TObject(schema, references, value) {
     }
     return result;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_5.Clone)(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
@@ -167,13 +167,13 @@ function TRecord(schema, references, value) {
     }
     return result;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_6.Deref)(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_6.Deref)(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_5.Clone)(value);
     if (!(0, index_1.IsArray)(value))
@@ -182,7 +182,7 @@ function TTuple(schema, references, value) {
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
@@ -193,25 +193,25 @@ function Visit(schema, references, value) {
         // Structural
         // --------------------------------------------------------------
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         // --------------------------------------------------------------
         // DefaultClone
         // --------------------------------------------------------------