@valbuild/core 0.125.0 → 0.127.0

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

@@ -59,10 +59,11 @@ export type FieldRender = InlineRender;
  * question, and a disagreement between them is a row you can edit in place but
  * that "add" navigates away from.
  *
- * A tagged union counts as inline when the union itself declares it OR when
- * ANY of its variants does. A page-builder list is `s.array(s.union("type",
- * block, block, ...))` and the natural place to write the render is on the
- * blocks, one per block type — the union is a dispatch, not something the
+ * A discriminated union counts as inline when the union itself declares it OR
+ * when ANY of its variants does. A page-builder list is
+ * `s.array(s.discriminatedUnion("type", block, block, ...))` and the natural
+ * place to write the render is on the blocks, one per block type — the union
+ * is a dispatch, not something the
  * author thinks of as the field. `some` rather than `every` because the row
  * draws the union's own editor (the tag selector plus the matched variant's
  * fields), which handles every variant either way: with `every`, adding one

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

@@ -38,13 +38,57 @@ export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends S
     private readonly previewInput;
     private readonly renderInput;
     constructor(item: T, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, renderInput?: FieldRender | null);
+    /**
+     * Describe this field.
+     *
+     * The description is shown next to the field's label in the Val editor, so
+     * it is where you say what an editor needs to know but the field name cannot
+     * carry. It also travels in the serialized schema, which is what the AI
+     * assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s
+     *   .array(s.string())
+     *   .describe("Bullet points shown under the heading");
+     * export default c.define("/example.val.ts", schema, ["First", "Second"]);
+     */
     describe(description: string | null): ArraySchema<T, Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * The function is given the whole array. To validate one item, put a
+     * `.validate(...)` on the ITEM schema instead — that reports the error on
+     * the item's own row.
+     *
+     * @example
+     * const schema = s.array(s.string()).validate((val) =>
+     *   val.length <= 3 ? false : "At most 3 items",
+     * );
+     * export default c.define("/example.val.ts", schema, ["First", "Second"]);
+     */
     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(isReadonly?: boolean): ArraySchema<T, Src>;
     hidden(isHidden?: boolean): ArraySchema<T, Src>;
+    protected localeScopeChildren(): {
+        key: string;
+        schema: Schema<SelectorSource>;
+    }[];
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeSerialize(): SerializedArraySchema;
     protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: PreviewScope): ReifiedPreview;
@@ -55,6 +99,25 @@ export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends S
      * is the item of another container, in search, in references. What its rows
      * show is the ITEM schema's `preview`, not this. Never how the field is
      * edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * // The preview of the ARRAY, for where it is an item of something else.
+     * // What its own rows show is the ITEM schema's preview — see below.
+     * const tags = s.array(s.string()).preview(({ val }) => ({
+     *   title: `${val.length} tags`,
+     * }));
+     * export default c.define("/example.val.ts", s.record(tags), {
+     *   "a-post": ["news", "release"],
+     * });
+     *
+     * @example
+     * // Rows of an array come from the ITEM's preview, not the array's:
+     * const author = s
+     *   .object({ name: s.string(), role: s.string() })
+     *   .preview(({ val }) => ({ title: val.name, subtitle: val.role }));
+     * export default c.define("/example.val.ts", s.array(author), [
+     *   { name: "Ada", role: "Engineer" },
+     * ]);
      */
     preview(select: ItemPreviewInput<Src>): ArraySchema<T, Src>;
     /**
@@ -63,6 +126,12 @@ export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends S
      * instead of a preview row that navigates to it.
      *
      * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.record(s.array(s.string()).render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, {
+     *   "a-post": ["news", "release"],
+     * });
      */
     render(input: FieldRender): ArraySchema<T, Src>;
 }

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

@@ -24,7 +24,41 @@ export declare class BooleanSchema<Src extends boolean | null> extends Schema<Sr
     private readonly renderInput;
     private readonly previewInput;
     constructor(opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    /**
+     * Describe this field.
+     *
+     * The description is shown next to the field's label in the Val editor, so
+     * it is where you say what an editor needs to know but the field name cannot
+     * carry. It also travels in the serialized schema, which is what the AI
+     * assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s.boolean().describe("Show this item in the main menu");
+     * export default c.define("/example.val.ts", schema, true);
+     */
     describe(description: string | null): BooleanSchema<Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * @example
+     * const schema = s.boolean().validate((val) =>
+     *   val === true ? false : "This has to be on for now",
+     * );
+     * export default c.define("/example.val.ts", schema, true);
+     */
     validate(validationFunction: (src: Src) => false | string): BooleanSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
@@ -38,12 +72,22 @@ export declare class BooleanSchema<Src extends boolean | null> extends Schema<Sr
      * instead of a preview row that navigates to it.
      *
      * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.boolean().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, [true, false]);
      */
     render(input: FieldRender): BooleanSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field
      * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.boolean().preview(({ val }) => ({ title: val ? "On" : "Off" })),
+     * );
+     * export default c.define("/example.val.ts", schema, [true, false]);
      */
     preview(select: ItemPreviewInput<Src>): BooleanSchema<Src>;
     protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;

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

@@ -55,7 +55,52 @@ export declare class CodeSchema<Src extends string | null> extends Schema<Src> {
     private readonly renderInput;
     private readonly previewInput;
     constructor(options?: CodeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    /**
+     * Describe this field.
+     *
+     * The description is shown next to the field's label in the Val editor, so
+     * it is where you say what an editor needs to know but the field name cannot
+     * carry. It also travels in the serialized schema, which is what the AI
+     * assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s
+     *   .code({ language: "css" })
+     *   .describe("Injected into the page head — keep it small");
+     * export default c.define(
+     *   "/example.val.ts",
+     *   schema,
+     *   ".hero { color: red; }",
+     * );
+     */
     describe(description: string | null): CodeSchema<Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * @example
+     * const schema = s.code({ language: "json" }).validate((val) => {
+     *   try {
+     *     JSON.parse(val);
+     *     return false;
+     *   } catch {
+     *     return "Must be valid JSON";
+     *   }
+     * });
+     * export default c.define("/example.val.ts", schema, '{ "a": 1 }');
+     */
     validate(validationFunction: (src: Src) => false | string): CodeSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
@@ -69,12 +114,30 @@ export declare class CodeSchema<Src extends string | null> extends Schema<Src> {
      * instead of a preview row that navigates to it.
      *
      * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.code({ language: "css" }).render({ as: "inline" }),
+     * );
+     * export default c.define("/example.val.ts", schema, [
+     *   ".hero { color: red; }",
+     * ]);
      */
     render(input: FieldRender): CodeSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field
      * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.code({ language: "css" }).preview(({ val }) => ({
+     *     title: val.split("\n")[0],
+     *   })),
+     * );
+     * export default c.define("/example.val.ts", schema, [
+     *   ".hero { color: red; }",
+     * ]);
      */
     preview(select: ItemPreviewInput<Src>): CodeSchema<Src>;
     protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;

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

@@ -50,7 +50,47 @@ export declare class ColorSchema<Src extends string | null> extends Schema<Src>
     private readonly renderInput;
     private readonly previewInput;
     constructor(options?: ColorOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    /**
+     * Describe this field.
+     *
+     * The description is shown next to the field's label in the Val editor, so
+     * it is where you say what an editor needs to know but the field name cannot
+     * carry. It also travels in the serialized schema, which is what the AI
+     * assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s.color().describe("Background of the hero section");
+     * export default c.define(
+     *   "/example.val.ts",
+     *   schema,
+     *   "hsl(217.22 91.22% 59.8%)",
+     * );
+     */
     describe(description: string | null): ColorSchema<Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * @example
+     * const schema = s
+     *   .color({ format: "hex" })
+     *   .validate((val) =>
+     *     val === val.toLowerCase() ? false : "Write hex in lower case",
+     *   );
+     * export default c.define("/example.val.ts", schema, "#3b82f6");
+     */
     validate(validationFunction: (src: Src) => false | string): ColorSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
@@ -64,12 +104,26 @@ export declare class ColorSchema<Src extends string | null> extends Schema<Src>
      * instead of a preview row that navigates to it.
      *
      * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.color().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, [
+     *   "hsl(217.22 91.22% 59.8%)",
+     * ]);
      */
     render(input: FieldRender): ColorSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field
      * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.color().preview(({ val }) => ({ title: val })),
+     * );
+     * export default c.define("/example.val.ts", schema, [
+     *   "hsl(217.22 91.22% 59.8%)",
+     * ]);
      */
     preview(select: ItemPreviewInput<Src>): ColorSchema<Src>;
     protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;

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

@@ -9,14 +9,14 @@ type DateOptions = {
      * Validate that the date is this date or after (inclusive).
      *
      * @example
-     * 2021-01-01
+     * "2021-01-01"
      */
     from?: string;
     /**
      * Validate that the date is this date or before (inclusive).
      *
      * @example
-     * 2021-01-01
+     * "2021-01-01"
      */
     to?: string;
 };
@@ -43,11 +43,63 @@ export declare class DateSchema<Src extends string | null> extends Schema<Src> {
     private readonly renderInput;
     private readonly previewInput;
     constructor(options?: DateOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    /**
+     * Describe this field.
+     *
+     * The description is shown next to the field's label in the Val editor, so
+     * it is where you say what an editor needs to know but the field name cannot
+     * carry. It also travels in the serialized schema, which is what the AI
+     * assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s.date().describe("First day the campaign is live");
+     * export default c.define("/example.val.ts", schema, "2025-06-01");
+     */
     describe(description: string | null): DateSchema<Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * @example
+     * const schema = s.date().validate((val) =>
+     *   val >= "2025-01-01" ? false : "Must be in 2025 or later",
+     * );
+     * export default c.define("/example.val.ts", schema, "2025-06-01");
+     */
     validate(validationFunction: (src: Src) => false | string): DateSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    /**
+     * Validate that the date is this date or after (inclusive).
+     *
+     * Written as `YYYY-MM-DD`, the same shape the value has.
+     *
+     * @example
+     * const schema = s.date().from("2025-01-01");
+     * export default c.define("/example.val.ts", schema, "2025-06-01");
+     */
     from(from: string): DateSchema<Src>;
+    /**
+     * Validate that the date is this date or before (inclusive).
+     *
+     * Written as `YYYY-MM-DD`, the same shape the value has.
+     *
+     * @example
+     * const schema = s.date().from("2025-01-01").to("2025-12-31");
+     * export default c.define("/example.val.ts", schema, "2025-06-01");
+     */
     to(to: string): DateSchema<Src>;
     nullable(): DateSchema<Src | null>;
     readonly(isReadonly?: boolean): DateSchema<Src>;
@@ -59,12 +111,22 @@ export declare class DateSchema<Src extends string | null> extends Schema<Src> {
      * instead of a preview row that navigates to it.
      *
      * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.date().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, ["2025-06-01"]);
      */
     render(input: FieldRender): DateSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field
      * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.date().preview(({ val }) => ({ title: val })),
+     * );
+     * export default c.define("/example.val.ts", schema, ["2025-06-01"]);
      */
     preview(select: ItemPreviewInput<Src>): DateSchema<Src>;
     protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;

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

@@ -11,7 +11,7 @@ type DateTimeOptions = {
      * Accepts any ISO 8601 datetime string parseable by `Date.parse`.
      *
      * @example
-     * 2021-01-01T00:00:00Z
+     * "2021-01-01T00:00:00Z"
      */
     from?: string;
     /**
@@ -20,7 +20,7 @@ type DateTimeOptions = {
      * Accepts any ISO 8601 datetime string parseable by `Date.parse`.
      *
      * @example
-     * 2021-12-31T23:59:59Z
+     * "2021-12-31T23:59:59Z"
      */
     to?: string;
 };
@@ -47,11 +47,82 @@ export declare class DateTimeSchema<Src extends string | null> extends Schema<Sr
     private readonly renderInput;
     private readonly previewInput;
     constructor(options?: DateTimeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    /**
+     * Describe this field.
+     *
+     * The description is shown next to the field's label in the Val editor, so
+     * it is where you say what an editor needs to know but the field name cannot
+     * carry. It also travels in the serialized schema, which is what the AI
+     * assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s.datetime().describe("When the article goes live");
+     * export default c.define(
+     *   "/example.val.ts",
+     *   schema,
+     *   "2025-06-01T09:00:00.000Z",
+     * );
+     */
     describe(description: string | null): DateTimeSchema<Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * @example
+     * const schema = s.datetime().validate((val) =>
+     *   val.endsWith("Z") ? false : "Must be in UTC",
+     * );
+     * export default c.define(
+     *   "/example.val.ts",
+     *   schema,
+     *   "2025-06-01T09:00:00.000Z",
+     * );
+     */
     validate(validationFunction: (src: Src) => false | string): DateTimeSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    /**
+     * Validate that the datetime is this datetime or after (inclusive).
+     *
+     * Any ISO 8601 datetime string `Date.parse` understands.
+     *
+     * @example
+     * const schema = s.datetime().from("2025-01-01T00:00:00Z");
+     * export default c.define(
+     *   "/example.val.ts",
+     *   schema,
+     *   "2025-06-01T09:00:00.000Z",
+     * );
+     */
     from(from: string): DateTimeSchema<Src>;
+    /**
+     * Validate that the datetime is this datetime or before (inclusive).
+     *
+     * Any ISO 8601 datetime string `Date.parse` understands.
+     *
+     * @example
+     * const schema = s
+     *   .datetime()
+     *   .from("2025-01-01T00:00:00Z")
+     *   .to("2025-12-31T23:59:59Z");
+     * export default c.define(
+     *   "/example.val.ts",
+     *   schema,
+     *   "2025-06-01T09:00:00.000Z",
+     * );
+     */
     to(to: string): DateTimeSchema<Src>;
     nullable(): DateTimeSchema<Src | null>;
     readonly(isReadonly?: boolean): DateTimeSchema<Src>;
@@ -63,12 +134,26 @@ export declare class DateTimeSchema<Src extends string | null> extends Schema<Sr
      * instead of a preview row that navigates to it.
      *
      * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.datetime().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, [
+     *   "2025-06-01T09:00:00.000Z",
+     * ]);
      */
     render(input: FieldRender): DateTimeSchema<Src>;
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field
      * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.datetime().preview(({ val }) => ({ title: val })),
+     * );
+     * export default c.define("/example.val.ts", schema, [
+     *   "2025-06-01T09:00:00.000Z",
+     * ]);
      */
     preview(select: ItemPreviewInput<Src>): DateTimeSchema<Src>;
     protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;

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

@@ -0,0 +1,37 @@
+import { SerializedSchema } from "./index.js";
+/**
+ * The keys a record is REQUIRED to hold, where its key schema says what they are.
+ *
+ * Most records have an open key set — `s.record(s.string(), item)` holds
+ * whatever anyone adds — and this returns `null` for those. A record keyed by
+ * something that enumerates its values is different in kind: the keys are part
+ * of the schema, so a missing one is a hole in the content rather than content
+ * nobody has written yet.
+ *
+ * Two key schemas enumerate. A union of literals does it locally, so its keys
+ * are here. `s.locale()` does it in the settings module, which is another file
+ * and so cannot be read from a serialized schema — that case says only which
+ * kind it is, and is resolved against `locales.available` by
+ * `resolveSchemaSourceFixes`, the same crossing `keyOf` and `route` make.
+ */
+export type DeclaredKeySet = {
+    kind: "literals";
+    keys: string[];
+} | {
+    kind: "locale";
+};
+/**
+ * What `key` requires a record to hold, or `null` where it requires nothing.
+ *
+ * Works from the SERIALIZED schema so that the Studio, the validation worker
+ * and the server all answer this the same way — none of them has the schema
+ * instance, and `SchemaStore` deliberately holds serialized schemas only.
+ */
+export declare function declaredKeySetOf(key: SerializedSchema | undefined): DeclaredKeySet | null;
+/**
+ * The declared keys a record is missing, in the order the schema declares them.
+ *
+ * Declaration order rather than the source's: this is read as "what is left to
+ * write", and the answer should not reshuffle itself as entries are added.
+ */
+export declare function missingDeclaredKeys(declared: readonly string[], present: readonly string[]): string[];