@karibsen/eponyme 0.1.0

package/dist/runtime/server/services/eponyme-store.js

@@ -0,0 +1,338 @@
+import { isDeepStrictEqual } from "node:util";
+import { createDefaultEponymeData } from "../../utils/create-default-eponyme-data.js";
+import { getEponymeCollections, getEponymeSchemas } from "../../utils/get-eponyme-schemas.js";
+import { normalizeSlug } from "../../utils/normalize-slug.js";
+import { applyPreviewSlug } from "../../utils/preview.js";
+import { validateEponymeData, validateEponymePatch } from "../../utils/validate-eponyme-data.js";
+export class EponymeService {
+  constructor(config, client) {
+    this.client = client;
+    this.schemas = getEponymeSchemas(config);
+    this.collections = getEponymeCollections(config);
+  }
+  schemas;
+  collections;
+  getSchema(name) {
+    return this.schemas[name] ?? this.getCollectionEntry(name)?.definition.fields;
+  }
+  getCollection(name) {
+    return this.collections[name];
+  }
+  getCollectionEntry(name) {
+    for (const [collectionName, definition] of Object.entries(this.collections)) {
+      const prefix = `${collectionName}/`;
+      if (!name.startsWith(prefix)) continue;
+      const slug = name.slice(prefix.length);
+      if (slug && !slug.includes("/")) return { name: collectionName, slug, definition };
+    }
+  }
+  /** Reconcile every configured eponyme at application startup. */
+  async syncAll() {
+    await Promise.all(Object.keys(this.schemas).map((name) => this.loadState(name)));
+  }
+  reconcile(schema, value, mode) {
+    const persisted = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    const defaults = createDefaultEponymeData(schema);
+    return Object.fromEntries(Object.keys(schema).map((key) => {
+      const candidate = key in persisted ? persisted[key] : defaults[key];
+      const errors = validateEponymeData({ [key]: schema[key] }, { [key]: candidate }, mode);
+      return [key, Object.keys(errors).length ? defaults[key] : candidate];
+    }));
+  }
+  createState(schema, value) {
+    const data = this.reconcile(schema, value ?? createDefaultEponymeData(schema), "publish");
+    return {
+      __eponyme: {
+        version: 1,
+        draft: data,
+        published: data,
+        status: "published",
+        publishedAt: null
+      }
+    };
+  }
+  normalizeState(schema, value) {
+    const stored = getStoredState(value);
+    if (!stored) return this.createState(schema, value);
+    return {
+      __eponyme: {
+        version: 1,
+        draft: this.reconcile(schema, stored.draft, "draft"),
+        published: this.reconcile(schema, stored.published, "publish"),
+        status: stored.status,
+        publishedAt: stored.publishedAt
+      }
+    };
+  }
+  /** Reads the stored state along with the `updatedAt` it was read at, used as the optimistic lock token. */
+  async loadRow(name) {
+    const schema = this.getSchema(name);
+    if (!schema) return void 0;
+    const defaults = this.createState(schema);
+    const row = this.getCollectionEntry(name) ? await this.client.eponyme.findUnique({ where: { name } }) : await this.client.eponyme.upsert({ where: { name }, create: { name, data: defaults }, update: {} });
+    if (!row) return void 0;
+    const state = this.normalizeState(schema, row.data);
+    if (sameData(state, row.data)) return { state, updatedAt: row.updatedAt };
+    const healed = await this.client.eponyme.update({ where: { name }, data: { data: state } });
+    return { state, updatedAt: healed.updatedAt ?? row.updatedAt };
+  }
+  async loadState(name) {
+    return (await this.loadRow(name))?.state;
+  }
+  /**
+   * Writes a new state only if the row still carries the `updatedAt` we read.
+   * Returns false when a concurrent editor won the race, so the caller can report a conflict
+   * instead of silently discarding their changes.
+   */
+  async writeState(name, next, expectedUpdatedAt) {
+    const data = next;
+    if (!expectedUpdatedAt) {
+      await this.client.eponyme.update({ where: { name }, data: { data } });
+      return true;
+    }
+    const { count } = await this.client.eponyme.updateMany({ where: { name, updatedAt: expectedUpdatedAt }, data: { data } });
+    return count > 0;
+  }
+  async get(name, version = "published") {
+    return (await this.getResult(name, version))?.data;
+  }
+  async getResult(name, version = "published") {
+    if (typeof version === "number") return this.getVersionResult(name, version);
+    const state = await this.loadState(name);
+    if (!state) return void 0;
+    if (version === "published" && this.getCollectionEntry(name) && !state.__eponyme.publishedAt) return void 0;
+    return {
+      data: state.__eponyme[version],
+      status: state.__eponyme.status,
+      publishedAt: state.__eponyme.publishedAt
+    };
+  }
+  /** Content as it was in a given version, for previewing without restoring it. */
+  async getVersionResult(name, versionId) {
+    const schema = this.getSchema(name);
+    if (!schema) return void 0;
+    const version = await this.client.eponymeVersion.findUnique({ where: { id: versionId } });
+    if (!version || version.entryName !== name) return void 0;
+    const state = this.normalizeState(schema, version.data);
+    return {
+      data: state.__eponyme.draft,
+      status: state.__eponyme.status,
+      publishedAt: state.__eponyme.publishedAt
+    };
+  }
+  async statuses() {
+    const entries = await Promise.all(Object.keys(this.schemas).map(async (name) => {
+      const state = await this.loadState(name);
+      return [name, state?.__eponyme.status ?? "published"];
+    }));
+    return Object.fromEntries(entries);
+  }
+  async listCollection(name, version = "published") {
+    const definition = this.collections[name];
+    if (!definition) return void 0;
+    const rows = await this.client.eponyme.findMany({
+      where: { name: { startsWith: `${name}/` } },
+      orderBy: [
+        { updatedAt: "desc" },
+        { name: "asc" }
+      ]
+    });
+    const entries = await Promise.all(rows.filter((row) => !row.name.slice(name.length + 1).includes("/")).map(async (row) => {
+      const slug = row.name.slice(name.length + 1);
+      const result = await this.getResult(row.name, version);
+      return {
+        slug,
+        title: String(result?.data[definition.titleField] || slug),
+        data: result?.data ?? {},
+        status: version === "published" ? "published" : result?.status ?? "draft",
+        publishedAt: result?.publishedAt ?? null,
+        updatedAt: row.updatedAt ? new Date(row.updatedAt).toISOString() : null
+      };
+    }));
+    return version === "draft" ? entries : entries.filter((entry) => entry.publishedAt);
+  }
+  /**
+   * Builds the public URL list configured by `previewPaths`.
+   * Collections are resolved directly from their stored rows so this performs
+   * one query per collection rather than one query per entry.
+   */
+  async getSitemapEntries(previewPaths) {
+    const groups = await Promise.all(Object.entries(previewPaths).map(async ([name, path]) => {
+      const collection = this.collections[name];
+      if (!collection) {
+        const result = await this.getResult(name, "published");
+        if (!result) return [];
+        return [withLastmod(path, result.publishedAt)];
+      }
+      if (!path.includes(":slug"))
+        throw new Error(`[Eponyme] previewPaths.${name} must include ":slug" to generate collection sitemap URLs.`);
+      const rows = await this.client.eponyme.findMany({
+        where: { name: { startsWith: `${name}/` } },
+        orderBy: [
+          { updatedAt: "desc" },
+          { name: "asc" }
+        ]
+      });
+      return rows.flatMap((row) => {
+        const slug = row.name.slice(name.length + 1);
+        if (!slug || slug.includes("/")) return [];
+        const state = this.normalizeState(collection.fields, row.data);
+        if (!state.__eponyme.publishedAt) return [];
+        return [withLastmod(applyPreviewSlug(path, slug), state.__eponyme.publishedAt)];
+      });
+    }));
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of groups.flat())
+      entries.set(entry.loc, entry);
+    return [...entries.values()];
+  }
+  async createCollectionEntry(name, payload, actorId) {
+    const definition = this.collections[name];
+    if (!definition) return void 0;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { errors: { _form: ["Body must be an object."] } };
+    const input = payload;
+    if (!String(input[definition.titleField] || "").trim())
+      return { errors: { [definition.titleField]: ["This field is required."] } };
+    const slug = normalizeSlug(String(input[definition.slugField] || input[definition.titleField] || ""));
+    if (!slug) return { errors: { [definition.slugField]: ["A slug or title is required."] } };
+    const entryName = `${name}/${slug}`;
+    if (await this.client.eponyme.findUnique({ where: { name: entryName } }))
+      return { errors: { [definition.slugField]: ["This slug is already in use."] } };
+    const defaults = createDefaultEponymeData(definition.fields);
+    const data = { ...defaults, ...input, [definition.slugField]: slug };
+    const errors = validateEponymePatch(definition.fields, data, data, "draft");
+    if (Object.keys(errors).length) return { errors };
+    const state = {
+      __eponyme: {
+        version: 1,
+        draft: data,
+        published: defaults,
+        status: "draft",
+        publishedAt: null
+      }
+    };
+    try {
+      await this.client.eponyme.create({ data: { name: entryName, data: state } });
+    } catch (error) {
+      if (isPrismaError(error, "P2002")) return { errors: { [definition.slugField]: ["This slug is already in use."] } };
+      throw error;
+    }
+    await this.client.eponymeVersion.create({ data: { entryName, data: state, action: "draft", status: "draft", userId: actorId ?? null } });
+    return { slug, data, status: "draft", publishedAt: null };
+  }
+  async deleteCollectionEntry(name) {
+    if (!this.getCollectionEntry(name)) return false;
+    try {
+      await this.client.eponyme.delete({ where: { name } });
+    } catch (error) {
+      if (isPrismaError(error, "P2025")) return false;
+      throw error;
+    }
+    return true;
+  }
+  async patch(name, payload, action = "publish", actorId) {
+    const schema = this.getSchema(name);
+    if (!schema) return void 0;
+    const row = await this.loadRow(name);
+    if (!row) return void 0;
+    const { state, updatedAt } = row;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { errors: { _form: ["Body must be an object."] } };
+    const collectionEntry = this.getCollectionEntry(name);
+    if (collectionEntry && collectionEntry.definition.slugField in payload) {
+      const submittedSlug = payload[collectionEntry.definition.slugField];
+      if (submittedSlug !== collectionEntry.slug)
+        return { errors: { [collectionEntry.definition.slugField]: ["The slug cannot be changed after creation."] } };
+    }
+    const data = { ...state.__eponyme.draft, ...payload };
+    const patchErrors = validateEponymePatch(schema, payload, data, action);
+    const errors = action === "publish" ? mergeErrors(patchErrors, validateEponymeData(schema, data, "publish")) : patchErrors;
+    if (Object.keys(errors).length) return { errors };
+    const publishedAt = action === "publish" ? (/* @__PURE__ */ new Date()).toISOString() : state.__eponyme.publishedAt;
+    const next = {
+      __eponyme: {
+        version: 1,
+        draft: data,
+        published: action === "publish" ? data : state.__eponyme.published,
+        status: action === "publish" ? "published" : "draft",
+        publishedAt
+      }
+    };
+    if (!await this.writeState(name, next, updatedAt)) return { conflict: true };
+    await this.client.eponymeVersion.create({
+      data: {
+        entryName: name,
+        data: next,
+        action,
+        status: next.__eponyme.status,
+        userId: actorId ?? null
+      }
+    });
+    return { data, status: next.__eponyme.status, publishedAt };
+  }
+  async history(name, limit = 50) {
+    if (!this.getSchema(name)) return void 0;
+    const versions = await this.client.eponymeVersion.findMany({
+      where: { entryName: name },
+      orderBy: { createdAt: "desc" },
+      take: Math.min(Math.max(limit, 1), 100),
+      include: { user: true }
+    });
+    return versions.map((version) => ({
+      id: version.id,
+      action: version.action === "draft" || version.action === "publish" ? version.action : "restore",
+      status: version.status === "draft" ? "draft" : "published",
+      createdAt: new Date(version.createdAt).toISOString(),
+      user: version.user ? { id: version.user.id, username: version.user.username } : null
+    }));
+  }
+  async restore(name, versionId, actorId) {
+    const schema = this.getSchema(name);
+    if (!schema) return void 0;
+    const version = await this.client.eponymeVersion.findUnique({ where: { id: versionId } });
+    if (!version || version.entryName !== name) return void 0;
+    const current = await this.loadRow(name);
+    if (!current) return void 0;
+    const state = this.normalizeState(schema, version.data);
+    if (!await this.writeState(name, state, current.updatedAt)) return { conflict: true };
+    await this.client.eponymeVersion.create({
+      data: {
+        entryName: name,
+        data: state,
+        action: "restore",
+        status: state.__eponyme.status,
+        userId: actorId ?? null
+      }
+    });
+    return {
+      data: state.__eponyme.draft,
+      status: state.__eponyme.status,
+      publishedAt: state.__eponyme.publishedAt
+    };
+  }
+}
+function getStoredState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const envelope = value;
+  const state = envelope.__eponyme ?? envelope.__keditor;
+  const valid = Boolean(
+    state && state.version === 1 && state.draft && typeof state.draft === "object" && !Array.isArray(state.draft) && state.published && typeof state.published === "object" && !Array.isArray(state.published) && (state.status === "draft" || state.status === "published") && (state.publishedAt === null || typeof state.publishedAt === "string")
+  );
+  return valid ? state : void 0;
+}
+function mergeErrors(...groups) {
+  const errors = {};
+  for (const group of groups) {
+    for (const [field, messages] of Object.entries(group))
+      errors[field] = [.../* @__PURE__ */ new Set([...errors[field] ?? [], ...messages])];
+  }
+  return errors;
+}
+export function isPrismaError(error, code) {
+  return Boolean(error && typeof error === "object" && error.code === code);
+}
+function sameData(left, right) {
+  return isDeepStrictEqual(left, right);
+}
+function withLastmod(loc, publishedAt) {
+  return publishedAt ? { loc, lastmod: publishedAt } : { loc };
+}

package/dist/runtime/server/utils/auth.d.ts

@@ -0,0 +1,11 @@
+import type { H3Event } from 'h3';
+import type { EponymeAuthUser, EponymeRole } from '../../types/index.js';
+export declare const EPONYME_SESSION_COOKIE = "eponyme_session";
+export declare function getEponymeEventUser(event: H3Event): Promise<EponymeAuthUser | undefined>;
+export declare function requireEponymeUser(event: H3Event, options?: {
+    roles?: EponymeRole[];
+    allowPasswordChangeRequired?: boolean;
+}): Promise<EponymeAuthUser>;
+export declare function setEponymeSessionCookie(event: H3Event, token: string, expiresAt: Date): void;
+export declare function clearEponymeSessionCookie(event: H3Event): void;
+export declare function assertEponymeMutationOrigin(event: H3Event): void;

package/dist/runtime/server/utils/auth.js

@@ -0,0 +1,41 @@
+import {
+  createError,
+  deleteCookie,
+  getCookie,
+  getHeader,
+  getRequestURL,
+  setCookie
+} from "h3";
+import { useEponymeAuthService } from "../services/eponyme-auth-service.js";
+export const EPONYME_SESSION_COOKIE = "eponyme_session";
+export async function getEponymeEventUser(event) {
+  return (await useEponymeAuthService().getSession(getCookie(event, EPONYME_SESSION_COOKIE)))?.user;
+}
+export async function requireEponymeUser(event, options = {}) {
+  const user = await getEponymeEventUser(event);
+  if (!user) throw createError({ statusCode: 401, statusMessage: "Authentication required." });
+  if (user.mustChangePassword && !options.allowPasswordChangeRequired)
+    throw createError({ statusCode: 403, statusMessage: "Password change required.", data: { code: "PASSWORD_CHANGE_REQUIRED" } });
+  if (options.roles && !options.roles.includes(user.role))
+    throw createError({ statusCode: 403, statusMessage: "Insufficient permissions." });
+  return user;
+}
+export function setEponymeSessionCookie(event, token, expiresAt) {
+  setCookie(event, EPONYME_SESSION_COOKIE, token, {
+    httpOnly: true,
+    sameSite: "lax",
+    secure: process.env.NODE_ENV === "production",
+    path: "/",
+    expires: expiresAt
+  });
+}
+export function clearEponymeSessionCookie(event) {
+  deleteCookie(event, EPONYME_SESSION_COOKIE, { path: "/" });
+}
+export function assertEponymeMutationOrigin(event) {
+  const origin = getHeader(event, "origin");
+  if (!origin) return;
+  const requestUrl = getRequestURL(event);
+  if (origin !== requestUrl.origin)
+    throw createError({ statusCode: 403, statusMessage: "Invalid request origin." });
+}

package/dist/runtime/server/utils/eponyme-form.d.ts

@@ -0,0 +1,14 @@
+import type { ValidationErrors } from '../../utils/validate-eponyme-data.js';
+export type EponymeFormValidationResult = {
+    data: Record<string, unknown>;
+    errors?: never;
+} | {
+    data?: never;
+    errors: ValidationErrors;
+};
+/**
+ * Auto-imported so a `custom` form keeps a server-side security boundary: client
+ * validation only ever improves feedback. Throws on an unknown form name, since
+ * that is a configuration mistake rather than bad user input.
+ */
+export declare function validateEponymeForm(name: string, body: unknown): EponymeFormValidationResult;

package/dist/runtime/server/utils/eponyme-form.js

@@ -0,0 +1,6 @@
+import { useEponymeFormService } from "../services/eponyme-form-service.js";
+export function validateEponymeForm(name, body) {
+  const result = useEponymeFormService().validate(name, body);
+  if (!result) throw new Error(`[Eponyme] Unknown form "${name}". Declare it with form() in eponyme.config.ts.`);
+  return result;
+}

package/dist/runtime/server/utils/eponyme-sitemap.d.ts

@@ -0,0 +1,7 @@
+import type { EponymeSitemapEntry } from '../services/eponyme-store.js';
+export type { EponymeSitemapEntry };
+/**
+ * Auto-imported so a Nuxt sitemap integration can build its own route without an
+ * internal HTTP request.
+ */
+export declare function getEponymeSitemapEntries(): Promise<EponymeSitemapEntry[]>;

package/dist/runtime/server/utils/eponyme-sitemap.js

@@ -0,0 +1,7 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import { useEponymeService } from "../services/eponyme-service.js";
+export async function getEponymeSitemapEntries() {
+  const runtimeConfig = useRuntimeConfig();
+  const previewPaths = runtimeConfig.public.eponyme?.previewPaths ?? {};
+  return useEponymeService().getSitemapEntries(previewPaths);
+}

package/dist/runtime/server/utils/form-route.d.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+/**
+ * Form names may contain slashes (a form nested in a folder), so the route is a
+ * wildcard and the path is re-parsed here. The form name is everything before the
+ * trailing `/submissions` segment, which is what removes the ambiguity between a
+ * nested form and the route suffix.
+ */
+export interface EponymeFormRoute {
+    name: string;
+    /** True when the path carried the `/submissions` suffix. */
+    submissions: boolean;
+    submissionId?: string;
+}
+export declare function readEponymeFormRoute(event: H3Event): EponymeFormRoute | undefined;

package/dist/runtime/server/utils/form-route.js

@@ -0,0 +1,14 @@
+import { getRequestURL } from "h3";
+export function readEponymeFormRoute(event) {
+  const path = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-forms\/?/, ""));
+  if (!path) return void 0;
+  const segments = path.split("/").filter(Boolean);
+  const suffix = segments.lastIndexOf("submissions");
+  if (suffix === -1) return { name: segments.join("/"), submissions: false };
+  if (suffix === 0 || segments.length > suffix + 2) return void 0;
+  return {
+    name: segments.slice(0, suffix).join("/"),
+    submissions: true,
+    submissionId: segments[suffix + 1]
+  };
+}

package/dist/runtime/server/utils/password.d.ts

@@ -0,0 +1,4 @@
+export declare function validatePassword(password: unknown): string | undefined;
+export declare function hashPassword(password: string): Promise<string>;
+export declare function verifyPassword(password: string, encoded: string): Promise<boolean>;
+export declare function generateTemporaryPassword(): string;

package/dist/runtime/server/utils/password.js

@@ -0,0 +1,30 @@
+import { randomBytes, scrypt as scryptCallback, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+const scrypt = promisify(scryptCallback);
+const KEY_LENGTH = 64;
+const PASSWORD_MIN_LENGTH = 12;
+const PASSWORD_MAX_LENGTH = 128;
+export function validatePassword(password) {
+  if (typeof password !== "string") return "Password is required.";
+  if (password.length < PASSWORD_MIN_LENGTH) return `Password must contain at least ${PASSWORD_MIN_LENGTH} characters.`;
+  if (password.length > PASSWORD_MAX_LENGTH) return `Password must contain at most ${PASSWORD_MAX_LENGTH} characters.`;
+}
+export async function hashPassword(password) {
+  const salt = randomBytes(16).toString("base64url");
+  const derived = await scrypt(password, salt, KEY_LENGTH);
+  return `scrypt$${salt}$${derived.toString("base64url")}`;
+}
+export async function verifyPassword(password, encoded) {
+  const [algorithm, salt, expectedValue] = encoded.split("$");
+  if (algorithm !== "scrypt" || !salt || !expectedValue) return false;
+  try {
+    const expected = Buffer.from(expectedValue, "base64url");
+    const actual = await scrypt(password, salt, expected.length);
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+  } catch {
+    return false;
+  }
+}
+export function generateTemporaryPassword() {
+  return randomBytes(18).toString("base64url");
+}

package/dist/runtime/types/auth.d.ts

@@ -0,0 +1,20 @@
+export declare const EPONYME_ROLES: readonly ["viewer", "editor", "owner"];
+export type EponymeRole = typeof EPONYME_ROLES[number];
+export interface EponymeAuthUser {
+    id: string;
+    username: string;
+    role: EponymeRole;
+    active: boolean;
+    mustChangePassword: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface EponymeAuthSession {
+    user: EponymeAuthUser | null;
+}
+export interface EponymeManagedUserResult {
+    user: EponymeAuthUser;
+    temporaryPassword: string;
+}
+export declare function isEponymeRole(value: unknown): value is EponymeRole;
+export declare function canEditEponyme(role: EponymeRole | undefined): boolean;

package/dist/runtime/types/auth.js

@@ -0,0 +1,7 @@
+export const EPONYME_ROLES = ["viewer", "editor", "owner"];
+export function isEponymeRole(value) {
+  return typeof value === "string" && EPONYME_ROLES.includes(value);
+}
+export function canEditEponyme(role) {
+  return role === "editor" || role === "owner";
+}

package/dist/runtime/types/eponyme-config.d.ts

@@ -0,0 +1,11 @@
+declare module '#eponyme/config' {
+  import type { EponymeConfig } from './eponyme'
+
+  const config: EponymeConfig
+  export default config
+}
+
+declare module '#eponyme/prisma' {
+  const prisma: unknown
+  export default prisma
+}

package/dist/runtime/types/eponyme-navigation.d.ts

@@ -0,0 +1,6 @@
+export interface EponymeNavigationNode {
+    kind: 'folder' | 'collection' | 'form' | 'entry';
+    path: string;
+    label: string;
+    children: EponymeNavigationNode[];
+}

package/dist/runtime/types/eponyme.d.ts

@@ -0,0 +1,87 @@
+import type { ArrayFieldDefinition, ArrayItemValue, BooleanFieldDefinition, CheckboxGroupFieldDefinition, EmailFieldDefinition, FieldDefinition, NumberFieldDefinition, RadioFieldDefinition, SectionFieldDefinition, SectionValue, SelectFieldDefinition, SlugFieldDefinition, StringFieldDefinition, TabFieldDefinition, TabsValue, TextareaFieldDefinition, UrlFieldDefinition, UrlValue } from './field.js';
+export type EponymeSchema = Record<string, FieldDefinition>;
+export interface EponymeCollectionDefinitionBase {
+    __eponymeCollection: true;
+    label?: string;
+    description?: string;
+    fields: EponymeSchema;
+    slugField: string;
+    titleField: string;
+}
+export interface EponymeCollectionOptions<T extends EponymeSchema = EponymeSchema> {
+    label?: string;
+    description?: string;
+    fields: T;
+    slugField: keyof T & string;
+    titleField: keyof T & string;
+}
+export interface EponymeCollectionDefinition<T extends EponymeSchema = EponymeSchema> extends EponymeCollectionOptions<T> {
+    __eponymeCollection: true;
+    fields: T;
+    slugField: keyof T & string;
+    titleField: keyof T & string;
+}
+/**
+ * A public form only accepts field types a visitor can meaningfully fill in.
+ * `slug`, `richText`, `image`, `date`, `color`, `array`, `section` and `tabs` are
+ * authoring concerns and are rejected by `form()`.
+ */
+export type EponymeFormFieldDefinition = StringFieldDefinition | TextareaFieldDefinition | EmailFieldDefinition | UrlFieldDefinition | NumberFieldDefinition | BooleanFieldDefinition | SelectFieldDefinition | RadioFieldDefinition | CheckboxGroupFieldDefinition;
+export type EponymeFormSchema = Record<string, EponymeFormFieldDefinition>;
+/** `custom` leaves delivery to the host application; `managed` stores the submission. */
+export type EponymeFormMode = 'custom' | 'managed';
+export interface EponymeFormSubmissionOptions {
+    mode?: EponymeFormMode;
+}
+export interface EponymeFormOptions<T extends EponymeFormSchema = EponymeFormSchema> {
+    label?: string;
+    description?: string;
+    fields: T;
+    submission?: EponymeFormSubmissionOptions;
+    /** Name of the trap field bots fill in. `false` disables the check. */
+    honeypot?: string | false;
+    /** In bytes. */
+    maxBodyBytes?: number;
+}
+export interface EponymeFormDefinitionBase {
+    __eponymeForm: true;
+    label?: string;
+    description?: string;
+    fields: EponymeFormSchema;
+    submission: Required<EponymeFormSubmissionOptions>;
+    honeypot: string | false;
+    maxBodyBytes: number;
+}
+export interface EponymeFormDefinition<T extends EponymeFormSchema = EponymeFormSchema> extends EponymeFormDefinitionBase {
+    fields: T;
+}
+export interface EponymeConfig {
+    [name: string]: EponymeSchema | EponymeCollectionDefinitionBase | EponymeFormDefinitionBase | EponymeConfig;
+}
+export type CollectionSlugField<T extends EponymeSchema> = {
+    [K in keyof T & string]: T[K] extends SlugFieldDefinition ? K : never;
+}[keyof T & string];
+export type FieldValue<T extends FieldDefinition> = T extends {
+    type: 'number';
+} ? number : T extends {
+    type: 'boolean';
+} ? boolean : T extends UrlFieldDefinition ? UrlValue : T extends ArrayFieldDefinition<infer Item> ? Array<ArrayItemValue<Item>> : T extends CheckboxGroupFieldDefinition<infer Value> ? Value[] : T extends SectionFieldDefinition<infer Section> ? SectionValue<Section> : T extends TabFieldDefinition<infer Tabs> ? TabsValue<Tabs> : string;
+export type EponymeData<T extends EponymeSchema> = {
+    [K in keyof T]: T[K] extends FieldDefinition ? FieldValue<T[K]> : never;
+};
+export type EponymeDataByName<T extends EponymeConfig, Name extends EponymeName<T>> = EponymeDataAtPath<T, Name>;
+export type EponymeCollectionName<T extends EponymeConfig> = {
+    [K in keyof T & string]: T[K] extends EponymeCollectionDefinitionBase ? K : T[K] extends EponymeFormDefinitionBase ? never : T[K] extends EponymeSchema ? never : T[K] extends EponymeConfig ? `${K}/${EponymeCollectionName<T[K]>}` : never;
+}[keyof T & string];
+export type EponymeCollectionDataByName<T extends EponymeConfig, Name extends EponymeCollectionName<T>> = EponymeCollectionAtPath<T, Name> extends EponymeCollectionDefinition<infer Schema> ? EponymeData<Schema> : never;
+export type EponymeName<T extends EponymeConfig> = {
+    [K in keyof T & string]: T[K] extends EponymeCollectionDefinitionBase ? never : T[K] extends EponymeFormDefinitionBase ? never : T[K] extends EponymeSchema ? K : T[K] extends EponymeConfig ? `${K}/${EponymeName<T[K]>}` : never;
+}[keyof T & string];
+export type EponymeFormName<T extends EponymeConfig> = {
+    [K in keyof T & string]: T[K] extends EponymeFormDefinitionBase ? K : T[K] extends EponymeCollectionDefinitionBase ? never : T[K] extends EponymeSchema ? never : T[K] extends EponymeConfig ? `${K}/${EponymeFormName<T[K]>}` : never;
+}[keyof T & string];
+export type EponymeFormDataByName<T extends EponymeConfig, Name extends EponymeFormName<T>> = EponymeFormAtPath<T, Name> extends EponymeFormDefinition<infer Schema> ? EponymeData<Schema> : never;
+type EponymeDataAtPath<T extends EponymeConfig, Name extends string> = Name extends `${infer Folder}/${infer Rest}` ? Folder extends keyof T ? T[Folder] extends EponymeConfig ? EponymeDataAtPath<T[Folder], Rest> : never : never : Name extends keyof T ? T[Name] extends EponymeSchema ? EponymeData<T[Name]> : never : never;
+type EponymeCollectionAtPath<T extends EponymeConfig, Name extends string> = Name extends `${infer Folder}/${infer Rest}` ? Folder extends keyof T ? T[Folder] extends EponymeConfig ? EponymeCollectionAtPath<T[Folder], Rest> : never : never : Name extends keyof T ? T[Name] : never;
+type EponymeFormAtPath<T extends EponymeConfig, Name extends string> = Name extends `${infer Folder}/${infer Rest}` ? Folder extends keyof T ? T[Folder] extends EponymeConfig ? EponymeFormAtPath<T[Folder], Rest> : never : never : Name extends keyof T ? T[Name] : never;
+export {};