@velora-cms/api-schemas 0.9.0

package/dist/content-api.schema.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { ContentNodeSchema } from "./content.schema.js";
+import { ContentVersionSchema } from "./content-version.schema.js";
+// createdBy is deliberately absent from mutation request bodies — it comes
+// from the authenticated JWT (sub claim), never from the caller.
+export const CreateContentRequestSchema = z.object({
+    documentTypeId: z.string().uuid(),
+    parentId: z.string().uuid().nullable(),
+    path: z.string().min(1),
+    depth: z.number().int().nonnegative(),
+    sortOrder: z.number().int(),
+    locale: z.string().min(2),
+    isDefaultLocale: z.boolean(),
+    translationGroupId: z.string().uuid().optional(),
+    data: z.record(z.string(), z.unknown()),
+});
+export const ContentItemResponseSchema = z.object({
+    node: ContentNodeSchema,
+    version: ContentVersionSchema,
+});
+// S156 admin by-path lookup — the admin origin's honest-headless view
+// resolves a pasted URL against the content tree. Drafts ARE visible here
+// (this is the back office); the public no-leak rule lives on the server
+// origin's bridge, not on this authenticated route.
+export const ContentByPathQuerySchema = z.object({
+    path: z.string().min(1),
+});
+export const ContentByPathResponseSchema = z.object({
+    node: ContentNodeSchema,
+});
+export const SaveContentRequestSchema = z.object({
+    data: z.record(z.string(), z.unknown()),
+});
+export const SaveContentResponseSchema = z.object({
+    version: ContentVersionSchema,
+});
+// GET /api/content/:id/versions/latest — the newest saved version,
+// regardless of the current_version pointer. This is what the content
+// editor edits: after a draft save, GET /api/content/:id still serves the
+// pointer (published) version by design, so the draft would otherwise be
+// unreachable over REST. Also the response shape of
+// GET /api/content/:id/versions/:version (same "one full version" read).
+export const LatestVersionResponseSchema = z.object({
+    version: ContentVersionSchema,
+});
+// Version history list: metadata only — `data` can be arbitrarily large
+// and the history view only needs the row facts; the full snapshot is one
+// GET /api/content/:id/versions/:version away.
+export const ContentVersionMetaSchema = ContentVersionSchema.omit({ data: true });
+// Newest-first pages. Version numbers are contiguous (1..latest, rows are
+// never deleted — immutability), so the cursor is simply the last version
+// number of the previous page.
+export const VersionListQuerySchema = z.object({
+    cursor: z.coerce.number().int().positive().optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(20),
+});
+export const VersionListResponseSchema = z.object({
+    items: z.array(ContentVersionMetaSchema),
+    // null = no more pages.
+    nextCursor: z.number().int().positive().nullable(),
+});
+export const PublishContentRequestSchema = z.object({
+    // Omitted = publish the latest saved version.
+    version: z.number().int().positive().optional(),
+});
+export const PublishContentResponseSchema = z.object({
+    node: ContentNodeSchema,
+});
+// POST /api/content/:id/preview-token (Session 116) — mints a stateless,
+// short-TTL, single-content-id preview token (see
+// apps/server/src/auth/preview-tokens.ts). Any existing content id may be
+// minted for, published or not; `expiresAt` is an ISO datetime string.
+// Session 117: added `previewUrl` — the full preview URL (including token),
+// or null if VELORA_PREVIEW_BASE_URL is not configured.
+export const PreviewTokenResponseSchema = z.object({
+    token: z.string(),
+    expiresAt: z.string().datetime(),
+    previewUrl: z.string().nullable(),
+});
+// ?locale=fr&fallback=en per api-design.md. Without `locale`, the node is
+// returned as-is and `fallback` is ignored. With `locale` but no
+// `fallback`, only an exact translation matches (404 otherwise).
+export const ContentItemQuerySchema = z.object({
+    locale: z.string().min(2).optional(),
+    fallback: z.string().min(2).optional(),
+});
+export const ContentChildrenQuerySchema = z.object({
+    // Cursor = id of the previous page's last node, same semantics as
+    // DatabaseAdapter.getChildren.
+    cursor: z.string().uuid().optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+export const ContentChildrenResponseSchema = z.object({
+    items: z.array(ContentNodeSchema),
+    // null = no more pages.
+    nextCursor: z.string().uuid().nullable(),
+});
+// Whole-array reorder (mirrors the document-type fields/tabs pattern) —
+// orderedIds must exactly match the current children of the parent (or
+// root nodes, for /api/content/roots/reorder); the adapter rejects
+// otherwise. Only practical for a fully-loaded sibling list, so the admin
+// UI only offers drag-reorder once every page has loaded.
+export const ReorderNodesRequestSchema = z.object({
+    orderedIds: z.array(z.string().uuid()).min(1),
+});
+export const ReorderNodesResponseSchema = z.object({
+    success: z.literal(true),
+});
+// The one deliberate exception to ApiErrorSchema's "every route, same
+// shape" rule (api-error.schema.ts) — field validation failures are
+// per-field by nature, and the admin editor needs that structure to
+// eventually highlight the right field/tab, not just show a string.
+export const FieldValidationFailureSchema = z.object({
+    fieldId: z.string(),
+    key: z.string(),
+    params: z.record(z.string(), z.unknown()).optional(),
+});
+export const ContentValidationErrorSchema = z.object({
+    message: z.string(),
+    fieldErrors: z.array(FieldValidationFailureSchema),
+});

package/dist/content-trash-api.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const ContentTrashBodySchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>>;
+export type ContentTrashBody = z.infer<typeof ContentTrashBodySchema>;
+export declare const ContentTrashConfirmationSchema: z.ZodObject<{
+    requiresConfirmation: z.ZodLiteral<true>;
+    nodeName: z.ZodString;
+    descendantCount: z.ZodNumber;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ContentTrashConfirmation = z.infer<typeof ContentTrashConfirmationSchema>;
+export declare const ContentTrashResultSchema: z.ZodObject<{
+    trashedCount: z.ZodNumber;
+}, z.core.$strip>;
+export type ContentTrashResult = z.infer<typeof ContentTrashResultSchema>;
+export declare const ContentRestoreResultSchema: z.ZodObject<{
+    restoredCount: z.ZodNumber;
+}, z.core.$strip>;
+export type ContentRestoreResult = z.infer<typeof ContentRestoreResultSchema>;

package/dist/content-trash-api.schema.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+// S154 content trash. The DELETE is two-step like the structured-data
+// uninstall gate: unconfirmed → 409 naming the blast radius (the count
+// the confirm dialog renders), confirmed → trash. Trash is SOFT —
+// reversible via the restore route — so this is a plain confirmation,
+// not the snapshot-gate treatment.
+//
+// Fastify substitutes `null` for a genuinely absent body before handing it
+// to the validator — a DELETE sent with no payload at all lands here as
+// `null`, not `undefined`. `.nullish()` (not `.optional()`) is required so
+// an absent body validates; `request.body?.confirm` in the route handler
+// already tolerates both null and undefined.
+export const ContentTrashBodySchema = z
+    .object({ confirm: z.boolean().optional() })
+    .nullish();
+export const ContentTrashConfirmationSchema = z.object({
+    requiresConfirmation: z.literal(true),
+    nodeName: z.string(),
+    descendantCount: z.number().int(),
+    message: z.string(),
+});
+export const ContentTrashResultSchema = z.object({ trashedCount: z.number().int() });
+export const ContentRestoreResultSchema = z.object({ restoredCount: z.number().int() });

package/dist/content-trash.schema.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const ContentTrashListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const TrashedSubtreeSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    documentTypeId: z.ZodString;
+    deletedAt: z.ZodString;
+    nodeCount: z.ZodNumber;
+    orphaned: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ContentTrashListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        documentTypeId: z.ZodString;
+        deletedAt: z.ZodString;
+        nodeCount: z.ZodNumber;
+        orphaned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ContentRestoreBlockedSchema: z.ZodObject<{
+    message: z.ZodString;
+    blockingAncestorPath: z.ZodString;
+}, z.core.$strip>;
+export type ContentTrashListResponse = z.infer<typeof ContentTrashListResponseSchema>;
+export type TrashedSubtreeDto = z.infer<typeof TrashedSubtreeSchema>;
+export type ContentRestoreBlocked = z.infer<typeof ContentRestoreBlockedSchema>;

package/dist/content-trash.schema.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+// S161: the trash browse surface. Separate from content-trash-api.schema.ts
+// (S154's trash/restore confirmation bodies) — this file is the list route
+// and the restore-blocked 409, added a session later.
+export const ContentTrashListQuerySchema = z.object({
+    cursor: z.string().optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+export const TrashedSubtreeSchema = z.object({
+    id: z.string(),
+    path: z.string(),
+    documentTypeId: z.string(),
+    deletedAt: z.string(),
+    nodeCount: z.number().int().nonnegative(),
+    // True when the node's ancestors were purged rather than trashed —
+    // restoring it lands it at the root. The UI must say so before the click.
+    orphaned: z.boolean(),
+});
+export const ContentTrashListResponseSchema = z.object({
+    items: z.array(TrashedSubtreeSchema),
+    nextCursor: z.string().nullable(),
+});
+export const ContentRestoreBlockedSchema = z.object({
+    message: z.string(),
+    blockingAncestorPath: z.string(),
+});

package/dist/content-version.schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const ContentVersionSchema: z.ZodObject<{
+    id: z.ZodString;
+    contentId: z.ZodString;
+    version: z.ZodNumber;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    createdBy: z.ZodString;
+    publishedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ContentVersion = z.infer<typeof ContentVersionSchema>;

package/dist/content-version.schema.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export const ContentVersionSchema = z.object({
+    id: z.string().uuid(),
+    contentId: z.string().uuid(),
+    version: z.number().int().positive(),
+    data: z.record(z.string(), z.unknown()),
+    createdAt: z.string().datetime(),
+    createdBy: z.string().uuid(),
+    publishedAt: z.string().datetime().nullable(),
+});

package/dist/content.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const ContentNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    path: z.ZodString;
+    depth: z.ZodNumber;
+    sortOrder: z.ZodNumber;
+    documentTypeId: z.ZodString;
+    translationGroupId: z.ZodString;
+    locale: z.ZodString;
+    isDefaultLocale: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    currentVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type ContentNode = z.infer<typeof ContentNodeSchema>;

package/dist/content.schema.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const ContentNodeSchema = z.object({
+    id: z.string().uuid(),
+    parentId: z.string().uuid().nullable(),
+    path: z.string().min(1),
+    depth: z.number().int().nonnegative(),
+    sortOrder: z.number().int(),
+    documentTypeId: z.string().uuid(),
+    translationGroupId: z.string().uuid(),
+    locale: z.string().min(2),
+    isDefaultLocale: z.boolean(),
+    publishedAt: z.string().datetime().nullable(),
+    currentVersion: z.number().int().positive(),
+});

package/dist/data-type-api.schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const CreateDataTypeRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    editorId: z.ZodString;
+    settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type CreateDataTypeRequest = z.infer<typeof CreateDataTypeRequestSchema>;
+export declare const UpdateDataTypeRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type UpdateDataTypeRequest = z.infer<typeof UpdateDataTypeRequestSchema>;
+export declare const DataTypeResponseSchema: z.ZodObject<{
+    dataType: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        editorId: z.ZodString;
+        settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type DataTypeResponse = z.infer<typeof DataTypeResponseSchema>;
+export declare const DataTypeListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type DataTypeListQuery = z.infer<typeof DataTypeListQuerySchema>;
+export declare const DataTypeListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        editorId: z.ZodString;
+        settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DataTypeListResponse = z.infer<typeof DataTypeListResponseSchema>;

package/dist/data-type-api.schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { DataTypeConfigSchema } from "./data-type-config.schema.js";
+export const CreateDataTypeRequestSchema = z
+    .object({
+    name: z.string().min(1),
+    editorId: z.string().min(1),
+    settings: z.record(z.string(), z.unknown()).default({}),
+})
+    .strict();
+// editorId is deliberately absent — immutable after creation (see
+// DataTypeConfigSchema). At least the route merges partial updates onto
+// the loaded config, so both fields are optional here.
+export const UpdateDataTypeRequestSchema = z
+    .object({
+    name: z.string().min(1).optional(),
+    settings: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+export const DataTypeResponseSchema = z.object({
+    dataType: DataTypeConfigSchema,
+});
+// Ordered name ASC (id ASC tiebreak) for the Settings tree; cursor = id
+// of the previous page's last config.
+export const DataTypeListQuerySchema = z.object({
+    cursor: z.string().uuid().optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+export const DataTypeListResponseSchema = z.object({
+    items: z.array(DataTypeConfigSchema),
+    // null = no more pages.
+    nextCursor: z.string().uuid().nullable(),
+});

package/dist/data-type-config.schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const DataTypeConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    editorId: z.ZodString;
+    settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type DataTypeConfig = z.infer<typeof DataTypeConfigSchema>;
+export declare const BUILT_IN_DATA_TYPE_CONFIGS: readonly DataTypeConfig[];

package/dist/data-type-config.schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+// A Data Type is a named, admin-created CONFIGURATION of a registry
+// editor (Umbraco's split: the editor is the input-control code shipped
+// by core/plugins; the Data Type is "Richtext — limited toolbar").
+// Document type fields reference a Data Type's id — configure once,
+// reuse across document types. Settings are validated against the
+// editor's settingsSchema when the plugin settings pipeline lands
+// (Month 6); until then they are a free-form record.
+export const DataTypeConfigSchema = z
+    .object({
+    id: z.string().uuid(),
+    name: z.string().min(1),
+    // Registry editor id, e.g. 'com.velora.richtext'. Immutable after
+    // creation — swapping the editor under fields that already store
+    // values in the old editor's shape is a data footgun.
+    editorId: z.string().min(1),
+    settings: z.record(z.string(), z.unknown()).default({}),
+})
+    .strict();
+// Every built-in editor seeds one default config in migration
+// 0006_data_types, with these FIXED ids — the single source of truth
+// shared by the migrations, tests, and any code that needs "the plain
+// Text data type" without a lookup. Version-4/variant-8 shaped so
+// z.string().uuid() accepts them.
+export const BUILT_IN_DATA_TYPE_CONFIGS = [
+    { id: "b1e00000-0000-4000-8000-000000000001", name: "Text", editorId: "com.velora.text", settings: {} },
+    { id: "b1e00000-0000-4000-8000-000000000002", name: "Number", editorId: "com.velora.number", settings: {} },
+    { id: "b1e00000-0000-4000-8000-000000000003", name: "Boolean", editorId: "com.velora.boolean", settings: {} },
+    { id: "b1e00000-0000-4000-8000-000000000004", name: "Date", editorId: "com.velora.date", settings: {} },
+    { id: "b1e00000-0000-4000-8000-000000000005", name: "Image", editorId: "com.velora.image", settings: {} },
+    { id: "b1e00000-0000-4000-8000-000000000006", name: "Rich Text", editorId: "com.velora.richtext", settings: {} },
+];

package/dist/document-type-api.schema.d.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+export declare const CreateDocumentTypeRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    icon: z.ZodString;
+    kind: z.ZodLiteral<"page">;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        datatypeId: z.ZodString;
+        validation: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodBoolean>;
+            minLength: z.ZodOptional<z.ZodNumber>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tabId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    treeRules: z.ZodObject<{
+        allowedAtRoot: z.ZodBoolean;
+        allowedParentTypes: z.ZodArray<z.ZodString>;
+        allowedChildTypes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    icon: z.ZodString;
+    kind: z.ZodLiteral<"element">;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        datatypeId: z.ZodString;
+        validation: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodBoolean>;
+            minLength: z.ZodOptional<z.ZodNumber>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tabId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>], "kind">;
+export type CreateDocumentTypeRequest = z.infer<typeof CreateDocumentTypeRequestSchema>;
+export declare const UpdateDocumentTypeRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    icon: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        datatypeId: z.ZodString;
+        validation: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodBoolean>;
+            minLength: z.ZodOptional<z.ZodNumber>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tabId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    treeRules: z.ZodOptional<z.ZodObject<{
+        allowedAtRoot: z.ZodBoolean;
+        allowedParentTypes: z.ZodArray<z.ZodString>;
+        allowedChildTypes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type UpdateDocumentTypeRequest = z.infer<typeof UpdateDocumentTypeRequestSchema>;
+export declare const CreateDocumentTypeResponseSchema: z.ZodObject<{
+    documentType: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        icon: z.ZodString;
+        kind: z.ZodLiteral<"page">;
+        fields: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            datatypeId: z.ZodString;
+            validation: z.ZodOptional<z.ZodObject<{
+                required: z.ZodOptional<z.ZodBoolean>;
+                minLength: z.ZodOptional<z.ZodNumber>;
+                maxLength: z.ZodOptional<z.ZodNumber>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tabId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        treeRules: z.ZodObject<{
+            allowedAtRoot: z.ZodBoolean;
+            allowedParentTypes: z.ZodArray<z.ZodString>;
+            allowedChildTypes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        defaultTemplateId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        icon: z.ZodString;
+        kind: z.ZodLiteral<"element">;
+        fields: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            datatypeId: z.ZodString;
+            validation: z.ZodOptional<z.ZodObject<{
+                required: z.ZodOptional<z.ZodBoolean>;
+                minLength: z.ZodOptional<z.ZodNumber>;
+                maxLength: z.ZodOptional<z.ZodNumber>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tabId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strip>;
+export type CreateDocumentTypeResponse = z.infer<typeof CreateDocumentTypeResponseSchema>;
+export declare const DocumentTypeListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type DocumentTypeListQuery = z.infer<typeof DocumentTypeListQuerySchema>;
+export declare const DocumentTypeListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        icon: z.ZodString;
+        kind: z.ZodLiteral<"page">;
+        fields: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            datatypeId: z.ZodString;
+            validation: z.ZodOptional<z.ZodObject<{
+                required: z.ZodOptional<z.ZodBoolean>;
+                minLength: z.ZodOptional<z.ZodNumber>;
+                maxLength: z.ZodOptional<z.ZodNumber>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tabId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        treeRules: z.ZodObject<{
+            allowedAtRoot: z.ZodBoolean;
+            allowedParentTypes: z.ZodArray<z.ZodString>;
+            allowedChildTypes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        defaultTemplateId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        icon: z.ZodString;
+        kind: z.ZodLiteral<"element">;
+        fields: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            datatypeId: z.ZodString;
+            validation: z.ZodOptional<z.ZodObject<{
+                required: z.ZodOptional<z.ZodBoolean>;
+                minLength: z.ZodOptional<z.ZodNumber>;
+                maxLength: z.ZodOptional<z.ZodNumber>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tabId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DocumentTypeListResponse = z.infer<typeof DocumentTypeListResponseSchema>;
+export declare const DeleteDocumentTypeResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type DeleteDocumentTypeResponse = z.infer<typeof DeleteDocumentTypeResponseSchema>;