@valbuild/shared 0.121.0 → 0.123.0

package/dist/declarations/src/internal/schema/compatibility.d.ts

@@ -0,0 +1,62 @@
+import type { Json, SerializedSchema } from "@valbuild/core";
+/**
+ * Can this value, taken from one schema, be written into another?
+ *
+ * The question restore asks, and it is NOT the question validation asks.
+ * Validation checks a value against the schema it belongs to. This compares two
+ * schemas — the one a value was stored under and the one it is being written
+ * into — because a restore moves a value across a schema change, and possibly
+ * across paths.
+ *
+ * Three answers, not two. `unknown` is where the comparison genuinely cannot
+ * decide, and it exists so that an editor is told "we are not sure" rather than
+ * being given a confident answer we made up. Treating unknown as compatible
+ * writes values that break; treating it as incompatible blocks restores that
+ * would have been fine.
+ */
+export type Compatibility = {
+    status: "compatible";
+} | {
+    status: "incompatible";
+    reason: IncompatibleReason;
+} | {
+    status: "unknown";
+    message: string;
+};
+export type IncompatibleReason = {
+    kind: "type-changed";
+    from: string;
+    to: string;
+} | {
+    kind: "no-matching-variant";
+    variants: string[];
+} | {
+    kind: "unknown-field";
+    keys: string[];
+} | {
+    kind: "missing-required";
+    keys: string[];
+} | {
+    kind: "not-optional";
+} | {
+    kind: "literal-changed";
+    from: string;
+    to: string;
+} | {
+    kind: "different-module";
+    from: string;
+    to: string;
+};
+/**
+ * A sentence an editor can act on, for the popup that explains a refusal.
+ *
+ * Kept beside the reasons rather than in the UI so that adding a reason without
+ * wording for it is a type error rather than a blank dialog.
+ */
+export declare function explainIncompatible(reason: IncompatibleReason): string;
+export declare function checkCompatibility(from: {
+    schema: SerializedSchema;
+    value: Json;
+}, to: {
+    schema: SerializedSchema;
+}): Compatibility;

package/dist/declarations/src/internal/search/getFilenameFromRef.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Extract a human-readable filename from a file ref (local path or remote URL).
+ * Handles both remote refs (via splitRemoteRef) and plain `/public/...` paths.
+ */
+export declare function getFilenameFromRef(ref: string): string;
+/**
+ * Parse a file ref into its constituent parts: a clean path, filename, and
+ * folder (the path relative to `/public`).
+ *
+ * The `folder` strips the standard `/public` prefix so it shows a
+ * concise location like `/images` instead of `/public/images`.
+ */
+export declare function getRefParts(ref: string): {
+    cleanPath: string;
+    filename: string;
+    folder: string;
+};

package/dist/declarations/src/internal/search/searchIndex.d.ts

@@ -0,0 +1,76 @@
+import { Json, ModuleFilePath, SerializedSchema, SourcePath } from "@valbuild/core";
+import { Index } from "flexsearch";
+/**
+ * The search index and the labels to render for its hits.
+ *
+ * Kept as a plain module rather than living inside a worker so it can be tested:
+ * a worker entry runs `self.onmessage` on import, which no test environment here
+ * provides.
+ *
+ * In `@valbuild/shared` rather than the Studio because there are now two
+ * realms searching the same content: the Studio's `SearchStore`, which keeps an
+ * index alive in a worker and re-indexes a module at a time, and the MCP
+ * `search_content` tool, which builds one per call and throws it away. What
+ * counts as a document, and what a hit is labelled, must not differ between
+ * them — an agent and an editor searching the same project should find the same
+ * things.
+ */
+export type SearchIndex = {
+    index: Index;
+    pathToLabel: Map<string, string>;
+    /**
+     * Which document ids belong to which module, so one module can be re-indexed
+     * without touching the others.
+     *
+     * The ids are the `SourcePath`s themselves — `index.add(path, …)` below — so
+     * this could be recovered by scanning `pathToLabel` for a module-file-path
+     * prefix. It is kept explicitly anyway: the scan would be O(every document in
+     * the project) per module re-indexed, which is the whole-project cost that
+     * re-indexing one module exists to avoid.
+     */
+    docsByModule: Map<ModuleFilePath, Set<string>>;
+};
+/** An index with nothing in it. Fill it with {@link indexModule}. */
+export declare function createSearchIndex(): SearchIndex;
+/**
+ * Index one module, replacing whatever was previously indexed for it.
+ *
+ * Remove-then-add rather than `update`, because the set of paths in a module is
+ * not stable: deleting an array item or a record entry means documents that must
+ * disappear, and `update` only revises ids it is given.
+ *
+ * `.jsonValues()` entries are indexed only once their content is loaded — an
+ * un-loaded entry is an opaque marker that {@link traverseSchemaSource} skips, so
+ * the index is naturally PARTIAL and grows as batches land. That is why the search
+ * UI loads the entries on the first query and re-indexes (debounced) as they
+ * arrive, rather than pretending an empty result set is an answer.
+ */
+export declare function indexModule(searchIndex: SearchIndex, moduleFilePath: ModuleFilePath, source: Json, schema: SerializedSchema): void;
+/**
+ * Drop everything indexed for one module.
+ *
+ * Also used for a module that has gone away entirely — otherwise its documents
+ * stay searchable and a hit navigates to a path that no longer exists.
+ */
+export declare function removeModule(searchIndex: SearchIndex, moduleFilePath: ModuleFilePath): void;
+/**
+ * Index every module, from scratch.
+ *
+ * Now a loop over {@link indexModule} rather than its own walk, so the full
+ * build and the incremental one cannot drift in what they consider a document.
+ */
+export declare function buildSearchIndex(modules: Record<ModuleFilePath, {
+    source: Json;
+    schema: SerializedSchema;
+}>): SearchIndex;
+export type SearchResults = {
+    results: Array<{
+        path: SourcePath;
+        label: string;
+    }>;
+    /** Matches for the query, not just on this page. */
+    total: number;
+    /** `total` hit {@link MAX_COUNTED_RESULTS}, so it means "at least this many". */
+    totalIsLowerBound: boolean;
+};
+export declare function performSearch(searchIndex: SearchIndex | null, query: string, limit?: number, offset?: number): SearchResults;

package/dist/declarations/src/internal/search/sourcePath.d.ts

@@ -0,0 +1,30 @@
+import { ModuleFilePath, ModulePath, SourcePath } from "@valbuild/core";
+/**
+ * The one way to build a child's source path.
+ *
+ * There were five hand-rolled versions of this, three of them subtly different
+ * and two of them wrong, and the wrong ones were wrong in a way that hid: a
+ * module path segment has to be JSON-quoted if it is a string and bare if it is
+ * an array index, and both broken copies appended the raw key at the module
+ * root. An unquoted key parses fine as long as it contains no `.` — so every
+ * object field and every ordinary record key still resolved, and only a key with
+ * a dot in it broke. That is exactly what a media gallery is keyed by, so
+ * clicking a file in the Media panel navigated to
+ * `?p=/public/val/red-8x8_bfbd0.png`, which `splitModulePath` reads as the two
+ * segments `/public/val/red-8x8_bfbd0` and `png`, and the studio said the module
+ * was not found.
+ *
+ * So: one function, and never a template string. `Internal.createValPathOfItem`
+ * is the rule itself — `JSON.stringify` quotes a string and leaves a number
+ * bare, which is precisely the module-path grammar — and everything here defers
+ * to it rather than restating it.
+ */
+export declare function sourcePathOfChild(parent: SourcePath | ModuleFilePath, key: string | number): SourcePath;
+/**
+ * The same thing, for callers holding the module file path and module path apart.
+ *
+ * `ModulePath` is empty at the module root, which is the case both broken copies
+ * got wrong: there is no separator in the path yet, so the key is the first
+ * segment and still has to be quoted.
+ */
+export declare function concatModulePath(moduleFilePath: ModuleFilePath, modulePath: ModulePath, key: string | number): SourcePath;

package/dist/declarations/src/internal/search/traverseSchemaSource.d.ts

@@ -0,0 +1,20 @@
+import { Source, SerializedSchema, SourcePath } from "@valbuild/core";
+/**
+ * Traverses a schema and source pair, calling a callback for each leaf node.
+ * Handles all schema types including primitives, objects, arrays, records, unions, richtext, files, images, etc.
+ *
+ * @param source - The JSON source data
+ * @param schema - The serialized schema
+ * @param path - The current source path
+ * @param callback - Function called for each traversable node with { source, schema, path }
+ */
+export declare function traverseSchemaSource(source: Source, schema: SerializedSchema, path: SourcePath, callback: (opts: {
+    source: Source;
+    schema: SerializedSchema;
+    path: SourcePath;
+}) => void): void;
+/**
+ * Flattens richtext source to a plain string, extracting only text content.
+ * Used for indexing richtext content in search.
+ */
+export declare function flattenRichText(source: Source): string;

package/dist/declarations/src/internal/zod/History.d.ts

@@ -0,0 +1,257 @@
+import { z } from "zod";
+/**
+ * The wire shapes for reading history.
+ *
+ * Here rather than in `@valbuild/server` because both sides of `/api/val` need
+ * them: the server builds these and the Studio parses them, and a second
+ * hand-written copy in the client is how the two drift.
+ *
+ * `HistoryError` is a closed union of everything that can go wrong
+ * reconstructing a commit - see `packages/server/src/history/HistoryError.ts`
+ * for what each one means. It travels as data rather than as a message because
+ * the Studio decides what to OFFER from it: a schema mismatch means "cannot
+ * restore this field", a missing source means "cannot restore this module at
+ * all", and a rendered string cannot be told apart.
+ */
+export declare const HistoryError: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"commit-not-found">;
+    commitSha: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"archive-unreadable">;
+    commitSha: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"source-unavailable">;
+    moduleFilePath: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"schema-unreadable">;
+    moduleFilePath: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"file-unavailable">;
+    gitPath: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"not-supported-in-fs-mode">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"transport">;
+    message: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type HistoryError = z.infer<typeof HistoryError>;
+export declare const HistoricalCommit: z.ZodObject<{
+    commitSha: z.ZodString;
+    parentCommitSha: z.ZodString;
+    clientCommitSha: z.ZodString;
+    branch: z.ZodString;
+    createdBranch: z.ZodNullable<z.ZodString>;
+    creator: z.ZodNullable<z.ZodString>;
+    message: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    seqNum: z.ZodString;
+    patchCount: z.ZodNumber;
+    hasArchive: z.ZodBoolean;
+}, z.core.$strip>;
+export type HistoricalCommit = z.infer<typeof HistoricalCommit>;
+/**
+ * A binary file the commit touched - named, with a URL, and nothing fetched.
+ * Only an `<img src>` that mounts pays for the bytes.
+ */
+export declare const BinaryFileRef: z.ZodObject<{
+    gitPath: z.ZodString;
+    change: z.ZodUnion<readonly [z.ZodLiteral<"added">, z.ZodLiteral<"modified">, z.ZodLiteral<"deleted">]>;
+    remote: z.ZodBoolean;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type BinaryFileRef = z.infer<typeof BinaryFileRef>;
+export declare const HistoricalModule: z.ZodObject<{
+    source: z.ZodNullable<z.ZodType<import("@valbuild/core/patch").JSONValue, unknown, z.core.$ZodTypeInternals<import("@valbuild/core/patch").JSONValue, unknown>>>;
+    schema: z.ZodNullable<z.ZodType<import("@valbuild/core").SerializedSchema, unknown, z.core.$ZodTypeInternals<import("@valbuild/core").SerializedSchema, unknown>>>;
+    patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
+    changedPaths: z.ZodArray<z.ZodString>;
+    failures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"commit-not-found">;
+        commitSha: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"archive-unreadable">;
+        commitSha: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"source-unavailable">;
+        moduleFilePath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema-unreadable">;
+        moduleFilePath: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file-unavailable">;
+        gitPath: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"not-supported-in-fs-mode">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"transport">;
+        message: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type HistoricalModule = z.infer<typeof HistoricalModule>;
+export declare const HistoricalPatchSet: z.ZodObject<{
+    commit: z.ZodObject<{
+        commitSha: z.ZodString;
+        parentCommitSha: z.ZodString;
+        clientCommitSha: z.ZodString;
+        branch: z.ZodString;
+        createdBranch: z.ZodNullable<z.ZodString>;
+        creator: z.ZodNullable<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        seqNum: z.ZodString;
+        patchCount: z.ZodNumber;
+        hasArchive: z.ZodBoolean;
+    }, z.core.$strip>;
+    modules: z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodNullable<z.ZodType<import("@valbuild/core/patch").JSONValue, unknown, z.core.$ZodTypeInternals<import("@valbuild/core/patch").JSONValue, unknown>>>;
+        schema: z.ZodNullable<z.ZodType<import("@valbuild/core").SerializedSchema, unknown, z.core.$ZodTypeInternals<import("@valbuild/core").SerializedSchema, unknown>>>;
+        patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
+        changedPaths: z.ZodArray<z.ZodString>;
+        failures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"commit-not-found">;
+            commitSha: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"archive-unreadable">;
+            commitSha: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"source-unavailable">;
+            moduleFilePath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema-unreadable">;
+            moduleFilePath: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file-unavailable">;
+            gitPath: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"not-supported-in-fs-mode">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"transport">;
+            message: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>;
+    patches: z.ZodArray<z.ZodObject<{
+        patchId: z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>;
+        moduleFilePath: z.ZodString;
+        patch: z.ZodUnknown;
+        authorId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        baseSha: z.ZodString;
+        coreVersion: z.ZodString;
+    }, z.core.$strip>>;
+    jsonEntries: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    binaryFiles: z.ZodArray<z.ZodObject<{
+        gitPath: z.ZodString;
+        change: z.ZodUnion<readonly [z.ZodLiteral<"added">, z.ZodLiteral<"modified">, z.ZodLiteral<"deleted">]>;
+        remote: z.ZodBoolean;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"commit-not-found">;
+        commitSha: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"archive-unreadable">;
+        commitSha: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"source-unavailable">;
+        moduleFilePath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema-unreadable">;
+        moduleFilePath: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file-unavailable">;
+        gitPath: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"not-supported-in-fs-mode">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"transport">;
+        message: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type HistoricalPatchSet = z.infer<typeof HistoricalPatchSet>;
+/**
+ * Whether the historical value can be written back as the project stands.
+ *
+ * Computed in the Studio, not on the server: the verdict depends on the current
+ * source and the current schema, both of which the client already holds, and it
+ * runs against the same worker-thread validator that validates ordinary edits.
+ * The types stay here because they are what a restore preview hands to the UI.
+ *
+ * `blocked` carries its reasons so a refusal can name the field and say why,
+ * rather than being an unexplained disabled button.
+ */
+export declare const RestoreVerdict: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"restorable">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"blocked">;
+    reasons: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"commit-not-found">;
+        commitSha: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"archive-unreadable">;
+        commitSha: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"source-unavailable">;
+        moduleFilePath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema-unreadable">;
+        moduleFilePath: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file-unavailable">;
+        gitPath: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"not-supported-in-fs-mode">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"transport">;
+        message: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>]>;
+export type RestoreVerdict = z.infer<typeof RestoreVerdict>;
+export declare const ModuleComparison: z.ZodObject<{
+    current: z.ZodNullable<z.ZodUnknown>;
+    changedVsCurrent: z.ZodArray<z.ZodString>;
+    verdict: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"restorable">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"blocked">;
+        reasons: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"commit-not-found">;
+            commitSha: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"archive-unreadable">;
+            commitSha: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"source-unavailable">;
+            moduleFilePath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema-unreadable">;
+            moduleFilePath: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file-unavailable">;
+            gitPath: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"not-supported-in-fs-mode">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"transport">;
+            message: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type ModuleComparison = z.infer<typeof ModuleComparison>;

package/dist/declarations/src/internal/zod/Patch.d.ts

@@ -1,6 +1,13 @@
 import type { JSONValue as JSONValueT, PatchJSON as PatchJSONT, PatchBlock as PatchBlockT, ParentRef as ParentRefT } from "@valbuild/core/patch";
 import type { PatchId as PatchIdT } from "@valbuild/core";
 import { z } from "zod";
+/**
+ * JSON, recursively — the shape of a Source over the wire.
+ *
+ * Exported because history reads stored Sources back and needs the same
+ * definition; a second copy is a second thing to keep in step.
+ */
+export declare const JSONValue: z.ZodType<JSONValueT>;
 export declare const PatchJSON: z.ZodType<PatchJSONT>;
 export type PatchJSON = PatchJSONT;
 export declare const Patch: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/declarations/src/internal/zod/SerializedSchema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedUnionSchema as SerializedUnionSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedColorSchema as SerializedColorSchemaT, type SerializedCodeSchema as SerializedCodeSchemaT, type SerializedImageSchema as SerializedImageSchemaT } from "@valbuild/core";
+import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedUnionSchema as SerializedUnionSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedColorSchema as SerializedColorSchemaT, type SerializedCodeSchema as SerializedCodeSchemaT, type SerializedImageSchema as SerializedImageSchemaT, type SerializedSettingsSchema as SerializedSettingsSchemaT } from "@valbuild/core";
 export declare const SerializedStringSchema: z.ZodType<SerializedStringSchemaT>;
 export declare const SerializedLiteralSchema: z.ZodType<SerializedLiteralSchemaT>;
 export declare const SerializedBooleanSchema: z.ZodType<SerializedBooleanSchemaT>;
@@ -73,4 +73,5 @@ export declare const CodeOptions: z.ZodObject<{
 }, z.core.$strip>;
 export declare const SerializedCodeSchema: z.ZodType<SerializedCodeSchemaT>;
 export declare const SerializedRouteSchema: z.ZodType<SerializedRouteSchemaT>;
+export declare const SerializedSettingsSchema: z.ZodType<SerializedSettingsSchemaT>;
 export declare const SerializedSchema: z.ZodType<SerializedSchemaT>;