includio-cms 0.6.0 → 0.6.1

package/dist/admin/components/tiptap/InlineBlockNodeView.svelte

@@ -11,13 +11,15 @@
 	import Trash from '@tabler/icons-svelte/icons/trash';
 	import ChevronDown from '@tabler/icons-svelte/icons/chevron-down';
 	import { slide } from 'svelte/transition';
-	import { onMount, onDestroy } from 'svelte';
+	import { onMount, onDestroy, setContext } from 'svelte';
 	import type { FormPathLeaves } from 'sveltekit-superforms';
 	import { evaluateCondition } from '../../utils/fieldCondition.js';
 	import { isRecentlyInserted } from './inline-block-node.js';
 
 	let { node, updateAttributes, editor, getPos, deleteNode }: NodeViewProps = $props();
 
+	setContext('inInlineBlock', true);
+
 	let collapsed = $state(!isRecentlyInserted(node.attrs.blockId));
 
 	const contentLanguage = getContentLanguage();
@@ -33,9 +35,14 @@
 		for (const f of fields) {
 			const key = f.slug;
 			if (['text', 'richtext', 'content'].includes(f.type)) {
-				if (typeof result[key] !== 'object' || result[key] == null) {
-					const val = result[key] ?? (f.type === 'content' ? null : '');
-					result[key] = Object.fromEntries(langs.map((l) => [l, val]));
+				const val = result[key];
+				const needsWrap =
+					val == null ||
+					typeof val !== 'object' ||
+					(f.type === 'content' && 'type' in (val as Record<string, unknown>));
+				if (needsWrap) {
+					const fallback = val ?? (f.type === 'content' ? null : '');
+					result[key] = Object.fromEntries(langs.map((l) => [l, fallback]));
 				}
 			} else if (f.type === 'url') {
 				const v = result[key] as Record<string, unknown> | undefined;
@@ -89,9 +96,9 @@
 		for (const f of fields) {
 			const key = f.slug;
 			const val = result[key];
-			if (['text', 'richtext'].includes(f.type)) {
+			if (['text', 'richtext', 'content'].includes(f.type)) {
 				if (val && typeof val === 'object' && !Array.isArray(val)) {
-					result[key] = (val as Record<string, unknown>)[currentLang] ?? '';
+					result[key] = (val as Record<string, unknown>)[currentLang] ?? (f.type === 'content' ? null : '');
 				}
 			} else if (f.type === 'url' && val && typeof val === 'object') {
 				const v = val as Record<string, unknown>;

package/dist/admin/components/tiptap/content-editor.svelte

@@ -84,8 +84,17 @@
 					element: bubbleMenu!
 				}),
 				Placeholder.configure({
-					placeholder: 'Wpisz treść lub "/" by wstawić element',
-					showOnlyCurrent: true
+					showOnlyCurrent: false,
+					placeholder: ({ node, hasAnchor, editor }) => {
+						const isLastNode = editor.state.doc.lastChild === node;
+						if (isLastNode && node.type.name === 'paragraph') {
+							return 'Wpisz treść lub "/" by wstawić element';
+						}
+						if (hasAnchor) {
+							return 'Wpisz treść...';
+						}
+						return '';
+					}
 				})
 			],
 			content: initialContent,

package/dist/admin/styles/admin.css

@@ -310,7 +310,8 @@ div[data-collapsible]:not([data-collapsible='icon'])
 
 /* Placeholder — Notion-style */
 .ProseMirror .is-empty.is-editor-empty::before,
-.ProseMirror .has-focus.is-empty::before {
+.ProseMirror .has-focus.is-empty::before,
+.ProseMirror > .is-empty:last-child[data-placeholder]::before {
 	color: var(--text-light);
 	content: attr(data-placeholder);
 	float: left;

package/dist/ai-claude/index.js

@@ -2,9 +2,15 @@ import { getCMS } from '../core/cms.js';
 import Anthropic from '@anthropic-ai/sdk';
 import sharp from 'sharp';
 export function claudeAdapter(config) {
-    const client = new Anthropic({
-        apiKey: config.apiKey
-    });
+    let client = null;
+    function getClient() {
+        if (!client) {
+            if (!config.apiKey)
+                throw new Error('AI_CLAUDE_API_KEY is not set');
+            client = new Anthropic({ apiKey: config.apiKey });
+        }
+        return client;
+    }
     return {
         generateAltText: async (fileId) => {
             const mediaFile = await getCMS().databaseAdapter.getMediaFile({
@@ -23,7 +29,7 @@ export function claudeAdapter(config) {
             const pngBuffer = await sharp(fileBuffer).png().toBuffer();
             const imageBase64 = pngBuffer.toString('base64');
             const prompt = `Generate a concise and descriptive alt text for the following image file in polish language. The alt text should accurately describe the content and context of the image, be no longer than 125 characters, and avoid using phrases like "image of" or "picture of". Return only the alt text, nothing else.`;
-            const message = await client.messages.create({
+            const message = await getClient().messages.create({
                 model: 'claude-haiku-4-5-20251001',
                 max_tokens: 256,
                 messages: [

package/dist/cli/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { scaffoldAdmin } from './scaffold/admin.js';
+import { installPeers } from './install-peers.js';
 import path from 'node:path';
 const args = process.argv.slice(2);
 const command = args[0];
@@ -8,11 +9,13 @@ function printUsage() {
     console.log(`Usage: includio <command>
 
 Commands:
-  scaffold admin   Generate admin route files
+  scaffold admin    Generate admin route files
+  install-peers     Install missing peer dependencies
 
 Options:
-  --force          Overwrite existing files
-  --routes-dir     Path to routes directory (default: src/routes)
+  --force           Overwrite existing files
+  --routes-dir      Path to routes directory (default: src/routes)
+  --dry-run         Show what would be installed (install-peers)
 `);
 }
 if (command === 'scaffold' && subcommand === 'admin') {
@@ -22,6 +25,10 @@ if (command === 'scaffold' && subcommand === 'admin') {
     console.log('Scaffolding admin routes...\n');
     scaffoldAdmin({ routesDir, force });
 }
+else if (command === 'install-peers') {
+    const dryRun = args.includes('--dry-run');
+    installPeers({ dryRun });
+}
 else {
     printUsage();
     process.exit(command ? 1 : 0);

package/dist/cli/install-peers.d.ts

@@ -0,0 +1,3 @@
+export declare function installPeers(options?: {
+    dryRun?: boolean;
+}): void;

package/dist/cli/install-peers.js

@@ -0,0 +1,52 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function detectPackageManager() {
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    return 'npm';
+}
+function getProjectDeps() {
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        console.error('No package.json found in current directory.');
+        process.exit(1);
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+function getCmsPeerDeps() {
+    // Find includio-cms package.json in node_modules
+    const cmsPkgPath = path.join(process.cwd(), 'node_modules', 'includio-cms', 'package.json');
+    if (!fs.existsSync(cmsPkgPath)) {
+        console.error('includio-cms not found in node_modules. Run install first.');
+        process.exit(1);
+    }
+    const pkg = JSON.parse(fs.readFileSync(cmsPkgPath, 'utf-8'));
+    return pkg.peerDependencies || {};
+}
+export function installPeers(options = {}) {
+    const projectDeps = getProjectDeps();
+    const peerDeps = getCmsPeerDeps();
+    const missing = [];
+    for (const [name, version] of Object.entries(peerDeps)) {
+        if (!projectDeps[name]) {
+            missing.push(`${name}@${version}`);
+        }
+    }
+    if (missing.length === 0) {
+        console.log('All peer dependencies already installed.');
+        return;
+    }
+    console.log(`Missing peer dependencies:\n${missing.map((m) => `  ${m}`).join('\n')}\n`);
+    if (options.dryRun) {
+        console.log('Dry run — no changes made.');
+        return;
+    }
+    const pm = detectPackageManager();
+    const cmd = `${pm} add ${missing.join(' ')}`;
+    console.log(`Running: ${cmd}\n`);
+    execSync(cmd, { stdio: 'inherit' });
+    console.log('\nPeer dependencies installed.');
+}

package/dist/core/fields/fieldSchemaToTs.js

@@ -98,6 +98,8 @@ export function generateZodSchemaFromField(field, languages, options = {
                     }
                 });
             }
+            if (!localized)
+                return docSchema;
             return z.object(Object.fromEntries(languages.map((lang) => [lang, docSchema])));
         }
         case 'number': {

package/dist/core/fields/layoutUtils.d.ts

@@ -3,15 +3,42 @@ import type { ConfigBase } from '../../types/config.js';
 import type { Layout, LayoutNode } from '../../types/layout.js';
 export declare function getFieldsFromConfig(config: ConfigBase): Field[];
 export declare function hasLayout(config: ConfigBase): boolean;
-/** Collect all field slugs referenced in layout nodes (depth-first order) */
+/** Collect all field paths referenced in layout nodes (depth-first order).
+ *  Supports both plain slugs ('title') and dot-notation ('hero.title'). */
 export declare function collectFieldSlugs(nodes: LayoutNode[]): string[];
+/**
+ * Resolve a field definition by dot-notation path.
+ * E.g. 'companyInfo.contact.email' navigates: fields → companyInfo → fields → contact → fields → email
+ */
+export declare function resolveFieldByPath(fields: Field[], path: string): Field | undefined;
+/**
+ * Collect all leaf field paths from field definitions (recursively flattens objects).
+ * E.g. an object 'hero' with fields 'title','image' → ['hero.title', 'hero.image']
+ * Non-object fields at top level → ['slug']
+ */
+export declare function collectAllLeafPaths(fields: Field[], prefix?: string): string[];
+/**
+ * Identify top-level object slugs where ALL leaf fields are individually
+ * distributed across layout nodes (via dot-notation).
+ * These objects should suppress their own wrapper rendering.
+ */
+export declare function getDistributedObjectSlugs(nodes: LayoutNode[], fields: Field[]): Set<string>;
+/**
+ * Build SuperForm-compatible path for a dot-notation field reference.
+ * 'hero.title' → 'hero.data.title'
+ * 'hero.contact.email' → 'hero.data.contact.data.email'
+ * 'title' → 'title' (no change for top-level)
+ */
+export declare function buildFormPath(dotPath: string): string;
 export interface LayoutValidationError {
     type: 'missing_field' | 'duplicate_field' | 'depth_exceeded' | 'columns_mismatch';
     message: string;
 }
-/** Validate layout against fields — returns errors or empty array */
+/** Validate layout against fields — returns errors or empty array.
+ *  Supports dot-notation paths (e.g. 'hero.title'). */
 export declare function validateLayout(nodes: LayoutNode[], fields: Field[]): LayoutValidationError[];
 /** Expand a preset into LayoutNode[] */
 export declare function resolveLayout(layout: Layout, fields: Field[]): LayoutNode[];
-/** Resolve layout + append orphan fields in a trailing section */
+/** Resolve layout + append orphan fields in a trailing section.
+ *  Orphan detection works at leaf level — dot-notation refs count as covering their leaves. */
 export declare function resolveLayoutWithOrphans(config: ConfigBase): LayoutNode[];

package/dist/core/fields/layoutUtils.js

@@ -5,7 +5,8 @@ export function getFieldsFromConfig(config) {
 export function hasLayout(config) {
     return !!config.layout;
 }
-/** Collect all field slugs referenced in layout nodes (depth-first order) */
+/** Collect all field paths referenced in layout nodes (depth-first order).
+ *  Supports both plain slugs ('title') and dot-notation ('hero.title'). */
 export function collectFieldSlugs(nodes) {
     const slugs = [];
     for (const node of nodes) {
@@ -18,28 +19,133 @@ export function collectFieldSlugs(nodes) {
     }
     return slugs;
 }
+/**
+ * Resolve a field definition by dot-notation path.
+ * E.g. 'companyInfo.contact.email' navigates: fields → companyInfo → fields → contact → fields → email
+ */
+export function resolveFieldByPath(fields, path) {
+    const parts = path.split('.');
+    let current = fields;
+    for (let i = 0; i < parts.length; i++) {
+        const field = current.find((f) => f.slug === parts[i]);
+        if (!field)
+            return undefined;
+        if (i === parts.length - 1)
+            return field;
+        if (field.type !== 'object' || !('fields' in field))
+            return undefined;
+        current = field.fields;
+    }
+    return undefined;
+}
+/**
+ * Collect all leaf field paths from field definitions (recursively flattens objects).
+ * E.g. an object 'hero' with fields 'title','image' → ['hero.title', 'hero.image']
+ * Non-object fields at top level → ['slug']
+ */
+export function collectAllLeafPaths(fields, prefix = '') {
+    const paths = [];
+    for (const f of fields) {
+        const fullPath = prefix ? `${prefix}.${f.slug}` : f.slug;
+        if (f.type === 'object' && 'fields' in f) {
+            paths.push(...collectAllLeafPaths(f.fields, fullPath));
+        }
+        else {
+            paths.push(fullPath);
+        }
+    }
+    return paths;
+}
+/**
+ * Expand a layout field reference into leaf paths.
+ * - 'title' (non-object) → ['title']
+ * - 'hero' (object with fields) → ['hero.title', 'hero.image', ...]
+ * - 'hero.title' (dot-notation to leaf) → ['hero.title']
+ */
+function expandToLeafPaths(ref, fields) {
+    const resolved = resolveFieldByPath(fields, ref);
+    if (!resolved)
+        return [ref]; // unresolved — let validation catch it
+    if (resolved.type === 'object' && 'fields' in resolved) {
+        return collectAllLeafPaths(resolved.fields, ref);
+    }
+    return [ref];
+}
+/**
+ * Identify top-level object slugs where ALL leaf fields are individually
+ * distributed across layout nodes (via dot-notation).
+ * These objects should suppress their own wrapper rendering.
+ */
+export function getDistributedObjectSlugs(nodes, fields) {
+    const refs = collectFieldSlugs(nodes);
+    const distributed = new Set();
+    for (const f of fields) {
+        if (f.type !== 'object' || !('fields' in f))
+            continue;
+        // Check: is this object referenced as a whole?
+        if (refs.includes(f.slug))
+            continue;
+        // Get all leaf paths for this object
+        const leafPaths = collectAllLeafPaths(f.fields, f.slug);
+        if (leafPaths.length === 0)
+            continue;
+        // Check if ALL leaf paths are covered by layout refs
+        const allCovered = leafPaths.every((lp) => refs.includes(lp));
+        if (allCovered)
+            distributed.add(f.slug);
+    }
+    return distributed;
+}
+/**
+ * Build SuperForm-compatible path for a dot-notation field reference.
+ * 'hero.title' → 'hero.data.title'
+ * 'hero.contact.email' → 'hero.data.contact.data.email'
+ * 'title' → 'title' (no change for top-level)
+ */
+export function buildFormPath(dotPath) {
+    const parts = dotPath.split('.');
+    if (parts.length <= 1)
+        return dotPath;
+    const result = [parts[0]];
+    for (let i = 1; i < parts.length; i++) {
+        result.push('data', parts[i]);
+    }
+    return result.join('.');
+}
 /** Count columns expected by a ratio string */
 function columnCount(ratio) {
     return ratio.split(' ').length;
 }
-/** Validate layout against fields — returns errors or empty array */
+/** Validate layout against fields — returns errors or empty array.
+ *  Supports dot-notation paths (e.g. 'hero.title'). */
 export function validateLayout(nodes, fields) {
     const errors = [];
-    const fieldSlugs = new Set(fields.map((f) => f.slug));
+    const topLevelSlugs = new Set(fields.map((f) => f.slug));
     const referencedSlugs = collectFieldSlugs(nodes);
-    // Check for missing fields
+    // Check for missing fields — support both top-level slugs and dot-notation
     for (const slug of referencedSlugs) {
-        if (!fieldSlugs.has(slug)) {
-            errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+        if (slug.includes('.')) {
+            // Dot-notation: resolve through field tree
+            if (!resolveFieldByPath(fields, slug)) {
+                errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+            }
+        }
+        else {
+            if (!topLevelSlugs.has(slug)) {
+                errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+            }
         }
     }
-    // Check for duplicates
-    const seen = new Set();
-    for (const slug of referencedSlugs) {
-        if (seen.has(slug)) {
-            errors.push({ type: 'duplicate_field', message: `Field "${slug}" referenced multiple times` });
+    // Check for duplicates (expand to leaf paths for overlap detection)
+    const seenLeaves = new Set();
+    for (const ref of referencedSlugs) {
+        const leaves = expandToLeafPaths(ref, fields);
+        for (const leaf of leaves) {
+            if (seenLeaves.has(leaf)) {
+                errors.push({ type: 'duplicate_field', message: `Field "${leaf}" referenced multiple times` });
+            }
+            seenLeaves.add(leaf);
         }
-        seen.add(slug);
     }
     // Check depth + columns
     function walk(nodeList, depth) {
@@ -72,7 +178,8 @@ export function resolveLayout(layout, fields) {
         return layout;
     return expandPreset(layout, fields);
 }
-/** Resolve layout + append orphan fields in a trailing section */
+/** Resolve layout + append orphan fields in a trailing section.
+ *  Orphan detection works at leaf level — dot-notation refs count as covering their leaves. */
 export function resolveLayoutWithOrphans(config) {
     if (!config.layout) {
         // No layout — single section with all fields
@@ -85,16 +192,37 @@ export function resolveLayoutWithOrphans(config) {
         ];
     }
     const nodes = resolveLayout(config.layout, config.fields);
-    const referenced = new Set(collectFieldSlugs(nodes));
-    const orphans = config.fields.filter((f) => !referenced.has(f.slug)).map((f) => f.slug);
-    if (orphans.length === 0)
+    const refs = collectFieldSlugs(nodes);
+    // Expand all refs to leaf paths for coverage checking
+    const coveredLeaves = new Set();
+    for (const ref of refs) {
+        for (const leaf of expandToLeafPaths(ref, config.fields)) {
+            coveredLeaves.add(leaf);
+        }
+    }
+    // Find orphan top-level fields (not covered at all)
+    const allLeaves = collectAllLeafPaths(config.fields);
+    const orphanTopSlugs = [];
+    for (const f of config.fields) {
+        if (f.type === 'object' && 'fields' in f) {
+            const objectLeaves = collectAllLeafPaths(f.fields, f.slug);
+            const anyCovered = objectLeaves.some((lp) => coveredLeaves.has(lp));
+            if (!anyCovered)
+                orphanTopSlugs.push(f.slug);
+        }
+        else {
+            if (!coveredLeaves.has(f.slug))
+                orphanTopSlugs.push(f.slug);
+        }
+    }
+    if (orphanTopSlugs.length === 0)
         return nodes;
     return [
         ...nodes,
         {
             type: 'section',
             label: { en: 'Other', pl: 'Pozostałe' },
-            fields: orphans
+            fields: orphanTopSlugs
         }
     ];
 }

package/dist/core/server/generator/generator.js

@@ -31,7 +31,8 @@ function generateTypesStringForRecords(type, records) {
 		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
-        return `${single.slug}: ${toPascalCase(single.slug)}`;
+        const key = single.slug.includes('-') ? `'${single.slug}'` : single.slug;
+        return `${key}: ${toPascalCase(single.slug)}`;
     })
         .join(';\n')}
 		}
@@ -58,7 +59,8 @@ function generateTypesStringForForms(records) {
 		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
-        return `${single.slug}: ${toPascalCase(single.slug)}`;
+        const key = single.slug.includes('-') ? `'${single.slug}'` : single.slug;
+        return `${key}: ${toPascalCase(single.slug)}`;
     })
         .join(';\n')}
 		}
@@ -94,10 +96,10 @@ function generateAPI(config) {
 	`;
     code += `
 
-		interface GetEntryQueryOptions<T extends { data: Record<string, unknown> }> {
+		interface GetEntryQueryOptions {
 			id?: string;
 			status?: 'draft' | 'published' | 'scheduled' | 'archived';
-			dataValues?: Partial<T['data']>;
+			dataValues?: Record<string, unknown>;
 		}
 
 		interface GetEntryOptions {
@@ -118,7 +120,7 @@ function generateAPI(config) {
 		`;
     code += `
 
-		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions<SingleEntryMap[K]>, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
+		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
 			return (await getEntry({
 			  ...data,
 				slug,
@@ -126,7 +128,7 @@ function generateAPI(config) {
 			})) as unknown as SingleEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions<CollectionEntryMap[K]>, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
+		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
 			return (await getEntry({
 			  ...data,
 				slug,
@@ -134,7 +136,15 @@ function generateAPI(config) {
 			})) as unknown as CollectionEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntryOptions): Promise<CollectionEntryMap[K][]> {
+		interface GetEntriesQueryOptions {
+			ids?: string[];
+			status?: 'draft' | 'published' | 'scheduled' | 'archived';
+			dataValues?: Record<string, unknown>;
+			dataLike?: Record<string, unknown>;
+			orderBy?: { column: 'createdAt' | 'updatedAt' | 'sortOrder'; direction: 'asc' | 'desc' };
+		}
+
+		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntryOptions & GetEntriesQueryOptions = {}): Promise<CollectionEntryMap[K][]> {
 			return (await getEntries({ slug, ...options })) as unknown as CollectionEntryMap[K][];
 		}
 
@@ -162,8 +172,9 @@ function generateSchemas(config) {
 		import { z } from 'zod';
 	`;
     config.forms?.map((form) => {
+        const varName = toPascalCase(form.slug);
         code += `
-			export const ${form.slug}FormSchema = ${generateZodSchemaStringFromFormFieldsAsString(form.fields)} \n
+			export const ${varName}FormSchema = ${generateZodSchemaStringFromFormFieldsAsString(form.fields)} \n
 		`;
     });
     writeFileSync(filePath, code);
@@ -177,13 +188,13 @@ function generateRemote(config) {
     code += `import { command } from '$app/server';\n`;
     code += `import { submitForm } from './api';\n`;
     const schemaImports = config.forms
-        .map((form) => `${form.slug}FormSchema`)
+        .map((form) => `${toPascalCase(form.slug)}FormSchema`)
         .join(', ');
     code += `import { ${schemaImports} } from './schemas';\n\n`;
     config.forms.forEach((form) => {
         const pascalSlug = toPascalCase(form.slug);
         code += `export const submit${pascalSlug}Command = command(\n`;
-        code += `\t${form.slug}FormSchema,\n`;
+        code += `\t${pascalSlug}FormSchema,\n`;
         code += `\tasync (data) => {\n`;
         code += `\t\tawait submitForm('${form.slug}', data);\n`;
         code += `\t}\n`;

package/dist/entity/index.d.ts

@@ -0,0 +1,26 @@
+import type { CMS } from '../core/cms.js';
+import type { DbEntry, DbEntryVersion, EntryData } from '../types/entries.js';
+interface EntityAPIOptions {
+    userId?: string;
+}
+interface CreateOptions {
+    skipValidation?: boolean;
+    sortOrder?: number;
+}
+export declare function createEntityAPI(cms: CMS, opts?: EntityAPIOptions): {
+    create(slug: string, data?: EntryData, options?: CreateOptions): Promise<DbEntry>;
+    update(entryId: string, data: EntryData, options?: {
+        skipValidation?: boolean;
+    }): Promise<DbEntryVersion>;
+    publish(entryId: string): Promise<void>;
+    unpublish(entryId: string): Promise<void>;
+    archive(entryId: string): Promise<void>;
+    unarchive(entryId: string): Promise<void>;
+    delete(entryId: string): Promise<void>;
+    list(slug: string, options?: {
+        includeArchived?: boolean;
+        onlyArchived?: boolean;
+    }): Promise<import("../types/entries.js").RawEntry[]>;
+    createAndPublish(slug: string, data: EntryData, options?: CreateOptions): Promise<DbEntry>;
+};
+export {};