@valbuild/core 0.96.2 → 0.97.0

package/dist/declarations/src/index.d.ts

@@ -47,6 +47,7 @@ export { type SerializedBooleanSchema, BooleanSchema } from "./schema/boolean.js
 export { type SerializedImageSchema, ImageSchema } from "./schema/image.js";
 export { type SerializedFileSchema, FileSchema } from "./schema/file.js";
 export { type SerializedDateSchema, DateSchema } from "./schema/date.js";
+export { type SerializedDateTimeSchema, DateTimeSchema, } from "./schema/datetime.js";
 export { type SerializedKeyOfSchema, KeyOfSchema } from "./schema/keyOf.js";
 export { type SerializedRouteSchema, RouteSchema } from "./schema/route.js";
 export { type SerializedRichTextSchema, RichTextSchema, } from "./schema/richtext.js";

package/dist/declarations/src/initSchema.d.ts

@@ -12,6 +12,7 @@ import { record } from "./schema/record.js";
 import { file } from "./schema/file.js";
 import { files } from "./schema/files.js";
 import { date } from "./schema/date.js";
+import { datetime } from "./schema/datetime.js";
 import { route } from "./schema/route.js";
 import { router } from "./schema/router.js";
 import { images } from "./schema/images.js";
@@ -161,6 +162,17 @@ export type InitSchema = {
      *
      */
     readonly date: typeof date;
+    /**
+     * Define a date and time.
+     *
+     * Stored as an ISO 8601 datetime string (UTC).
+     *
+     * @example
+     * const schema = s.datetime();
+     * export default c.define("/example.val.ts", schema, "2025-01-01T12:00:00.000Z");
+     *
+     */
+    readonly datetime: typeof datetime;
     /**
      * Define a string that references a route path in your application.
      *
@@ -270,6 +282,7 @@ export declare function initSchema(): {
         mimeType: string;
     }>, import("./schema/index.js").Schema<string>, Record<string, import("./schema/files.js").FilesEntryMetadata>>;
     date: (options?: Record<string, never>) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
+    datetime: (options?: Record<string, never>) => import("./schema/datetime.js").DateTimeSchema<import("./schema/string.js").RawString>;
     route: <T extends string>(options?: Record<string, never>) => import("./schema/route.js").RouteSchema<T>;
     router: typeof router;
     images: <Accept extends `image/${string}`>(options: import("./schema/images.js").ImagesOptions<Accept>) => import("./schema/record.js").RecordSchema<import("./schema/object.js").ObjectSchema<{

package/dist/declarations/src/schema/array.d.ts

@@ -9,16 +9,25 @@ export type SerializedArraySchema = {
     item: SerializedSchema;
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends SelectorOfSchema<T>[] | null> extends Schema<Src> {
     private readonly item;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(item: T, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(item: T, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): ArraySchema<T, Src>;
     validate(validationFunction: (src: Src) => false | string): ArraySchema<T, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): ArraySchema<T, Src | null>;
+    readonly(): ArraySchema<T, Src>;
+    hidden(): ArraySchema<T, Src>;
     protected executeSerialize(): SerializedArraySchema;
     private renderInput;
     protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;

package/dist/declarations/src/schema/boolean.d.ts

@@ -6,15 +6,24 @@ export type SerializedBooleanSchema = {
     type: "boolean";
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class BooleanSchema<Src extends boolean | null> extends Schema<Src> {
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): BooleanSchema<Src>;
     validate(validationFunction: (src: Src) => false | string): BooleanSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): BooleanSchema<Src | null>;
+    readonly(): BooleanSchema<Src>;
+    hidden(): BooleanSchema<Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/date.d.ts

@@ -24,18 +24,27 @@ export type SerializedDateSchema = {
     options?: DateOptions;
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class DateSchema<Src extends string | null> extends Schema<Src> {
     private readonly options?;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(options?: DateOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options?: DateOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): DateSchema<Src>;
     validate(validationFunction: (src: Src) => false | string): DateSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     from(from: string): DateSchema<Src>;
     to(to: string): DateSchema<Src>;
     nullable(): DateSchema<Src | null>;
+    readonly(): DateSchema<Src>;
+    hidden(): DateSchema<Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/datetime.d.ts

@@ -0,0 +1,56 @@
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { ReifiedRender } from "../render.js";
+import { SourcePath } from "../val/index.js";
+import { RawString } from "./string.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
+type DateTimeOptions = {
+    /**
+     * Validate that the datetime is this datetime or after (inclusive).
+     *
+     * Accepts any ISO 8601 datetime string parseable by `Date.parse`.
+     *
+     * @example
+     * 2021-01-01T00:00:00Z
+     */
+    from?: string;
+    /**
+     * Validate that the datetime is this datetime or before (inclusive).
+     *
+     * Accepts any ISO 8601 datetime string parseable by `Date.parse`.
+     *
+     * @example
+     * 2021-12-31T23:59:59Z
+     */
+    to?: string;
+};
+export type SerializedDateTimeSchema = {
+    type: "dateTime";
+    options?: DateTimeOptions;
+    opt: boolean;
+    customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
+};
+export declare class DateTimeSchema<Src extends string | null> extends Schema<Src> {
+    private readonly options?;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options?: DateTimeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): DateTimeSchema<Src>;
+    validate(validationFunction: (src: Src) => false | string): DateTimeSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    from(from: string): DateTimeSchema<Src>;
+    to(to: string): DateTimeSchema<Src>;
+    nullable(): DateTimeSchema<Src | null>;
+    readonly(): DateTimeSchema<Src>;
+    hidden(): DateTimeSchema<Src>;
+    protected executeSerialize(): SerializedSchema;
+    protected executeRender(): ReifiedRender;
+}
+export declare const datetime: (options?: Record<string, never>) => DateTimeSchema<RawString>;
+export {};

package/dist/declarations/src/schema/file.d.ts

@@ -16,6 +16,9 @@ export type SerializedFileSchema = {
     opt: boolean;
     customValidate?: boolean;
     referencedModule?: string;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export type FileMetadata = {
     mimeType?: string;
@@ -26,12 +29,18 @@ export declare class FileSchema<Src extends FileSource<FileMetadata | undefined>
     protected readonly isRemote: boolean;
     private readonly customValidateFunctions;
     private readonly moduleMetadata;
-    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FilesEntryMetadata>>);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FilesEntryMetadata>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): FileSchema<Src>;
     remote(): FileSchema<Src | RemoteSource<FileMetadata | undefined>>;
     validate(validationFunction: CustomValidateFunction<Src>): FileSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): FileSchema<Src | null>;
+    readonly(): FileSchema<Src>;
+    hidden(): FileSchema<Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/image.d.ts

@@ -20,6 +20,9 @@ export type SerializedImageSchema = {
     remote?: boolean;
     customValidate?: boolean;
     referencedModule?: string;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export type ImageMetadata = {
     width?: number;
@@ -37,12 +40,18 @@ export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefine
     protected readonly isRemote: boolean;
     private readonly customValidateFunctions;
     private readonly moduleMetadata;
-    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagesEntryMetadata>>);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagesEntryMetadata>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): ImageSchema<Src>;
     remote(): ImageSchema<Src | RemoteSource<ImageMetadata | undefined>>;
     validate(validationFunction: CustomValidateFunction<Src>): ImageSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): ImageSchema<Src | null>;
+    readonly(): ImageSchema<Src>;
+    hidden(): ImageSchema<Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/index.d.ts

@@ -13,12 +13,13 @@ import { SerializedRichTextSchema } from "./richtext.js";
 import { RawString, SerializedStringSchema } from "./string.js";
 import { SerializedUnionSchema } from "./union.js";
 import { SerializedDateSchema } from "./date.js";
+import { SerializedDateTimeSchema } from "./datetime.js";
 import { SerializedRouteSchema } from "./route.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 import { FileSource } from "../source/file.js";
 import { GenericRichTextSourceNode, RichTextSource } from "../source/richtext.js";
 import { ReifiedRender } from "../render.js";
-export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedRouteSchema | SerializedImageSchema;
+export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedDateTimeSchema | SerializedRouteSchema | SerializedImageSchema;
 type Primitives = number | string | boolean | null | FileSource;
 export type AssertError = {
     message: string;
@@ -67,6 +68,20 @@ export declare abstract class Schema<Src extends SelectorSource> {
      */
     protected abstract executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     abstract nullable(): Schema<Src | null>;
+    /**
+     * Mark this field as read-only in the Val editor.
+     *
+     * This is a UI-only flag: the field is rendered disabled in the editor, but
+     * the value is not otherwise validated or enforced differently.
+     */
+    abstract readonly(): Schema<Src>;
+    /**
+     * Hide this field from the Val editor.
+     *
+     * This is a UI-only flag: the field is not rendered in the editor, but the
+     * value is still stored, validated and serialized as normal.
+     */
+    abstract hidden(): Schema<Src>;
     protected abstract executeSerialize(): SerializedSchema;
     protected abstract executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
     /** MUTATES! since internal and perf sensitive */

package/dist/declarations/src/schema/keyOf.d.ts

@@ -13,6 +13,9 @@ export type SerializedKeyOfSchema = {
     opt: boolean;
     values: "string" | string[];
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 type SerializedRefSchema = {
     type: "object";
@@ -28,11 +31,17 @@ export declare class KeyOfSchema<Sel extends GenericSelector<SourceObject>, Src
     private readonly sourcePath?;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(schema?: SerializedRefSchema | undefined, sourcePath?: SourcePath | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(schema?: SerializedRefSchema | undefined, sourcePath?: SourcePath | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): KeyOfSchema<Sel, Src>;
     validate(validationFunction: (src: Src) => false | string): KeyOfSchema<Sel, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): KeyOfSchema<Sel, Src | null>;
+    readonly(): KeyOfSchema<Sel, Src>;
+    hidden(): KeyOfSchema<Sel, Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/literal.d.ts

@@ -7,16 +7,25 @@ export type SerializedLiteralSchema = {
     value: string;
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class LiteralSchema<Src extends string | null> extends Schema<Src> {
     private readonly value;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(value: string, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(value: string, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): LiteralSchema<Src>;
     validate(validationFunction: (src: Src) => false | string): LiteralSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): LiteralSchema<Src | null>;
+    readonly(): LiteralSchema<Src>;
+    hidden(): LiteralSchema<Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/number.d.ts

@@ -11,16 +11,25 @@ export type SerializedNumberSchema = {
     options?: NumberOptions;
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class NumberSchema<Src extends number | null> extends Schema<Src> {
     private readonly options?;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): NumberSchema<Src>;
     validate(validationFunction: (src: Src) => false | string): NumberSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): NumberSchema<Src | null>;
+    readonly(): NumberSchema<Src>;
+    hidden(): NumberSchema<Src>;
     max(max: number): NumberSchema<Src>;
     min(min: number): NumberSchema<Src>;
     protected executeSerialize(): SerializedSchema;

package/dist/declarations/src/schema/object.d.ts

@@ -8,6 +8,9 @@ export type SerializedObjectSchema = {
     items: Record<string, SerializedSchema>;
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 type ObjectSchemaProps = {
     [key: string]: Schema<SelectorSource>;
@@ -36,11 +39,17 @@ export declare class ObjectSchema<Props extends ObjectSchemaProps, Src extends O
     private readonly items;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(items: Props, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(items: Props, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): ObjectSchema<Props, Src>;
     validate(validationFunction: (src: Src) => false | string): ObjectSchema<Props, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): ObjectSchema<Props, Src | null>;
+    readonly(): ObjectSchema<Props, Src>;
+    hidden(): ObjectSchema<Props, Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
 }

package/dist/declarations/src/schema/record.d.ts

@@ -26,6 +26,9 @@ export type SerializedRecordSchema = {
     directory?: string;
     remote?: boolean;
     alt?: SerializedSchema;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Schema<string>, Src extends Record<SelectorOfSchema<K>, SelectorOfSchema<T>> | null> extends Schema<Src> {
     private readonly item;
@@ -34,7 +37,11 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
     private readonly currentRouter;
     private readonly keySchema;
     private readonly mediaOptions?;
-    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null, keySchema?: Schema<string> | null, mediaOptions?: MediaOptions | undefined);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null, keySchema?: Schema<string> | null, mediaOptions?: MediaOptions | undefined, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): RecordSchema<T, K, Src>;
     validate(validationFunction: (src: Src) => false | string): RecordSchema<T, K, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     private isRemoteUrl;
@@ -43,6 +50,8 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
     private validateMediaMimeType;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): RecordSchema<T, K, Src | null>;
+    readonly(): RecordSchema<T, K, Src>;
+    hidden(): RecordSchema<T, K, Src>;
     router(router: ValRouter): RecordSchema<T, K, Src>;
     remote(): RecordSchema<T, K, Src>;
     private getRouterValidations;

package/dist/declarations/src/schema/richtext.d.ts

@@ -12,12 +12,19 @@ export type SerializedRichTextSchema = {
     opt: boolean;
     options?: SerializedRichTextOptions & ValidationOptions;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class RichTextSchema<O extends RichTextOptions, Src extends RichTextSource<O> | null> extends Schema<Src> {
     private readonly options;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): RichTextSchema<O, Src>;
     maxLength(max: number): RichTextSchema<O, Src>;
     minLength(min: number): RichTextSchema<O, Src>;
     validate(validationFunction: (src: Src) => false | string): RichTextSchema<O, Src>;
@@ -26,6 +33,8 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     private recursiveAssert;
     nullable(): RichTextSchema<O, Src | null>;
+    readonly(): RichTextSchema<O, Src>;
+    hidden(): RichTextSchema<O, Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/route.d.ts

@@ -21,12 +21,19 @@ export type SerializedRouteSchema = {
     };
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export declare class RouteSchema<Src extends string | null> extends Schema<Src> {
     private readonly options?;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(options?: RouteOptions | undefined, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[]);
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    constructor(options?: RouteOptions | undefined, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): RouteSchema<Src>;
     /**
      * Specify a pattern for which routes are allowed.
      *
@@ -57,6 +64,8 @@ export declare class RouteSchema<Src extends string | null> extends Schema<Src>
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): RouteSchema<Src | null>;
+    readonly(): RouteSchema<Src>;
+    hidden(): RouteSchema<Src>;
     protected executeSerialize(): SerializedSchema;
     protected executeRender(): ReifiedRender;
 }

package/dist/declarations/src/schema/string.d.ts

@@ -23,6 +23,9 @@ export type SerializedStringSchema = {
     opt: boolean;
     raw: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 declare const brand: unique symbol;
 export type RawString = string & {
@@ -34,12 +37,16 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     private readonly isRaw;
     private readonly customValidateFunctions;
     private readonly renderInput;
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
     constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], renderInput?: {
         as: "textarea";
     } | {
         as: "code";
         language: CodeLanguage;
-    } | null);
+    } | null, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    describe(description: string | null): StringSchema<Src>;
     /**
      * @deprecated Use `minLength` instead
      */
@@ -55,6 +62,8 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): StringSchema<Src | null>;
+    readonly(): StringSchema<Src>;
+    hidden(): StringSchema<Src>;
     raw(): StringSchema<Src extends null ? RawString | null : RawString>;
     protected executeSerialize(): SerializedSchema;
     render(input: {

package/dist/declarations/src/schema/union.d.ts

@@ -13,6 +13,9 @@ export type SerializedStringUnionSchema = {
     items: SerializedLiteralSchema[];
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 export type SerializedObjectUnionSchema = {
     type: "union";
@@ -20,6 +23,9 @@ export type SerializedObjectUnionSchema = {
     items: SerializedObjectSchema[];
     opt: boolean;
     customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
 };
 type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
     [k in Key]: string;
@@ -31,12 +37,18 @@ export declare class UnionSchema<Key extends string | Schema<string>, T extends
     private readonly items;
     private readonly opt;
     private readonly customValidateFunctions;
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    describe(description: string | null): UnionSchema<Key, T, Src>;
     validate(validationFunction: (src: Src) => false | string): UnionSchema<Key, T, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): UnionSchema<Key, T, Src | null>;
+    readonly(): UnionSchema<Key, T, Src>;
+    hidden(): UnionSchema<Key, T, Src>;
     protected executeSerialize(): SerializedSchema;
-    constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
     protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
 }
 export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => UnionSchema<Key, T, SourceOf<Key, T>>;