@karibsen/eponyme 0.1.1 → 0.2.0

package/dist/runtime/pages/EponymeIndexPage.vue

@@ -1,34 +1,149 @@
 <script setup>
-import { useRoute, useSeoMeta } from "#app";
+import { nextTick, ref } from "vue";
+import { refreshNuxtData, useRequestFetch, useRoute, useSeoMeta } from "#app";
 import EponymeNavigationLink from "../components/editor/EponymeNavigationLink.vue";
 import EponymeSidebar from "../components/editor/EponymeSidebar.vue";
+import EPButton from "../components/ui/EPButton.vue";
+import EPDialog from "../components/ui/EPDialog.vue";
+import EPToast from "../components/ui/EPToast.vue";
+import { useEponymeAuth } from "../composables/useEponymeAuth";
 import { useEponymeConfig } from "../composables/useEponymeConfig";
 import { getEponymeCollections, getEponymeForms, getEponymeSchemas } from "../utils/get-eponyme-schemas";
 const config = useEponymeConfig();
 const route = useRoute();
+const auth = useEponymeAuth();
+const request = useRequestFetch();
 const eponymes = getEponymeSchemas(config);
 const collections = getEponymeCollections(config);
 const forms = getEponymeForms(config);
 const entries = { ...eponymes, ...collections, ...forms };
 useSeoMeta({ title: "Eponyme" });
+const fileInput = ref();
+const exporting = ref(false);
+const importing = ref(false);
+const preview = ref();
+const pendingFile = ref();
+const toast = ref({ open: false, title: "", description: "", variant: "success" });
 function label(name) {
   return name.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 }
+async function showToast(variant, title, description) {
+  toast.value.open = false;
+  await nextTick();
+  toast.value = { open: true, variant, title, description };
+}
+function describeError(caught, fallback) {
+  const error = caught;
+  const mismatch = error?.data?.data?.schemaMismatch;
+  const message = error?.statusMessage || error?.data?.statusMessage || fallback;
+  return mismatch?.length ? `${message} (${mismatch.join(", ")})` : message;
+}
+async function exportContent() {
+  exporting.value = true;
+  try {
+    const file = await request("/api/eponyme-export", { cache: "no-store" });
+    const url = URL.createObjectURL(new Blob([JSON.stringify(file, null, 2)], { type: "application/json" }));
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `eponyme-export-${file.eponyme.exportedAt.slice(0, 10)}.json`;
+    link.click();
+    URL.revokeObjectURL(url);
+  } catch (caught) {
+    await showToast("error", "Export failed", describeError(caught, "Unable to export the content."));
+  } finally {
+    exporting.value = false;
+  }
+}
+async function reviewFile(event) {
+  const input = event.target;
+  const file = input.files?.[0];
+  input.value = "";
+  if (!file) return;
+  importing.value = true;
+  try {
+    const parsed = JSON.parse(await file.text());
+    preview.value = await request("/api/eponyme-import?dryRun=1", { method: "POST", body: parsed });
+    pendingFile.value = parsed;
+  } catch (caught) {
+    pendingFile.value = void 0;
+    preview.value = void 0;
+    await showToast("error", "Import refused", caught instanceof SyntaxError ? "This file is not valid JSON." : describeError(caught, "Unable to read this export file."));
+  } finally {
+    importing.value = false;
+  }
+}
+async function confirmImport() {
+  if (!pendingFile.value) return;
+  importing.value = true;
+  try {
+    const result = await request("/api/eponyme-import", { method: "POST", body: pendingFile.value });
+    closePreview();
+    await refreshNuxtData();
+    await showToast(
+      "success",
+      "Content imported",
+      `${result.created} created, ${result.updated} updated${result.skipped.length ? `, ${result.skipped.length} skipped` : ""}.`
+    );
+  } catch (caught) {
+    await showToast("error", "Import failed", describeError(caught, "Unable to import this file."));
+  } finally {
+    importing.value = false;
+  }
+}
+function closePreview() {
+  preview.value = void 0;
+  pendingFile.value = void 0;
+}
 </script>
 
 <template>
   <main class="eponyme-root ep:flex ep:min-h-screen ep:flex-col ep:bg-theme-ep ep:font-sans ep:text-text-ep ep:md:flex-row">
     <EponymeSidebar :base-path="route.path" />
     <section class="ep:mx-auto ep:w-full ep:max-w-3xl ep:px-6 ep:py-8 ep:md:px-10 ep:md:py-12">
-      <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
-        Eponyme
-      </p>
-      <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
-        Content entries
-      </h1>
-      <p class="ep:mt-2 ep:text-sm ep:text-muted-ep">
-        Choose the content area you want to update.
-      </p>
+      <div class="ep:flex ep:flex-wrap ep:items-start ep:justify-between ep:gap-4">
+        <div>
+          <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
+            Eponyme
+          </p>
+          <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
+            Content entries
+          </h1>
+          <p class="ep:mt-2 ep:text-sm ep:text-muted-ep">
+            Choose the content area you want to update.
+          </p>
+        </div>
+        <div
+          v-if="auth.canEdit.value"
+          class="ep:flex ep:shrink-0 ep:items-center ep:gap-2"
+        >
+          <EPButton
+            label="Export"
+            icon="mingcute:download-2-line"
+            size="sm"
+            :loading="exporting"
+            :disabled="exporting"
+            title="Download every entry as a JSON file"
+            @click="exportContent"
+          />
+          <EPButton
+            v-if="auth.isOwner.value"
+            label="Import"
+            icon="mingcute:upload-2-line"
+            size="sm"
+            :loading="importing"
+            :disabled="importing"
+            title="Apply an export file from another environment"
+            @click="fileInput?.click()"
+          />
+          <input
+            ref="fileInput"
+            type="file"
+            accept="application/json,.json"
+            class="ep:hidden"
+            @change="reviewFile"
+          >
+        </div>
+      </div>
       <nav
         class="ep:mt-8 ep:grid ep:gap-3 ep:sm:grid-cols-2"
         aria-label="Content entries"
@@ -43,6 +158,54 @@ function label(name) {
         />
       </nav>
     </section>
+    <ClientOnly>
+      <EPDialog
+        :open="Boolean(preview)"
+        title="Import content"
+        description="Entries in the file overwrite their counterpart. Nothing is ever deleted."
+        @update:open="!$event && closePreview()"
+      >
+        <div v-if="preview">
+          <ul class="ep:m-0 ep:list-none ep:space-y-1 ep:p-0 ep:text-sm ep:text-muted-ep">
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.created }}</span> to create</li>
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.updated }}</span> to overwrite</li>
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.skipped.length }}</span> skipped</li>
+          </ul>
+          <ul
+            v-if="preview.skipped.length"
+            class="ep:mt-4 ep:max-h-40 ep:list-none ep:space-y-2 ep:overflow-y-auto ep:p-0 ep:text-xs ep:text-muted-ep"
+          >
+            <li
+              v-for="skipped in preview.skipped"
+              :key="skipped.name"
+            >
+              <span class="ep:font-medium ep:text-white">{{ skipped.name }}</span> — {{ skipped.reason }}
+            </li>
+          </ul>
+          <div class="ep:mt-6 ep:flex ep:justify-end ep:gap-2">
+            <EPButton
+              label="Cancel"
+              variant="ghost"
+              @click="closePreview"
+            />
+            <EPButton
+              label="Import"
+              variant="primary"
+              :loading="importing"
+              :disabled="importing || !preview.created && !preview.updated"
+              @click="confirmImport"
+            />
+          </div>
+        </div>
+      </EPDialog>
+      <EPToast
+        :open="toast.open"
+        :title="toast.title"
+        :description="toast.description"
+        :variant="toast.variant"
+        @update:open="toast.open = $event"
+      />
+    </ClientOnly>
   </main>
 </template>
 

package/dist/runtime/server/api/eponyme/[name].patch.js

@@ -1,6 +1,8 @@
 import { createError, defineEventHandler, getQuery, getRequestURL, readBody, setResponseStatus } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeBlockingHook, callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
   const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
@@ -8,7 +10,12 @@ export default defineEventHandler(async (event) => {
   if (!name) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
   const requestedAction = getQuery(event).action;
   const action = requestedAction === "draft" ? "draft" : "publish";
-  const result = await useEponymeService().patch(name, await readBody(event), action, user.id);
+  const service = useEponymeService();
+  const collection = splitEponymeCollectionEntry(service, name);
+  const body = await readBody(event);
+  const beforeSave = { name, collection, action, data: body, userId: user.id };
+  await callEponymeBlockingHook("eponyme:entry:beforeSave", beforeSave);
+  const result = await service.patch(name, beforeSave.data, action, user.id);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
   if ("conflict" in result && result.conflict)
     throw createError({ statusCode: 409, message: "This entry was changed by someone else. Reload the page to get the latest version." });
@@ -16,5 +23,14 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 422);
     return { errors: result.errors };
   }
+  await callEponymeHook(action === "publish" ? "eponyme:entry:published" : "eponyme:entry:saved", {
+    name,
+    collection,
+    action,
+    status: result.status,
+    publishedAt: result.publishedAt,
+    data: result.data,
+    userId: user.id
+  });
   return requestedAction ? result : { data: result.data };
 });

package/dist/runtime/server/api/eponyme-collections/[path].delete.js

@@ -1,11 +1,16 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
-  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
   const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-collections\//, ""));
-  if (!name || !await useEponymeService().deleteCollectionEntry(name))
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.deleteCollectionEntry(name))
     throw createError({ statusCode: 404, statusMessage: "Eponyme collection entry not found." });
+  await callEponymeHook("eponyme:entry:trashed", { name, collection, userId: user.id });
   return { deleted: true };
 });

package/dist/runtime/server/api/eponyme-export.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../services/eponyme-store.js").EponymeExportFile>>;
+export default _default;

package/dist/runtime/server/api/eponyme-export.get.js

@@ -0,0 +1,11 @@
+import { defineEventHandler, setResponseHeader } from "h3";
+import { useEponymeService } from "../services/eponyme-service.js";
+import { requireEponymeUser } from "../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  setResponseHeader(event, "Cache-Control", "no-store");
+  const file = await useEponymeService().exportContent();
+  const day = file.eponyme.exportedAt.slice(0, 10);
+  setResponseHeader(event, "Content-Disposition", `attachment; filename="eponyme-export-${day}.json"`);
+  return file;
+});

package/dist/runtime/server/api/eponyme-forms/[path].post.js

@@ -1,6 +1,7 @@
 import { createError, defineEventHandler, getRequestHeader, readRawBody, setResponseHeader, setResponseStatus } from "h3";
 import { useEponymeFormService } from "../../services/eponyme-form-service.js";
 import { readEponymeFormRoute } from "../../utils/form-route.js";
+import { callEponymeBlockingHook, callEponymeHook } from "../../utils/eponyme-hooks.js";
 export default defineEventHandler(async (event) => {
   const route = readEponymeFormRoute(event);
   const service = useEponymeFormService();
@@ -25,12 +26,24 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 201);
     return { submitted: true };
   }
-  const result = await service.submit(route.name, payload);
+  const validated = service.validate(route.name, payload);
+  if (validated && "errors" in validated) {
+    setResponseStatus(event, 422);
+    return { errors: validated.errors };
+  }
+  const beforeSubmit = { form: route.name, data: validated?.data ?? {} };
+  await callEponymeBlockingHook("eponyme:form:beforeSubmit", beforeSubmit);
+  const result = await service.submit(route.name, beforeSubmit.data);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
   if ("errors" in result) {
     setResponseStatus(event, 422);
     return { errors: result.errors };
   }
+  await callEponymeHook("eponyme:form:submitted", {
+    form: route.name,
+    data: result.submission.data,
+    id: result.submission.id
+  });
   setResponseStatus(event, 201);
   return { submitted: true, id: result.submission.id };
 });

package/dist/runtime/server/api/eponyme-history/[path].patch.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeResult | import("../../services/eponyme-store.js").EponymeConflict>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeResult>>;
 export default _default;

package/dist/runtime/server/api/eponyme-history/[path].patch.js

@@ -1,6 +1,8 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
   const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
@@ -10,9 +12,19 @@ export default defineEventHandler(async (event) => {
   const [, name, rawVersionId] = match;
   const versionId = Number(rawVersionId);
   if (!Number.isSafeInteger(versionId)) throw createError({ statusCode: 404, statusMessage: "Eponyme version not found." });
-  const result = await useEponymeService().restore(name, versionId, user.id);
+  const service = useEponymeService();
+  const result = await service.restore(name, versionId, user.id);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme version not found." });
-  if ("conflict" in result && result.conflict)
+  if ("conflict" in result)
     throw createError({ statusCode: 409, message: "This entry was changed by someone else. Reload the page to get the latest version." });
+  await callEponymeHook("eponyme:entry:restored", {
+    name,
+    collection: splitEponymeCollectionEntry(service, name),
+    action: "restore",
+    status: result.status,
+    publishedAt: result.publishedAt,
+    data: result.data,
+    userId: user.id
+  });
   return result;
 });

package/dist/runtime/server/api/eponyme-import.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../services/eponyme-store.js").EponymeImportResult>>;
+export default _default;

package/dist/runtime/server/api/eponyme-import.post.js

@@ -0,0 +1,31 @@
+import { createError, defineEventHandler, getQuery, getRequestHeader, readRawBody, setResponseHeader } from "h3";
+import { useEponymeService } from "../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../utils/auth.js";
+const MAX_BODY_BYTES = 5 * 1024 * 1024;
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["owner"] });
+  setResponseHeader(event, "Cache-Control", "no-store");
+  const declaredLength = Number(getRequestHeader(event, "content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_BODY_BYTES)
+    throw createError({ statusCode: 413, statusMessage: "Import file is too large." });
+  const raw = await readRawBody(event, "utf8");
+  if (raw && Buffer.byteLength(raw, "utf8") > MAX_BODY_BYTES)
+    throw createError({ statusCode: 413, statusMessage: "Import file is too large." });
+  let payload;
+  try {
+    payload = raw ? JSON.parse(raw) : void 0;
+  } catch {
+    throw createError({ statusCode: 400, statusMessage: "Import file must be valid JSON." });
+  }
+  const dryRun = Boolean(getQuery(event).dryRun);
+  const result = await useEponymeService().importContent(payload, { dryRun, actorId: user.id });
+  if ("errors" in result) {
+    throw createError({
+      statusCode: result.schemaMismatch?.length ? 409 : 400,
+      statusMessage: result.errors[0] ?? "This import could not be applied.",
+      data: { errors: result.errors, schemaMismatch: result.schemaMismatch ?? [] }
+    });
+  }
+  return result;
+});

package/dist/runtime/server/api/eponyme-trash/[path].delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    purged: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-trash/[path].delete.js

@@ -0,0 +1,16 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["owner"] });
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-trash\//, ""));
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.purgeCollectionEntry(name))
+    throw createError({ statusCode: 404, statusMessage: "Eponyme trashed entry not found." });
+  await callEponymeHook("eponyme:entry:purged", { name, collection, userId: user.id });
+  return { purged: true };
+});

package/dist/runtime/server/api/eponyme-trash/[path].get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeCollectionPage<Record<string, unknown>>>>;
+export default _default;

package/dist/runtime/server/api/eponyme-trash/[path].get.js

@@ -0,0 +1,11 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-trash\//, ""));
+  if (!name) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  const page = await useEponymeService().listCollectionTrash(name);
+  if (!page) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  return page;
+});

package/dist/runtime/server/api/eponyme-trash/[path].patch.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    restored: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-trash/[path].patch.js

@@ -0,0 +1,16 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-trash\//, ""));
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.restoreCollectionEntry(name))
+    throw createError({ statusCode: 404, statusMessage: "Eponyme trashed entry not found." });
+  await callEponymeHook("eponyme:entry:untrashed", { name, collection, userId: user.id });
+  return { restored: true };
+});

package/dist/runtime/server/services/eponyme-form-store.d.ts

@@ -1,5 +1,6 @@
 import type { EponymeConfig, EponymeFormDefinitionBase } from '../../types/index.js';
 import { type ValidationErrors } from '../../utils/validate-eponyme-data.js';
+/** Kept here rather than imported, so the store stays free of H3 imports. */
 type DateValue = Date | string;
 export interface EponymeFormSubmission {
     id: string;

package/dist/runtime/server/services/eponyme-store.d.ts

@@ -16,7 +16,7 @@ export interface EponymeVersionAuthor {
 }
 export interface EponymeHistoryEntry {
     id: number;
-    action: EponymeAction | 'restore';
+    action: EponymeAction | 'restore' | 'import';
     status: EponymeStatus;
     createdAt: string;
     user: EponymeVersionAuthor | null;
@@ -33,11 +33,47 @@ export interface EponymeCollectionEntry<Data extends Record<string, unknown> = R
     status: EponymeStatus;
     publishedAt: string | null;
     updatedAt: string | null;
+    /** Only set for entries read from the trash. */
+    deletedAt?: string | null;
 }
 export interface EponymeSitemapEntry {
     loc: string;
     lastmod?: string;
 }
+/** One entry of an export file: the complete stored state, without the envelope. */
+export interface EponymeExportEntry {
+    name: string;
+    /** Set for collection entries, so a reader can group them without re-parsing the name. */
+    collection?: string;
+    draft: Record<string, unknown>;
+    published: Record<string, unknown>;
+    status: EponymeStatus;
+    publishedAt: string | null;
+}
+export interface EponymeExportFile {
+    eponyme: {
+        format: 1;
+        exportedAt: string;
+        /** Schema fingerprint per singleton and per collection, checked before an import writes anything. */
+        schemas: Record<string, string>;
+    };
+    entries: EponymeExportEntry[];
+}
+export interface EponymeImportResult {
+    dryRun: boolean;
+    created: number;
+    updated: number;
+    skipped: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+/** The import was refused as a whole, before any write. */
+export interface EponymeImportRejection {
+    errors: string[];
+    /** Names whose configured schema differs from the one the file was exported with. */
+    schemaMismatch?: string[];
+}
 export type EponymeSortDirection = 'asc' | 'desc';
 export interface EponymeCollectionQuery {
     take?: number;
@@ -55,6 +91,11 @@ export type PrismaEponymeRow = {
     name: string;
     data: unknown;
     updatedAt?: Date | string;
+    deletedAt?: Date | string | null;
+};
+/** `null` keeps the live rows, `{ not: null }` the trashed ones. */
+export type PrismaDeletedAtFilter = null | {
+    not: null;
 };
 export type PrismaEponymeVersionRow = {
     id: number;
@@ -96,9 +137,11 @@ export type PrismaEponymeClient = {
             where: {
                 name: string;
                 updatedAt?: Date | string;
+                deletedAt?: PrismaDeletedAtFilter;
             };
             data: {
-                data: Record<string, unknown>;
+                data?: Record<string, unknown>;
+                deletedAt?: Date | null;
             };
         }): Promise<{
             count: number;
@@ -119,6 +162,7 @@ export type PrismaEponymeClient = {
                 name: {
                     startsWith: string;
                 };
+                deletedAt?: PrismaDeletedAtFilter;
             };
             orderBy: Array<{
                 updatedAt: 'desc';
@@ -197,13 +241,40 @@ export declare class EponymeService {
      * one query per collection rather than one query per entry.
      */
     getSitemapEntries(previewPaths: Record<string, string>): Promise<EponymeSitemapEntry[]>;
+    /**
+     * Every singleton and every live collection entry, as a portable file.
+     * Collections are read with one query each rather than one per entry.
+     */
+    exportContent(): Promise<EponymeExportFile>;
+    /**
+     * Applies an export file on top of the current content: every entry it carries is
+     * upserted, everything else is left alone. Nothing is ever deleted.
+     *
+     * The schema check runs first and refuses the whole file, so an import can never
+     * land half of its entries into a configuration that no longer matches.
+     */
+    importContent(file: unknown, options?: {
+        dryRun?: boolean;
+        actorId?: string;
+    }): Promise<EponymeImportResult | EponymeImportRejection>;
     createCollectionEntry(name: string, payload: unknown, actorId?: string): Promise<(EponymeResult & {
         slug: string;
         errors?: never;
     }) | {
         errors: ValidationErrors;
     } | undefined>;
+    /**
+     * A trashed entry keeps its row, so it keeps its slug: reusing one has to be
+     * refused with an error the editor can act on rather than the generic message.
+     */
+    private slugTakenError;
+    /** Moves an entry to the trash. Its history is kept, so it stays restorable. */
     deleteCollectionEntry(name: string): Promise<boolean>;
+    restoreCollectionEntry(name: string): Promise<boolean>;
+    /** Definitive: `onDelete: Cascade` takes the entry's whole history with it. */
+    purgeCollectionEntry(name: string): Promise<boolean>;
+    /** Trashed entries of a collection, most recently updated first. */
+    listCollectionTrash(name: string): Promise<EponymeCollectionPage | undefined>;
     patch(name: string, payload: unknown, action?: EponymeAction, actorId?: string): Promise<(EponymeResult & {
         errors?: never;
         conflict?: never;
@@ -214,4 +285,6 @@ export declare class EponymeService {
     history(name: string, limit?: number): Promise<EponymeHistoryEntry[] | undefined>;
     restore(name: string, versionId: number, actorId?: string): Promise<EponymeResult | EponymeConflict | undefined>;
 }
+/** Stable hash of a schema's shape, embedded in an export and checked on import. */
+export declare function schemaFingerprint(schema: EponymeSchema): string;
 export declare function isPrismaError(error: unknown, code: string): boolean;