includio-cms 0.7.2 → 0.13.1

package/dist/sveltekit/components/preview.svelte

@@ -1,9 +1,5 @@
-<script lang="ts" generics="T extends { data: PopulatedEntryData }">
-	import type { PopulatedEntryData } from '../../types/entries.js';
+<script lang="ts" generics="T extends Record<string, unknown>">
 	import { onMount, type Snippet } from 'svelte';
-	import { enableHybridEditing } from './hybrid-context.js';
-
-	enableHybridEditing();
 
 	type Props = {
 		entry: T;
@@ -13,230 +9,10 @@
 	let { entry, child }: Props = $props();
 
 	let previewData: T = $state(entry);
-	let hybridModeEnabled = $state(false);
-	let highlightedPath = $state<string | null>(null);
 	let parentOrigin: string | null = null;
 
-	/**
-	 * Checks if a value looks like a UUID reference
-	 */
-	function isUUID(value: unknown): value is string {
-		if (typeof value !== 'string') return false;
-		return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-	}
-
-	/**
-	 * Checks if a value is a block with slug and data (e.g., {slug: "card", data: {...}})
-	 */
-	function isBlock(value: unknown): value is { slug: string; data: Record<string, unknown> } {
-		return (
-			typeof value === 'object' &&
-			value !== null &&
-			'slug' in value &&
-			'data' in value &&
-			typeof (value as Record<string, unknown>).slug === 'string'
-		);
-	}
-
-	/**
-	 * Checks if a value is a resolved media/file object with nested data
-	 * e.g., { data: { id: "...", url: "...", ... }, styles: {} }
-	 */
-	function isResolvedMediaBlock(
-		value: unknown
-	): value is { data: { id: string; [key: string]: unknown }; [key: string]: unknown } {
-		return (
-			typeof value === 'object' &&
-			value !== null &&
-			'data' in value &&
-			typeof (value as Record<string, unknown>).data === 'object' &&
-			(value as Record<string, unknown>).data !== null &&
-			'id' in ((value as Record<string, unknown>).data as Record<string, unknown>) &&
-			'url' in ((value as Record<string, unknown>).data as Record<string, unknown>)
-		);
-	}
-
-	/**
-	 * Checks if a value is a simple resolved reference (has id UUID at top level)
-	 * e.g., { id: "...", slug: "...", type: "collection" } or { id: "...", url: "...", width: 800 }
-	 */
-	function isResolvedReference(
-		value: unknown
-	): value is { id: string; [key: string]: unknown } {
-		return (
-			typeof value === 'object' &&
-			value !== null &&
-			'id' in value &&
-			typeof (value as Record<string, unknown>).id === 'string' &&
-			isUUID((value as Record<string, unknown>).id)
-		);
-	}
-
-	/**
-	 * Checks if a value looks like a localized object (has language keys like 'pl', 'en')
-	 */
-	function isLocalizedObject(value: unknown): value is Record<string, unknown> {
-		if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
-		const keys = Object.keys(value);
-		// Common language codes
-		const langCodes = ['pl', 'en', 'de', 'fr', 'es', 'it', 'uk', 'cs', 'sk'];
-		return keys.length > 0 && keys.every((k) => langCodes.includes(k));
-	}
-
-	/**
-	 * Deep merges form data with original populated data, preserving resolved references
-	 * when the ID hasn't changed. This allows live preview to work without losing
-	 * populated image/file/relation data.
-	 */
-	function deepMergeWithReferences(
-		original: PopulatedEntryData,
-		updates: Record<string, unknown>
-	): PopulatedEntryData {
-		const result: PopulatedEntryData = { ...original };
-
-		for (const key in updates) {
-			const updateValue = updates[key];
-			const originalValue = original[key];
-
-			// Case 1: Update is a UUID string, original is a resolved media block { data: { id, url, ... }, styles: {} }
-			if (isUUID(updateValue) && isResolvedMediaBlock(originalValue)) {
-				if (originalValue.data.id === updateValue) {
-					// Same ID - keep the fully populated original
-					continue;
-				} else {
-					// Different ID - mark as pending
-					result[key] = { data: { id: updateValue, _pending: true }, styles: {} };
-				}
-				continue;
-			}
-
-			// Case 2: Update is a UUID string, original is a simple resolved reference { id, url, ... }
-			if (isUUID(updateValue) && isResolvedReference(originalValue)) {
-				if (originalValue.id === updateValue) {
-					// Same ID - keep the fully populated original
-					continue;
-				} else {
-					// Different ID - mark as pending
-					result[key] = { id: updateValue, _pending: true };
-				}
-				continue;
-			}
-
-			// Case 3: Both are arrays - merge based on index and slug matching for blocks
-			if (Array.isArray(updateValue) && Array.isArray(originalValue)) {
-				const mergedArray: unknown[] = [];
-
-				for (let i = 0; i < updateValue.length; i++) {
-					const updateItem = updateValue[i];
-
-					// Handle UUID in array
-					if (isUUID(updateItem)) {
-						// Find matching resolved object in original by ID
-						const matchingOriginal = originalValue.find((orig) => {
-							if (isResolvedMediaBlock(orig)) return orig.data.id === updateItem;
-							if (isResolvedReference(orig)) return orig.id === updateItem;
-							return false;
-						});
-						if (matchingOriginal) {
-							mergedArray.push(matchingOriginal);
-						} else {
-							mergedArray.push({ id: updateItem, _pending: true });
-						}
-						continue;
-					}
-
-					// Handle blocks with slug and data
-					if (isBlock(updateItem)) {
-						// Try to find matching block in original by same index and slug
-						const originalItem = originalValue[i];
-						if (isBlock(originalItem) && originalItem.slug === updateItem.slug) {
-							// Recursively merge the data inside the block
-							mergedArray.push({
-								slug: updateItem.slug,
-								data: deepMergeWithReferences(
-									originalItem.data as PopulatedEntryData,
-									updateItem.data
-								)
-							});
-						} else {
-							// No matching block, use update as-is
-							mergedArray.push(updateItem);
-						}
-						continue;
-					}
-
-					// Handle other nested objects
-					if (typeof updateItem === 'object' && updateItem !== null) {
-						const originalItem = originalValue[i];
-						if (typeof originalItem === 'object' && originalItem !== null) {
-							mergedArray.push(
-								deepMergeWithReferences(
-									originalItem as PopulatedEntryData,
-									updateItem as Record<string, unknown>
-								)
-							);
-						} else {
-							mergedArray.push(updateItem);
-						}
-						continue;
-					}
-
-					// Primitive value
-					mergedArray.push(updateItem);
-				}
-
-				result[key] = mergedArray;
-				continue;
-			}
-
-			// Case 4: Update is localized object {pl: "..."}, original is plain string
-			// Use the current language value or first available
-			if (isLocalizedObject(updateValue) && typeof originalValue === 'string') {
-				const langs = Object.keys(updateValue);
-				// Try 'pl' first, then first available
-				result[key] = updateValue['pl'] ?? updateValue[langs[0]] ?? originalValue;
-				continue;
-			}
-
-			// Case 5: Both are blocks with slug/data - merge recursively
-			if (
-				isBlock(updateValue) &&
-				isBlock(originalValue) &&
-				updateValue.slug === originalValue.slug
-			) {
-				result[key] = {
-					slug: updateValue.slug,
-					data: deepMergeWithReferences(originalValue.data as PopulatedEntryData, updateValue.data)
-				};
-				continue;
-			}
-
-			// Case 6: Both are nested objects (but not arrays) - recursively merge
-			if (
-				typeof updateValue === 'object' &&
-				updateValue !== null &&
-				!Array.isArray(updateValue) &&
-				typeof originalValue === 'object' &&
-				originalValue !== null &&
-				!Array.isArray(originalValue)
-			) {
-				result[key] = deepMergeWithReferences(
-					originalValue as PopulatedEntryData,
-					updateValue as Record<string, unknown>
-				);
-				continue;
-			}
-
-			// Case 7: Simple value replacement (strings, numbers, booleans, etc.)
-			result[key] = updateValue;
-		}
-
-		return result;
-	}
-
 	onMount(() => {
 		function handleMessage(e: MessageEvent) {
-			// Accept first message from any origin (handshake), then lock to that origin
 			if (!parentOrigin) {
 				parentOrigin = e.origin;
 			} else if (e.origin !== parentOrigin) {
@@ -244,103 +20,17 @@
 			}
 
 			if (e.data.type === 'preview-update') {
-				// Merge form data with current preview data, preserving resolved references
-				previewData = {
-					...previewData,
-					data: deepMergeWithReferences(previewData.data as PopulatedEntryData, e.data.data)
-				} as T;
-			}
-
-			if (e.data.type === 'hybrid-mode-enable') {
-				hybridModeEnabled = e.data.enabled;
-				updateHybridClickHandlers();
-			}
-
-			// Highlight from form focus
-			if (e.data.type === 'hybrid-highlight') {
-				highlightedPath = e.data.path;
-				updateHighlight();
+				previewData = { ...previewData, ...e.data.data } as T;
 			}
 		}
 
 		window.addEventListener('message', handleMessage);
-		// Block link clicks in hybrid mode
-		document.addEventListener('click', handleLinkClick, true);
-
-		// Signal to parent that preview is ready to receive data
 		window.parent.postMessage({ type: 'preview-ready' }, parentOrigin || '*');
 
 		return () => {
 			window.removeEventListener('message', handleMessage);
-			document.removeEventListener('click', handleLinkClick, true);
 		};
 	});
-
-	function updateHybridClickHandlers() {
-		// Remove existing handlers and styles
-		document.querySelectorAll('[data-hybrid-path]').forEach((el) => {
-			el.removeEventListener('click', handleHybridClick as EventListener);
-			(el as HTMLElement).classList.remove('hybrid-editable');
-		});
-
-		if (hybridModeEnabled) {
-			// Add click handlers and styles for hybrid elements
-			document.querySelectorAll('[data-hybrid-path]').forEach((el) => {
-				el.addEventListener('click', handleHybridClick as EventListener);
-				(el as HTMLElement).classList.add('hybrid-editable');
-			});
-		}
-	}
-
-	// Block all link navigation when in hybrid mode
-	function handleLinkClick(e: MouseEvent) {
-		if (!hybridModeEnabled) return;
-
-		const link = (e.target as HTMLElement).closest('a');
-		if (link && link.href) {
-			e.preventDefault();
-			e.stopPropagation();
-		}
-	}
-
-	function updateHighlight() {
-		// Remove all highlights
-		document.querySelectorAll('[data-hybrid-path]').forEach((el) => {
-			(el as HTMLElement).classList.remove('hybrid-highlighted');
-		});
-
-		// Add highlight to matching element
-		if (highlightedPath) {
-			const el = document.querySelector(`[data-hybrid-path="${highlightedPath}"]`) as HTMLElement;
-			if (el) {
-				el.classList.add('hybrid-highlighted');
-			}
-		}
-	}
-
-	function handleHybridClick(e: MouseEvent) {
-		e.preventDefault();
-		e.stopPropagation();
-
-		// Find the closest element with data-hybrid-path
-		const target = (e.target as HTMLElement).closest('[data-hybrid-path]') as HTMLElement;
-		if (!target) return;
-
-		const path = target.dataset.hybridPath;
-		if (path) {
-			// Normalize to dot notation (hero[0].data → hero.0.data)
-			const normalized = path.replace(/\[(\d+)\]/g, '.$1');
-			window.parent.postMessage({ type: 'hybrid-focus', path: normalized }, parentOrigin || '*');
-		}
-	}
-
-	// Re-apply handlers when previewData changes
-	$effect(() => {
-		if (previewData && hybridModeEnabled) {
-			// Small delay to ensure DOM is updated
-			setTimeout(updateHybridClickHandlers, 100);
-		}
-	});
 </script>
 
 {#if child}
@@ -350,17 +40,3 @@
 {:else}
 	<pre>{JSON.stringify(previewData, null, 2)}</pre>
 {/if}
-
-<style>
-	:global(.hybrid-editable) {
-		cursor: pointer;
-		outline: 2px dashed transparent;
-		outline-offset: 4px;
-		transition: outline-color 0.15s ease;
-	}
-
-	:global(.hybrid-editable:hover),
-	:global(.hybrid-highlighted) {
-		outline-color: #3b82f6;
-	}
-</style>

package/dist/sveltekit/components/preview.svelte.d.ts

@@ -1,8 +1,5 @@
-import type { PopulatedEntryData } from '../../types/entries.js';
 import { type Snippet } from 'svelte';
-declare function $$render<T extends {
-    data: PopulatedEntryData;
-}>(): {
+declare function $$render<T extends Record<string, unknown>>(): {
     props: {
         entry: T;
         child?: Snippet<[{
@@ -14,9 +11,7 @@ declare function $$render<T extends {
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<T extends {
-    data: PopulatedEntryData;
-}> {
+declare class __sveltets_Render<T extends Record<string, unknown>> {
     props(): ReturnType<typeof $$render<T>>['props'];
     events(): ReturnType<typeof $$render<T>>['events'];
     slots(): ReturnType<typeof $$render<T>>['slots'];
@@ -24,18 +19,12 @@ declare class __sveltets_Render<T extends {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <T extends {
-        data: PopulatedEntryData;
-    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+    new <T extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
     } & ReturnType<__sveltets_Render<T>['exports']>;
-    <T extends {
-        data: PopulatedEntryData;
-    }>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Preview: $$IsomorphicComponent;
-type Preview<T extends {
-    data: PopulatedEntryData;
-}> = InstanceType<typeof Preview<T>>;
+type Preview<T extends Record<string, unknown>> = InstanceType<typeof Preview<T>>;
 export default Preview;

package/dist/sveltekit/server/index.d.ts

@@ -1,5 +1,6 @@
 export { includioCMS } from './handle.js';
-export { getEntry, getEntries } from '../../core/server/entries/operations/get.js';
+export { getEntry, getEntries, countEntries } from '../../core/server/entries/operations/get.js';
 export { createFormSubmission } from '../../core/server/forms/submissions/operations/create.js';
+export { parseFormDataForSubmission } from '../../core/server/forms/submissions/utils/parseMultipart.js';
 export { createConsentLog } from '../../core/server/consentLogs/operations/create.js';
 export { getPreviewEntry } from './preview.js';

package/dist/sveltekit/server/index.js

@@ -1,5 +1,6 @@
 export { includioCMS } from './handle.js';
-export { getEntry, getEntries } from '../../core/server/entries/operations/get.js';
+export { getEntry, getEntries, countEntries } from '../../core/server/entries/operations/get.js';
 export { createFormSubmission } from '../../core/server/forms/submissions/operations/create.js';
+export { parseFormDataForSubmission } from '../../core/server/forms/submissions/utils/parseMultipart.js';
 export { createConsentLog } from '../../core/server/consentLogs/operations/create.js';
 export { getPreviewEntry } from './preview.js';

package/dist/sveltekit/server/preview.js

@@ -9,11 +9,8 @@ export async function getPreviewEntry(event, options) {
     if (!authLocals.user || !authLocals.session) {
         throw new Error('Unauthorized');
     }
-    if (preview) {
-        return getEntryVersion({
-            id: preview,
-            language: options.language
-        });
-    }
-    return null;
+    return getEntryVersion({
+        id: preview,
+        language: options.language
+    });
 }

package/dist/types/adapters/db.d.ts

@@ -1,5 +1,5 @@
 import type { ConsentLogData } from '../consent.js';
-import type { DbEntry, DbEntryInsert, DbEntryVersion, DbEntryVersionInsert, GetDbEntriesOptions, GetDbEntryVersionsOptions, PaginationOptions } from '../entries.js';
+import type { DbEntry, DbEntryInsert, DbEntryVersion, DbEntryVersionInsert, GetDbEntriesOptions, GetDbEntryVersionsOptions, GetPaginatedEntriesOptions, PaginatedEntryRow, PaginationOptions } from '../entries.js';
 import type { ImageFieldStyle } from '../fields.js';
 import type { FormSubmission } from '../forms.js';
 import type { ImageStyle, MediaFile, MediaTag, UploadedMediaFile } from '../media.js';
@@ -20,6 +20,8 @@ export interface DatabaseAdapter {
     getFormSubmission: GetFormSubmission;
     updateFormSubmission: UpdateFormSubmission;
     deleteFormSubmission: DeleteFormSubmission;
+    getPaginatedEntries?: GetPaginatedEntries;
+    countPaginatedEntries?: CountPaginatedEntries;
     createConsentLog: CreateConsentLog;
     getMediaTags: GetMediaTags;
     createMediaTag: CreateMediaTag;
@@ -35,6 +37,8 @@ export interface DatabaseAdapter {
     getAllImageStyles: GetAllImageStyles;
     deleteAllImageStyles: DeleteAllImageStyles;
     getMediaFiles: GetMediaFiles;
+    countMediaFiles: CountMediaFiles;
+    getMediaTagsWithCounts: GetMediaTagsWithCounts;
     getMediaFile: GetMediaFile;
     updateMediaFile: UpdateMediaFile;
     deleteMediaFile: DeleteMediaFile;
@@ -49,6 +53,8 @@ export type UpdateEntry = (data: {
 export type DeleteEntry = (data: {
     id: string;
 }) => Promise<void>;
+export type GetPaginatedEntries = (data: GetPaginatedEntriesOptions) => Promise<PaginatedEntryRow[]>;
+export type CountPaginatedEntries = (data: Omit<GetPaginatedEntriesOptions, 'limit' | 'offset' | 'orderBy'>) => Promise<number>;
 export type ArchiveEntry = (data: {
     id: string;
     archivedAt?: Date;
@@ -80,9 +86,17 @@ export interface GetMediaFilesOptions {
         ids?: string[];
         mimeTypes?: string[];
         search?: string;
+        untagged?: boolean;
+        limit?: number;
+        offset?: number;
     };
 }
 export type GetMediaFiles = (data: GetMediaFilesOptions) => Promise<MediaFile[]>;
+export type CountMediaFiles = (data: GetMediaFilesOptions) => Promise<number>;
+export type GetMediaTagsWithCounts = () => Promise<{
+    tag: MediaTag;
+    count: number;
+}[]>;
 export interface GetMediaFileOptions {
     data: {
         id?: string;

package/dist/types/adapters/files.d.ts

@@ -5,6 +5,12 @@ export interface FilesAdapter {
     renameFile: RenameFile;
     deleteFile: DeleteFile;
     listFiles: ListFiles;
+    uploadPrivateFile?: (file: File) => Promise<{
+        filename: string;
+        url: string;
+    }>;
+    downloadPrivateFile?: (filename: string) => Promise<File | null>;
+    deletePrivateFile?: (filename: string) => Promise<void>;
 }
 export type DownloadFile = (id: string) => Promise<File | null>;
 export type UploadFile = (file: File) => Promise<UploadedMediaFile>;

package/dist/types/cms.d.ts

@@ -36,6 +36,9 @@ export interface ApiKeyConfig {
     name?: string;
     role?: 'admin' | 'editor';
 }
+export interface TypographyConfig {
+    fixOrphans?: boolean;
+}
 export interface CMSConfig {
     languages: Language[];
     collections?: CollectionConfig[];
@@ -49,6 +52,7 @@ export interface CMSConfig {
     ai?: AIAdapter;
     media?: MediaConfig;
     apiKeys?: ApiKeyConfig[];
+    typography?: TypographyConfig;
 }
 export interface ICMS {
     collections: Record<string, CollectionConfigWithType>;
@@ -64,4 +68,5 @@ export interface ICMS {
     aiAdapter: AIAdapter | null;
     mediaConfig: MediaConfig;
     apiKeys: ApiKeyConfig[];
+    typographyConfig: TypographyConfig;
 }

package/dist/types/entries.d.ts

@@ -12,44 +12,40 @@ export interface DbEntry {
     id: string;
     slug: string;
     type: EntryType;
-    availableLocales: string[] | null;
     createdAt: Date;
     updatedAt: Date;
     archivedAt: Date | null;
-    publishedAt: Date | null;
-    publishedVersionId: string | null;
-    publishedBy: string | null;
     sortOrder: number | null;
 }
 export interface DbEntryInsert {
     slug: string;
     type: EntryType;
-    availableLocales?: string[] | null;
     createdAt?: Date;
     updatedAt?: Date;
     archivedAt?: Date | null;
-    publishedAt?: Date | null;
-    publishedVersionId?: string | null;
-    publishedBy?: string | null;
     sortOrder?: number | null;
 }
 export interface RawEntry extends DbEntry {
     collection: CollectionConfigWithType | SingleConfigWithType;
     versions: DbEntryVersion[];
-    publishedVersion: DbEntryVersion | null;
-    scheduledVersion: DbEntryVersion | null;
-    draftVersion: DbEntryVersion | null;
-}
-export interface Entry {
-    id: string;
-    data: PopulatedEntryData;
-    slug: string;
-    type: EntryType;
-    publishedAt?: Date | null;
+    /** Per-language published versions */
+    publishedVersions: Record<string, DbEntryVersion | null>;
+    /** Per-language scheduled versions */
+    scheduledVersions: Record<string, DbEntryVersion | null>;
+    /** Per-language latest draft versions */
+    draftVersions: Record<string, DbEntryVersion | null>;
 }
+export type Entry = {
+    _id: string;
+    _slug: string;
+    _type: EntryType;
+    _publishedAt?: Date | null;
+    _url?: string;
+} & Record<string, unknown>;
 export interface DbEntryVersion {
     id: string;
     entryId: string;
+    lang: string;
     versionNumber: number;
     data: EntryData;
     createdAt: Date;
@@ -59,6 +55,7 @@ export interface DbEntryVersion {
 }
 export interface DbEntryVersionInsert {
     entryId: string;
+    lang: string;
     versionNumber?: number;
     data: EntryData;
     createdAt?: Date;
@@ -73,6 +70,10 @@ export interface PaginationOptions {
         column: 'createdAt' | 'updatedAt' | 'sortOrder';
         direction: 'asc' | 'desc';
     };
+    dataOrderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
 }
 export interface GetDbEntriesOptions extends PaginationOptions {
     ids?: string[];
@@ -103,30 +104,65 @@ export interface GetEntriesOptions {
     slug?: string;
     dataValues?: Record<string, unknown>;
     dataLike?: Record<string, unknown>;
+    dataILikeOr?: Record<string, unknown>;
     language?: string;
     status?: EntryStatus;
     orderBy?: {
         column: 'createdAt' | 'updatedAt' | 'sortOrder';
         direction: 'asc' | 'desc';
     };
+    dataOrderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit?: number;
+    offset?: number;
 }
 export interface GetEntryOptions {
     id?: string;
     slug?: string;
     dataValues?: Record<string, unknown>;
     dataLike?: Record<string, unknown>;
+    dataILikeOr?: Record<string, unknown>;
     language?: string;
     status?: EntryStatus;
 }
 export interface GetDbEntryVersionsOptions {
     ids?: string[];
     entryIds?: string[];
+    lang?: string;
     dataValues?: Record<string, unknown>;
     dataLike?: Record<string, unknown>;
+    dataILikeOr?: Record<string, unknown>;
 }
 export interface GetDbEntryVersionOptions {
     id?: string;
     entryId?: string;
+    lang?: string;
     dataValues?: Record<string, unknown>;
     dataLike?: Record<string, unknown>;
+    dataILikeOr?: Record<string, unknown>;
+}
+export interface GetPaginatedEntriesOptions {
+    slug?: string;
+    ids?: string[];
+    language: string;
+    status: EntryStatus;
+    dataValues?: Record<string, unknown>;
+    dataLike?: Record<string, unknown>;
+    dataILikeOr?: Record<string, unknown>;
+    orderBy?: {
+        column: 'createdAt' | 'updatedAt' | 'sortOrder';
+        direction: 'asc' | 'desc';
+    };
+    dataOrderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit: number;
+    offset: number;
+}
+export interface PaginatedEntryRow {
+    entry: DbEntry;
+    version: DbEntryVersion;
 }