import { r as ContentFieldFilters } from "./content-list-query-BhejKVqb.mjs";
import { _ as UpdateCollectionInput, a as CollectionWithFields, c as CreateFieldInput, d as Field, p as FieldValidation, s as CreateCollectionInput, t as Collection, v as UpdateFieldInput } from "./types-BjBDp25t.mjs";
import { f as UpdateContentInput, i as ContentItem, l as FindManyOptions, o as ContentSeoInput, r as ContentDateField, s as CreateContentInput, t as BylineSummary, u as FindManyResult } from "./types-C4ZXxSAE.mjs";
import { d as ContentListResponse, f as ContentResponse, h as ManifestResponse, u as ApiResult } from "./options-B5K8QEV1.mjs";
import { t as Database } from "./types-BCOU_CXE.mjs";
import { At as PortableTextBlockConfig, Dt as PluginMcpManifestConfig, Et as PluginManifest, Ht as StorageCollection, I as CronAccess, It as ResolvedPlugin, J as EmailMessage, L as CronEvent, Mt as PublicPageContext, Nt as QueryOptions, Pt as RequestMeta, Q as HttpAccess, Qt as WhereClause, St as PluginCapability, Vt as SettingField, Y as FieldWidgetConfig, Zt as UserInfo, dt as PageFragmentEvent, f as CommentAfterModerateEvent, j as ContentItem$1, kt as PluginStorageConfig, m as CommentBeforeCreateEvent, mt as PageMetadataEvent, pt as PageMetadataContribution, st as MediaItem$1, u as CommentAfterCreateEvent, ut as PageFragmentContribution, vt as PaginatedResult, wt as PluginDefinition, z as CronTaskInfo } from "./types-XJPFqvc1.mjs";
import { _ as MediaValue, f as MediaProvider, m as MediaProviderDescriptor, p as MediaProviderCapabilities } from "./placeholder-CZAsZ2bK.mjs";
import { T as ContentBylineInput } from "./index-BFUET8yL.mjs";
import { r as DatabaseDescriptor } from "./adapters-D8N6Sa1v.mjs";
import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-DmfO8RJk.mjs";
import { r as ObjectCacheDescriptor } from "./types-D5VVLr7J.mjs";
import { d as Storage } from "./types-D_DWe7k9.mjs";
import { i as SiteSettings, r as SiteSettingKey } from "./types-Blb-MRC3.mjs";
import { EmDashManifest } from "./astro/types.mjs";
import { Dialect, Kysely, sql } from "kysely";
import { z } from "astro/zod";
import { z as z$1 } from "zod";
import { ManifestHookEntry, ManifestRouteEntry } from "@premium-cms/plugin-types";
import "@premium-cms/registry-client/env";
import { LiveLoader } from "astro/loaders";

//#region src/database/errors.d.ts
/**
 * Database error types. Kept in their own module (no driver imports) so the
 * public package barrel can re-export them without dragging native database
 * drivers into the module graph of consumers that picked a different dialect.
 */
declare class EmDashDatabaseError extends Error {
  cause?: unknown | undefined;
  constructor(message: string, cause?: unknown | undefined);
}
//#endregion
//#region src/database/connection.d.ts
interface DatabaseConfig {
  url: string;
  authToken?: string;
}
//#endregion
//#region src/database/repositories/content.d.ts
/**
 * Repository for content CRUD operations
 *
 * Content is stored in per-collection tables (ec_posts, ec_pages, etc.)
 * Each field becomes a real column in the table.
 */
declare class ContentRepository {
  private db;
  constructor(db: Kysely<Database>);
  /**
   * Create a new content item
   */
  create(input: CreateContentInput): Promise<ContentItem>;
  /**
   * Generate a unique slug for a content item within a collection.
   *
   * Checks the collection table for existing slugs that match `baseSlug`
   * (optionally scoped to a locale) and appends a numeric suffix (`-1`,
   * `-2`, etc.) on collision to guarantee uniqueness.
   *
   * Returns null when slug normalization cannot produce a value.
   */
  generateUniqueSlug(type: string, text: string, locale?: string): Promise<string | null>;
  /**
   * Duplicate a content item
   * Creates a new draft copy with "(Copy)" appended to the title.
   * A slug is auto-generated from the new title by the handler layer.
   */
  duplicate(type: string, id: string, authorId?: string): Promise<ContentItem>;
  /**
   * Find content by ID
   */
  findById(type: string, id: string): Promise<ContentItem | null>;
  /**
   * Find content by id, including trashed (soft-deleted) items.
   * Used by restore endpoint for ownership checks.
   */
  findByIdIncludingTrashed(type: string, id: string): Promise<ContentItem | null>;
  /**
   * Find content by ID or slug. Tries ID first if it looks like a ULID,
   * otherwise tries slug. Falls back to the other if the first lookup misses.
   */
  findByIdOrSlug(type: string, identifier: string, locale?: string): Promise<ContentItem | null>;
  /**
   * Find content by ID or slug, including trashed (soft-deleted) items.
   * Used by restore/permanent-delete endpoints.
   */
  findByIdOrSlugIncludingTrashed(type: string, identifier: string, locale?: string): Promise<ContentItem | null>;
  private _findByIdOrSlug;
  /**
   * Find content by slug
   */
  findBySlug(type: string, slug: string, locale?: string): Promise<ContentItem | null>;
  /**
   * Find content by slug, including trashed (soft-deleted) items.
   * Used by restore/permanent-delete endpoints.
   */
  findBySlugIncludingTrashed(type: string, slug: string, locale?: string): Promise<ContentItem | null>;
  /**
   * Find many content items with filtering and pagination
   */
  findMany(type: string, options?: FindManyOptions): Promise<FindManyResult<ContentItem>>;
  /**
   * Update content
   */
  update(type: string, id: string, input: UpdateContentInput): Promise<ContentItem>;
  /**
   * Update plugin-authored fields without letting content columns diverge
   * from the revision pointers that publication promotes.
   */
  updateDraftAware(type: string, id: string, input: UpdateContentInput): Promise<ContentItem>;
  private deleteUnstagedRevision;
  private replaceDraftRevisionForUpdate;
  /**
   * Delete content (soft delete - moves to trash)
   */
  delete(type: string, id: string): Promise<boolean>;
  /**
   * Restore content from trash
   */
  restore(type: string, id: string): Promise<ContentItem | null>;
  /**
   * Permanently delete content (cannot be undone)
   */
  /**
   * Permanently delete a soft-deleted content row.
   *
   * Returns `true` only when a soft-deleted (trashed) row was removed.
   * Returns `false` when no row exists OR when the row exists but is live —
   * the caller is responsible for distinguishing these cases (typically via
   * a follow-up `findByIdOrSlugIncludingTrashed` to surface NOT_FOUND vs
   * NOT_TRASHED). The `AND deleted_at IS NOT NULL` clause is the safety net
   * that prevents permanent delete from bypassing the trash workflow.
   */
  permanentDelete(type: string, id: string): Promise<boolean>;
  /**
   * Find trashed content items
   */
  findTrashed(type: string, options?: Omit<FindManyOptions, "where">): Promise<FindManyResult<ContentItem & {
    deletedAt: string;
  }>>;
  /**
   * Count trashed content items
   */
  countTrashed(type: string): Promise<number>;
  /**
   * Apply the optional `q` filter.
   *
   * When the handler sets `useFts` (collection has a healthy FTS5 index
   * covering the display columns; SQLite only), the filter is served from
   * the index: a token-prefix MATCH against `_emdash_fts_<slug>` OR'd with
   * an index-served `slug GLOB 'term*'` prefix (the slug is not in the FTS
   * index). Both sides are index-backed, so SQLite's OR optimization avoids
   * the full-table scan the LIKE fallback needs (#1517). The trade-off is
   * search semantics: token-prefix matching instead of arbitrary substring.
   *
   * Fallback (Postgres, search disabled, or no usable terms): case-
   * insensitive substring LIKE across the handler-resolved `searchColumns`
   * (OR'd). User input is treated literally (LIKE wildcards escaped) and
   * `lower()` is applied on both sides for SQLite/Postgres parity.
   */
  private applySearchFilter;
  /**
   * Apply the optional inclusive date-range filter. The field is mapped
   * through `DATE_FILTER_COLUMNS` (a closed whitelist), and bounds compare
   * lexicographically against the stored ISO 8601 timestamps. A `publishedAt`
   * range naturally excludes never-published rows (their column is NULL).
   */
  private applyDateFilter;
  /**
   * Apply the optional byline filter as a correlated (NOT) EXISTS against
   * `_emdash_content_bylines`.
   *
   * Correlating from the content table preserves the outer sort index so
   * `LIMIT` can short-circuit. `mode: "none"` tests the junction rather than
   * `primary_byline_id` because the two are written in the same call but
   * are not atomically consistent, so the junction is authoritative.
   *
   * Whether a credit *renders* is locale-scoped; whether one *exists* is
   * not. Both are needed: the first decides what the filter matches, the
   * second decides whether the author fallback applies at all.
   */
  private applyBylineFilter;
  /**
   * Count content items
   */
  count(type: string, where?: FindManyOptions["where"]): Promise<number>;
  private countWithResolvedFilters;
  /**
   * Distinct, non-null `author_id` values across the collection's live
   * (non-trashed) content. Used to populate the admin author filter with
   * only the users who have actually authored entries, rather than the
   * full user directory (which requires admin privileges to read).
   */
  findDistinctAuthorIds(type: string): Promise<string[]>;
  getStats(type: string, now?: Date): Promise<{
    total: number;
    published: number;
    draft: number;
    scheduled: number;
    overdueScheduled: number;
  }>;
  /**
   * Schedule content for future publishing
   *
   * Sets status to 'scheduled' and stores the scheduled publish time.
   * The content will be auto-published when the scheduled time is reached.
   */
  schedule(type: string, id: string, scheduledAt: string): Promise<ContentItem>;
  /**
   * Unschedule content
   *
   * Clears the scheduled time. Published posts stay published;
   * draft/scheduled posts revert to 'draft'.
   */
  unschedule(type: string, id: string): Promise<ContentItem>;
  /**
   * Find content that is ready to be published
   *
   * Returns all content where scheduled_at <= now, regardless of status.
   * This covers both draft-scheduled posts (status='scheduled') and
   * published posts with scheduled draft changes (status='published').
   *
   * `limit` (optional) caps how many due rows are returned, oldest-due first.
   * The scheduled-publishing sweep passes a limit so a large backlog can't
   * fan out unbounded publish/webhook work in a single tick (and blow a Worker
   * invocation's CPU/subrequest budget); the remainder drains on later ticks.
   */
  findReadyToPublish(type: string, limit?: number): Promise<ContentItem[]>;
  /**
   * Find all translations in a translation group
   */
  findTranslations(type: string, translationGroup: string): Promise<ContentItem[]>;
  /**
   * Batch variant of {@link findTranslations}: every (non-deleted) locale
   * variant for any of `translationGroups`, in one `WHERE translation_group IN
   * (...)` query chunked at `SQL_BATCH_SIZE` for D1's bind-parameter limit.
   * Lets callers resolve many edge groups without an N+1 per group. The caller
   * groups the flat result by `translationGroup` itself.
   *
   * `translation_group` leads the sort so the ordering follows
   * `idx_{table}_del_tg_locale` past its `deleted_at` equality; callers group by
   * `translationGroup`, so the per-group locale order they rely on is preserved.
   *
   * `publishedOnly` restricts the result to `status = 'published'` — reference
   * reads pass this for callers without `content:read_drafts` so draft/scheduled
   * entries never leak through an edge traversal.
   *
   * A reference edge stores only a collection slug (no SQL FK), so the table may
   * have been dropped since the edge was written. That is a tolerated dangling
   * state, not an error: a missing table resolves to no rows, mirroring how the
   * content read handlers treat `isMissingTableError`.
   */
  findTranslationsForGroups(type: string, translationGroups: string[], options?: {
    publishedOnly?: boolean;
  }): Promise<ContentItem[]>;
  /**
   * Batch variant of {@link findByIdOrSlug}: resolve many identifiers (each an
   * id OR a slug) within `type` in a constant number of queries — one `WHERE id
   * IN (...)` and one `WHERE slug IN (...)`, each chunked at `SQL_BATCH_SIZE`.
   * Returns a map from the input identifier to its resolved item; identifiers
   * that match nothing are absent. Used on write paths that accept a list of
   * references, so a single request doesn't fan out to an N+1 of point lookups.
   *
   * Resolution mirrors {@link findByIdOrSlug}: a ULID-shaped identifier prefers
   * the id match and falls back to slug; anything else prefers the slug match
   * and falls back to id. Slug matches collapse to the lowest-locale variant
   * (`ORDER BY locale ASC`), matching the slug-without-locale lookup.
   */
  findManyByIdOrSlug(type: string, identifiers: string[]): Promise<Map<string, ContentItem>>;
  /**
   * Publish the current draft
   *
   * Promotes draft_revision_id to live_revision_id and clears draft pointer.
   * Syncs the draft revision's data into the content table columns so the
   * content table always reflects the published version.
   * If no draft revision exists, creates one from current data and publishes it.
   * When `promoteRevision` is false, publishes the current content-table data
   * by changing lifecycle metadata only.
   *
   * `publishedAt` (optional) overrides the publication timestamp. If omitted,
   * the existing `published_at` is preserved (idempotent re-publish keeps the
   * original date) and falls back to the current time on first publish. Pass
   * an explicit value to backdate a publish (e.g. when migrating content from
   * another CMS).
   *
   * `requireDue` gates the final update on the row still being due.
   * `expectedScheduledAt` additionally fences changes made after a sweep
   * selected the row but before publication preparation began.
   */
  publish(type: string, id: string, publishedAt?: string, requireDue?: boolean, expectedScheduledAt?: string, promoteRevision?: boolean, requireSlug?: boolean): Promise<ContentItem>;
  /**
   * Unpublish content
   *
   * Removes live pointer but preserves draft. If no draft exists,
   * creates one from the live version so the content isn't lost.
   */
  unpublish(type: string, id: string): Promise<ContentItem>;
  /**
   * Set the draft revision pointer for a content item.
   *
   * Used by seed/import paths that stage a new revision's data before
   * promoting it to live via `publish()`.
   *
   * Validates that the content item exists and is not soft-deleted, that
   * the revision exists, and that the revision belongs to the same
   * collection and entry. Without these checks, a caller could leave the
   * content row pointing at a missing or unrelated revision.
   */
  setDraftRevision(type: string, id: string, revisionId: string): Promise<void>;
  replaceDraftRevision(type: string, id: string, revisionId: string, expected: Pick<ContentItem, "version" | "liveRevisionId" | "draftRevisionId">): Promise<boolean>;
  /**
   * Discard pending draft changes
   *
   * Clears draft_revision_id. The content table columns already hold the
   * published version, so no data sync is needed.
   */
  discardDraft(type: string, id: string): Promise<ContentItem>;
  /**
   * Count content items with a pending schedule.
   * Includes both draft-scheduled (status='scheduled') and published
   * posts with scheduled draft changes (status='published', scheduled_at set).
   */
  countScheduled(type: string): Promise<number>;
  /**
   * Map database row to ContentItem
   * Extracts system columns and puts content fields in data
   * Excludes null values from data to match input semantics
   */
  private mapRow;
  private normalizeFilterScalar;
  private normalizeFieldFilter;
  private collectionExists;
  private resolveFieldFilters;
  private applyFieldFilters;
  /**
   * Map order field names to database columns.
   * Only allows known fields to prevent column enumeration via crafted orderBy values.
   */
  private mapOrderField;
  private resolveOrderField;
}
//#endregion
//#region src/database/repositories/media.d.ts
type MediaStatus = "pending" | "ready" | "failed";
interface MediaItem {
  id: string;
  filename: string;
  mimeType: string;
  size: number | null;
  width: number | null;
  height: number | null;
  alt: string | null;
  caption: string | null;
  storageKey: string;
  status: MediaStatus;
  contentHash: string | null;
  blurhash: string | null;
  dominantColor: string | null;
  createdAt: string;
  authorId: string | null;
}
interface CreateMediaInput {
  filename: string;
  mimeType: string;
  size?: number;
  width?: number;
  height?: number;
  alt?: string;
  caption?: string;
  storageKey: string;
  contentHash?: string;
  blurhash?: string;
  dominantColor?: string;
  status?: MediaStatus;
  authorId?: string;
}
interface FindManyMediaOptions {
  limit?: number;
  cursor?: string;
  /** Filter by MIME type. Pass a string for a single prefix/exact, or an array to match any. Strings ending with "/" are treated as LIKE prefix matches; others are exact equality. */
  mimeType?: string | readonly string[];
  status?: MediaStatus | "all";
  /** Case-insensitive substring matched against the filename (covers filename and extension). */
  q?: string;
}
/**
 * Media repository for database operations
 */
declare class MediaRepository {
  private db;
  constructor(db: Kysely<Database>);
  /**
   * Create a new media item
   */
  create(input: CreateMediaInput): Promise<MediaItem>;
  /**
   * Create a pending media item (for signed URL upload flow)
   */
  createPending(input: {
    filename: string;
    mimeType: string;
    size?: number;
    storageKey: string;
    contentHash?: string;
    authorId?: string;
  }): Promise<MediaItem>;
  createUploadAttempt(mediaId: string, storageKey: string): Promise<void>;
  hasUploadAttempt(storageKey: string): Promise<boolean>;
  claimUploadAttemptForCleanup(storageKey: string): Promise<boolean>;
  deleteUploadAttempt(storageKey: string): Promise<void>;
  deleteCompletedUploadAttempts(): Promise<number>;
  findUploadAttemptsForCleanup(maxAgeMs?: number, limit?: number): Promise<string[]>;
  publishPendingStorageKey(id: string, expectedStorageKey: string, storageKey: string, contentHash?: string): Promise<boolean>;
  /**
   * Confirm upload (mark as ready)
   */
  confirmUpload(id: string, metadata?: {
    width?: number;
    height?: number;
    size?: number;
    blurhash?: string;
    dominantColor?: string;
    contentHash?: string | null;
  }, expectedStorageKey?: string): Promise<MediaItem | null>;
  /**
   * Mark upload as failed
   */
  markFailed(id: string, expectedStorageKey?: string): Promise<MediaItem | null>;
  /**
   * Find media by ID
   */
  findById(id: string): Promise<MediaItem | null>;
  /**
   * Find media by filename
   * Useful for idempotent imports
   */
  findByFilename(filename: string): Promise<MediaItem | null>;
  /**
   * Find media by content hash
   * Used for deduplication - same content = same hash
   */
  findByContentHash(contentHash: string): Promise<MediaItem | null>;
  /**
   * Find many media items with cursor pagination
   *
   * Uses keyset pagination (cursor-based) for consistent results.
   * The cursor encodes the created_at and id of the last item.
   */
  findMany(options?: FindManyMediaOptions): Promise<FindManyResult<MediaItem>>;
  /**
   * Update media metadata
   */
  update(id: string, input: Partial<Pick<CreateMediaInput, "alt" | "caption" | "width" | "height">>): Promise<MediaItem | null>;
  /**
   * Delete media item
   */
  deleteWithStorageKey(id: string): Promise<string | null>;
  delete(id: string): Promise<boolean>;
  /**
   * Count media items
   */
  count(mimeType?: string | readonly string[]): Promise<number>;
  /**
   * Delete pending uploads older than the given age.
   * Pending uploads that were never confirmed indicate abandoned upload flows.
   *
   * Returns the storage keys of deleted rows so callers can remove the
   * corresponding files from object storage.
   */
  cleanupPendingUploads(maxAgeMs?: number): Promise<string[]>;
  /**
   * Convert database row to MediaItem
   */
  private rowToItem;
}
//#endregion
//#region src/database/repositories/user.d.ts
/**
 * Valid role levels matching the database schema.
 * 10=subscriber, 20=contributor, 30=author, 40=editor, 50=admin
 */
type UserRole = 10 | 20 | 30 | 40 | 50;
/** String role names for convenience APIs */
type UserRoleName = "subscriber" | "contributor" | "author" | "editor" | "admin";
interface User {
  id: string;
  email: string;
  name: string | null;
  role: UserRole;
  avatarUrl: string | null;
  emailVerified: boolean;
  data: Record<string, unknown> | null;
  createdAt: string;
}
interface CreateUserInput {
  email: string;
  name?: string;
  role?: UserRole | UserRoleName;
  avatarUrl?: string;
  data?: Record<string, unknown>;
}
interface UpdateUserInput {
  name?: string;
  role?: UserRole | UserRoleName;
  avatarUrl?: string | null;
  data?: Record<string, unknown>;
}
/**
 * User repository for CRUD operations
 */
declare class UserRepository {
  private db;
  constructor(db: Kysely<Database>);
  /**
   * Create a new user
   */
  create(input: CreateUserInput): Promise<User>;
  /**
   * Find user by ID
   */
  findById(id: string): Promise<User | null>;
  /**
   * Batch-resolve users by ID. Returns only the users that exist; missing
   * IDs are silently dropped. Chunked at `SQL_BATCH_SIZE` to stay within
   * D1's bind-parameter limit.
   */
  findByIds(ids: string[]): Promise<User[]>;
  /**
   * Find user by email (case-insensitive)
   */
  findByEmail(email: string): Promise<User | null>;
  /**
   * List all users with cursor-based pagination
   */
  findMany(options?: {
    role?: UserRole | UserRoleName;
    limit?: number;
    cursor?: string;
  }): Promise<FindManyResult<User>>;
  /**
   * Update a user
   */
  update(id: string, input: UpdateUserInput): Promise<User | null>;
  /**
   * Delete a user
   */
  delete(id: string): Promise<boolean>;
  /**
   * Count users
   */
  count(role?: UserRole | UserRoleName): Promise<number>;
  /**
   * Check if email exists
   */
  emailExists(email: string): Promise<boolean>;
  /**
   * Convert database row to User object
   */
  private rowToUser;
  /** Map of role name strings to numeric levels */
  private static readonly ROLE_NAME_TO_LEVEL;
  /** Valid numeric role levels */
  private static readonly VALID_LEVELS;
  /**
   * Resolve a role name or number to a valid numeric UserRole.
   * Accepts both string names ("admin") and numeric levels (50).
   */
  static resolveRole(role: UserRole | UserRoleName): UserRole;
  /**
   * Convert a raw DB integer to a typed UserRole.
   * Falls back to subscriber (10) for unknown values.
   */
  private static toRole;
}
//#endregion
//#region src/database/repositories/revision.d.ts
interface Revision {
  id: string;
  collection: string;
  entryId: string;
  data: Record<string, unknown>;
  authorId: string | null;
  createdAt: string;
}
//#endregion
//#region src/database/repositories/comment.d.ts
/** Public-facing comment shape — no private fields */
interface PublicComment {
  id: string;
  parentId: string | null;
  authorName: string;
  isRegisteredUser: boolean;
  body: string;
  createdAt: string;
  replies?: PublicComment[];
  /** Aggregate reaction counts (`{ like: 12 }`), attached when requested. */
  reactions?: Record<string, number>;
}
//#endregion
//#region src/database/repositories/plugin-storage.d.ts
/**
 * Plugin Storage Repository
 *
 * Implements the StorageCollection interface for a specific plugin and collection.
 */
declare class PluginStorageRepository<T = unknown> implements StorageCollection<T> {
  private db;
  private pluginId;
  private collection;
  private indexedFields;
  constructor(db: Kysely<Database>, pluginId: string, collection: string, indexes: Array<string | string[]>);
  /**
   * Get a document by ID
   */
  get(id: string): Promise<T | null>;
  /**
   * Store a document
   */
  put(id: string, data: T): Promise<void>;
  /**
   * Delete a document
   */
  delete(id: string): Promise<boolean>;
  /**
   * Check if a document exists
   */
  exists(id: string): Promise<boolean>;
  /**
   * Get multiple documents by ID
   */
  getMany(ids: string[]): Promise<Map<string, T>>;
  /**
   * Store multiple documents
   */
  putMany(items: Array<{
    id: string;
    data: T;
  }>): Promise<void>;
  /**
   * Delete multiple documents
   */
  deleteMany(ids: string[]): Promise<number>;
  /**
   * Query documents with filters
   */
  query(options?: QueryOptions): Promise<PaginatedResult<{
    id: string;
    data: T;
  }>>;
  /**
   * Count documents matching a filter
   */
  count(where?: WhereClause): Promise<number>;
}
//#endregion
//#region src/database/dialect-helpers.d.ts
/**
 * Declared by an adapter whose backend caps the number of terms in a compound
 * SELECT (`UNION ALL`, `INTERSECT`, `EXCEPT`). SQLite's own
 * SQLITE_LIMIT_COMPOUND_SELECT default is 500 — high enough that no query
 * EmDash builds approaches it — but Cloudflare D1 sets it to 5 and rejects
 * anything larger with "too many terms in compound SELECT".
 */
interface CompoundSelectLimitedAdapter {
  /** Maximum terms per compound SELECT. Must be a positive integer. */
  readonly compoundSelectLimit: number;
}
//#endregion
//#region src/fields/types.d.ts
/**
 * SQLite column types that map from field types
 */
type ColumnType = "TEXT" | "REAL" | "INTEGER" | "JSON";
/**
 * Base field definition
 *
 * Note: schema uses z.ZodTypeAny to accommodate optional/default wrappers
 */
interface FieldDefinition<_T = unknown> {
  type: string;
  /**
   * The SQLite column type to use when storing this field
   */
  columnType: ColumnType;
  schema: z.ZodTypeAny;
  options?: unknown;
  ui?: FieldUIHints;
  validation?: FieldValidation;
}
/**
 * UI hints for admin rendering
 */
interface FieldUIHints {
  widget?: string;
  placeholder?: string;
  helpText?: string;
  rows?: number;
  min?: number | string;
  max?: number | string;
  [key: string]: unknown;
}
/**
 * Portable Text block structure
 */
interface PortableTextBlock$1 {
  _type: string;
  _key: string;
  [key: string]: unknown;
}
/**
 * @deprecated Use MediaValue instead. ImageValue is an alias for backwards compatibility.
 */
type ImageValue = MediaValue;
/**
 * Persisted file field value.
 *
 * File values are references with cached metadata, not implicitly hydrated
 * media records. Use the media provider API when current metadata is needed.
 */
interface FileValue {
  id: string;
  /** Legacy cached URL. Provider-backed values commonly omit this. */
  url?: string;
  /** Direct URL used by external media providers. */
  src?: string;
  /** Cached original filename, when available. */
  filename?: string;
  /** Cached MIME type, when available. */
  mimeType?: string;
  /** Cached file size in bytes, when persisted with the value. */
  size?: number;
  /** Media provider ID. Defaults to `local` when omitted. */
  provider?: string;
  /** Provider-specific data needed to resolve or render the file. */
  meta?: Record<string, unknown>;
}
//#endregion
//#region src/fields/image.d.ts
interface ImageOptions {
  required?: boolean;
  maxSize?: number;
  allowedTypes?: string[];
}
declare function image(options?: ImageOptions): FieldDefinition<ImageValue | undefined>;
//#endregion
//#region src/fields/file.d.ts
interface FileOptions {
  required?: boolean;
  maxSize?: number;
  allowedTypes?: string[];
  helpText?: string;
}
declare function file(options?: FileOptions): FieldDefinition<FileValue>;
//#endregion
//#region src/fields/reference.d.ts
/**
 * Reference field
 * References another content item by ID
 */
declare function reference(collection: string, options?: {
  required?: boolean;
}): FieldDefinition<string | undefined>;
//#endregion
//#region src/fields/portable-text.d.ts
/**
 * Portable Text field
 * Stores structured content in Portable Text format
 */
declare function portableText(options?: {
  required?: boolean;
}): FieldDefinition<PortableTextBlock$1[] | undefined>;
//#endregion
//#region src/api/handlers/content.d.ts
/**
 * Trashed content item with deletion timestamp
 */
interface TrashedContentItem {
  id: string;
  type: string;
  slug: string | null;
  status: string;
  data: Record<string, unknown>;
  authorId: string | null;
  createdAt: string;
  updatedAt: string;
  publishedAt: string | null;
  deletedAt: string;
}
/**
 * Create content list handler
 */
declare function handleContentList(db: Kysely<Database>, collection: string, params: {
  cursor?: string;
  limit?: number;
  status?: string;
  orderBy?: string;
  order?: "asc" | "desc";
  locale?: string;
  q?: string;
  authorId?: string;
  dateField?: ContentDateField;
  dateFrom?: string;
  dateTo?: string;
  bylines?: string[];
  bylinesNone?: boolean;
  includeInferredBylines?: boolean;
  fieldFilters?: ContentFieldFilters;
}): Promise<ApiResult<ContentListResponse>>;
/** A content author option for the admin author filter. */
interface ContentAuthor {
  id: string;
  name: string | null;
  email: string;
  avatarUrl: string | null;
}
/**
 * List the distinct authors of a collection's live content.
 *
 * Backs the admin content-list author filter. Unlike `/admin/users` (ADMIN
 * only), this is gated on `content:read`, so any editor can filter by author.
 * Returns only users who have authored at least one non-trashed entry, sorted
 * by display name then email for a stable dropdown order.
 */
declare function handleContentAuthors(db: Kysely<Database>, collection: string): Promise<ApiResult<{
  items: ContentAuthor[];
}>>;
/**
 * Get single content item
 */
declare function handleContentGet(db: Kysely<Database>, collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
/**
 * Get a content item by id, including trashed items.
 * Used by restore endpoint for ownership checks on soft-deleted items.
 */
declare function handleContentGetIncludingTrashed(db: Kysely<Database>, collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
/**
 * Create content item.
 *
 * Content + SEO writes are wrapped in a transaction so either both succeed
 * or neither does. If `body.seo` is provided for a non-SEO collection, the
 * API returns a validation error rather than silently dropping it.
 */
declare function handleContentCreate(db: Kysely<Database>, collection: string, body: {
  data: Record<string, unknown>;
  slug?: string | null;
  status?: string;
  authorId?: string;
  bylines?: ContentBylineInput[];
  locale?: string;
  translationOf?: string;
  seo?: ContentSeoInput;
  taxonomies?: Record<string, string[]>;
  createdAt?: string | null;
  publishedAt?: string | null;
}): Promise<ApiResult<ContentResponse>>;
/**
 * Update content item.
 * If `_rev` is provided, validates it against the current version before writing.
 * No `_rev` = blind write (backwards-compatible for admin UI).
 *
 * Content + SEO writes are wrapped in a transaction for atomicity.
 */
declare function handleContentUpdate(db: Kysely<Database>, collection: string, id: string, body: {
  data?: Record<string, unknown>;
  slug?: string | null;
  status?: string;
  authorId?: string | null;
  bylines?: ContentBylineInput[];
  locale?: string;
  _rev?: string;
  seo?: ContentSeoInput;
  taxonomies?: Record<string, string[]>;
  publishedAt?: string | null;
}): Promise<ApiResult<ContentResponse>>;
/**
 * Duplicate content item.
 *
 * Only copies SEO data if the collection has SEO enabled.
 * Always returns consistent `seo` shape for SEO-enabled collections.
 */
declare function handleContentDuplicate(db: Kysely<Database>, collection: string, id: string, authorId?: string): Promise<ApiResult<{
  item: ContentItem;
}>>;
/**
 * Delete content item (soft delete - moves to trash)
 */
declare function handleContentDelete(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
  deleted: true;
  id: string;
}>>;
/**
 * Restore content item from trash
 */
declare function handleContentRestore(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
  restored: true;
  item: ContentItem;
}>>;
/**
 * Permanently delete content item (cannot be undone).
 * Also cleans up associated SEO data.
 */
declare function handleContentPermanentDelete(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
  deleted: true;
  id: string;
}>>;
/**
 * List trashed content items
 */
declare function handleContentListTrashed(db: Kysely<Database>, collection: string, options?: {
  limit?: number;
  cursor?: string;
}): Promise<ApiResult<{
  items: TrashedContentItem[];
  nextCursor?: string;
}>>;
/**
 * Count trashed content items
 */
declare function handleContentCountTrashed(db: Kysely<Database>, collection: string): Promise<ApiResult<{
  count: number;
}>>;
/**
 * Schedule content for future publishing
 */
declare function handleContentSchedule(db: Kysely<Database>, collection: string, id: string, scheduledAt: string): Promise<ApiResult<ContentResponse>>;
/**
 * Unschedule content (revert to draft)
 */
declare function handleContentUnschedule(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<ContentResponse>>;
/**
 * Publish content immediately.
 *
 * Publication is one atomic content-row statement. On databases that support
 * transactions, the existing slug-redirect side write remains grouped with it.
 */
declare function handleContentPublish(db: Kysely<Database>, collection: string, id: string, options?: {
  publishedAt?: string;
  requireScheduledDue?: boolean;
  expectedScheduledAt?: string;
}): Promise<ApiResult<ContentResponse>>;
/**
 * Unpublish content (revert to draft).
 *
 * Wrapped in a transaction — unpublish may create a draft revision
 * from the live version then update the status, which is multi-step.
 */
declare function handleContentUnpublish(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<ContentResponse>>;
/**
 * Count scheduled content items
 */
declare function handleContentCountScheduled(db: Kysely<Database>, collection: string): Promise<ApiResult<{
  count: number;
}>>;
/**
 * Discard draft changes (revert to live version)
 */
declare function handleContentDiscardDraft(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<ContentResponse>>;
/**
 * Compare live and draft revisions
 */
declare function handleContentCompare(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
  hasChanges: boolean;
  live: Record<string, unknown> | null;
  draft: Record<string, unknown> | null;
}>>;
/**
 * Get all translations for a content item.
 * Returns the item's translation group members with locale and status info.
 */
declare function handleContentTranslations(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
  translationGroup: string;
  translations: Array<{
    id: string;
    locale: string | null;
    slug: string | null;
    status: string;
    updatedAt: string;
  }>;
}>>;
//#endregion
//#region src/api/handlers/manifest.d.ts
interface CollectionDefinition {
  schema: {
    _def?: {
      shape?: () => Record<string, unknown>;
    };
    shape?: Record<string, unknown>;
  };
  admin: {
    label: string;
    labelSingular?: string;
    supports?: string[];
    routable?: boolean;
  };
}
type CollectionMap = Record<string, CollectionDefinition>;
/**
 * Generate admin manifest from collections
 */
declare function generateManifest(collections: CollectionMap, plugins?: Record<string, {
  adminPages?: Array<{
    path: string;
    component: string;
  }>;
  widgets?: string[];
}>): Promise<ManifestResponse>;
//#endregion
//#region src/api/handlers/revision.d.ts
interface RevisionListResponse {
  items: Revision[];
  total: number;
}
interface RevisionResponse {
  item: Revision;
}
/**
 * List revisions for a content entry
 */
declare function handleRevisionList(db: Kysely<Database>, collection: string, entryId: string, params?: {
  limit?: number;
}): Promise<ApiResult<RevisionListResponse>>;
/**
 * Get a specific revision
 */
declare function handleRevisionGet(db: Kysely<Database>, revisionId: string): Promise<ApiResult<RevisionResponse>>;
/**
 * Restore a revision (updates content to this revision's data and creates new revision)
 */
declare function handleRevisionRestore(db: Kysely<Database>, revisionId: string, callerUserId: string): Promise<ApiResult<ContentResponse>>;
//#endregion
//#region src/api/handlers/media.d.ts
interface MediaListResponse {
  items: MediaItem[];
  nextCursor?: string;
}
interface MediaResponse {
  item: MediaItem;
}
/**
 * List media items
 */
declare function handleMediaList(db: Kysely<Database>, params: {
  cursor?: string;
  limit?: number;
  mimeType?: string | readonly string[];
  q?: string;
}): Promise<ApiResult<MediaListResponse>>;
/**
 * Get single media item
 */
declare function handleMediaGet(db: Kysely<Database>, id: string): Promise<ApiResult<MediaResponse>>;
/**
 * Create media item (after file upload)
 */
declare function handleMediaCreate(db: Kysely<Database>, input: {
  filename: string;
  mimeType: string;
  size?: number;
  width?: number;
  height?: number;
  alt?: string;
  storageKey: string;
  contentHash?: string;
  blurhash?: string;
  dominantColor?: string;
  authorId?: string;
}): Promise<ApiResult<MediaResponse>>;
/**
 * Update media metadata
 */
declare function handleMediaUpdate(db: Kysely<Database>, id: string, input: {
  alt?: string;
  caption?: string;
  width?: number;
  height?: number;
}): Promise<ApiResult<MediaResponse>>;
/**
 * Delete media item
 */
declare function handleMediaDelete(db: Kysely<Database>, id: string): Promise<ApiResult<{
  deleted: true;
  storageKey: string;
}>>;
//#endregion
//#region src/media/usage/content-refresh.d.ts
type ContentMediaUsageRefreshErrorCode = "CONTENT_NOT_FOUND" | "DRAFT_REVISION_NOT_FOUND" | "DRAFT_REVISION_MISMATCH" | "DRAFT_REVISION_INVALID" | "CONTENT_USAGE_REFRESH_ERROR" | "CONTENT_USAGE_DELETE_ERROR" | "CONTENT_USAGE_GENERATION_CONFLICT" | "CONTENT_USAGE_RESOURCE_LIMIT" | "CONTENT_USAGE_STALE";
declare function markContentMediaUsageCollectionStaleSafely(db: Kysely<Database>, collectionSlug: string, lastErrorCode: ContentMediaUsageRefreshErrorCode): Promise<boolean>;
//#endregion
//#region src/schema/registry.d.ts
/**
 * Error thrown when a schema operation fails
 */
declare class SchemaError extends Error {
  code: string;
  details?: Record<string, unknown> | undefined;
  constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
}
/**
 * Schema Registry
 *
 * Manages collection and field definitions stored in D1.
 * Handles runtime DDL operations (CREATE TABLE, ALTER TABLE).
 */
declare class SchemaRegistry {
  private db;
  constructor(db: Kysely<Database>);
  /**
   * List all collections
   */
  listCollections(): Promise<Collection[]>;
  /**
   * Get a collection by slug
   */
  getCollection(slug: string): Promise<Collection | null>;
  /**
   * Get a collection with all its fields
   */
  getCollectionWithFields(slug: string): Promise<CollectionWithFields | null>;
  /**
   * List every collection together with its fields in O(1) query shapes
   * — one for collections, then one batched query for the fields of every
   * returned collection — instead of the N+1 pattern of `listCollections`
   * + per-collection `listFields`. The fields query is chunked at
   * `SQL_BATCH_SIZE` to stay under D1's bound-parameter limit, so on
   * sites with more than `SQL_BATCH_SIZE` collections the field fetch
   * becomes `ceil(collectionCount / SQL_BATCH_SIZE)` queries — still
   * a constant factor, not N+1. Typical sites have well under
   * `SQL_BATCH_SIZE` collections, so this is two queries in practice.
   *
   * Used by the manifest build, which previously paid N+1 round-trips on
   * every admin request. Each round-trip costs ~80–150ms against the D1
   * primary on a busy link, so a 10-collection site spent ~1 s rebuilding
   * a manifest that is now built fresh per admin request (no cache).
   */
  listCollectionsWithFields(): Promise<CollectionWithFields[]>;
  /**
   * Validate `titleField`/`dateField` against the collection's fields:
   * `titleField` must be a text-like field; `dateField` must be a `datetime` field.
   * Only truthy values are checked (undefined = unchanged, null/"" = cleared).
   */
  private validateTitleDateFields;
  /**
   * Create a new collection
   */
  createCollection(input: CreateCollectionInput): Promise<Collection>;
  /**
   * Create a seed-owned collection and all of its fields in bulk.
   *
   * Fresh seeds can define dozens of fields. Creating them through
   * `createField` performs multiple reads, one ALTER TABLE, and one media
   * usage invalidation per field, which can exhaust D1's per-request query
   * budget. This path validates the full schema before mutating it, creates
   * the complete content table in one statement, and inserts field metadata
   * in parameter-safe batches.
   */
  createSeedCollection(input: Omit<CreateCollectionInput, "source">, fields: readonly CreateFieldInput[]): Promise<void>;
  private assertSeedFieldDefinitions;
  /**
   * Update a collection
   */
  updateCollection(slug: string, input: UpdateCollectionInput): Promise<Collection>;
  /**
   * Delete a collection
   */
  deleteCollection(slug: string, options?: {
    force?: boolean;
  }): Promise<void>;
  /**
   * List fields for a collection
   */
  listFields(collectionId: string): Promise<Field[]>;
  /**
   * Get a field by slug within a collection
   */
  getField(collectionSlug: string, fieldSlug: string): Promise<Field | null>;
  /**
   * Create a new field
   */
  createField(collectionSlug: string, input: CreateFieldInput): Promise<Field>;
  /**
   * Update a field
   */
  updateField(collectionSlug: string, fieldSlug: string, input: UpdateFieldInput): Promise<Field>;
  /**
   * Synchronize an existing FTS index with the collection's current state.
   *
   * Only rebuilds or disables — never first-time enables. First-time FTS
   * enablement is handled by the seed's explicit enableSearch call (which
   * is try-caught) or the admin UI toggle.
   *
   * - FTS active + still has search support and searchable fields → rebuild
   * - FTS active + lost search support or no searchable fields    → disable
   * - FTS not active                                              → no-op
   *
   * Pass `db` when calling from within a transaction so FTS operations
   * participate in the same transaction and are rolled back on failure.
   */
  private syncSearchState;
  /**
   * Delete a field
   */
  deleteField(collectionSlug: string, fieldSlug: string): Promise<void>;
  /**
   * Reorder collections in the admin sidebar.
   *
   * `slugs` is the full desired order: every listed collection gets its
   * index as `sort_order`, and any collection left out has its explicit
   * position cleared, dropping it back to the alphabetical tail. Unknown or
   * duplicate slugs throw before anything is written.
   */
  reorderCollections(slugs: string[]): Promise<void>;
  /**
   * Reorder fields
   */
  reorderFields(collectionSlug: string, fieldSlugs: string[]): Promise<void>;
  /**
   * Create a content table for a collection
   */
  private createContentTable;
  private getFieldIndexName;
  private getLocaleFieldIndexName;
  private createFieldIndex;
  private dropFieldIndex;
  /**
   * Add a column to a content table
   */
  private addColumn;
  /**
   * Drop a column from a content table
   */
  private dropColumn;
  /**
   * Check if a collection has any content
   */
  private collectionHasContent;
  /**
   * Get table name for a collection
   */
  private getTableName;
  /**
   * Get column name for a field
   */
  private getColumnName;
  /**
   * Validate a slug
   */
  private validateSlug;
  /**
   * Format a default value for SQL.
   *
   * SQLite `ALTER TABLE ADD COLUMN ... DEFAULT` requires a literal constant
   * expression — parameterized values cannot be used here. We manually escape
   * single quotes and coerce types to ensure the output is safe.
   *
   * INTEGER/REAL values are coerced through `Number()` which can only produce
   * digits, `.`, `-`, `e`, `Infinity`, or `NaN` — all safe in SQL.
   * TEXT/JSON values have single quotes escaped via SQL standard doubling (`''`).
   */
  private formatDefaultValue;
  /**
   * Get empty default for a field type
   */
  private getEmptyDefault;
  /**
   * Map a collection row to a Collection object
   */
  private mapCollectionRow;
  /**
   * Map a field row to a Field object
   */
  private mapFieldRow;
  /**
   * Discover orphaned content tables
   *
   * Finds ec_* tables that exist in the database but don't have a
   * corresponding entry in _emdash_collections.
   */
  discoverOrphanedTables(): Promise<Array<{
    slug: string;
    tableName: string;
    rowCount: number;
  }>>;
  /**
   * Register an orphaned table as a collection
   *
   * Creates a _emdash_collections entry for an existing ec_* table.
   */
  registerOrphanedTable(slug: string, options?: {
    label?: string;
    labelSingular?: string;
    description?: string;
  }): Promise<Collection>;
  /**
   * Convert slug to human-readable label
   */
  private slugToLabel;
}
//#endregion
//#region src/schema/query.d.ts
/**
 * Get collection metadata by slug.
 *
 * @example
 * ```ts
 * import { getCollectionInfo } from "@premium-cms/emdash";
 *
 * const info = await getCollectionInfo("posts");
 * if (info?.commentsEnabled) {
 *   // render comment UI
 * }
 * ```
 */
declare function getCollectionInfo(slug: string): Promise<Collection | null>;
//#endregion
//#region src/database/migrations/policy.d.ts
type RuntimeMigrationMode = "auto" | "check" | "manual";
interface RuntimeMigrationConfig {
  runtime: RuntimeMigrationMode;
  dev?: RuntimeMigrationMode;
}
//#endregion
//#region src/registry/types.d.ts
/**
 * Public types for the experimental plugin registry.
 *
 * Kept in their own module so they don't get re-bundled into the
 * `astro/integration/runtime.ts` chunk's dist output. tsdown / rolldown
 * are sensitive to which top-level types live alongside `definePlugin`'s
 * overloads, and pulling these types into the integration module
 * affected downstream `definePlugin()` overload resolution for trusted
 * plugins built against core's dist (see commit history for the
 * detailed write-up).
 */
/**
 * Experimental plugin registry configuration.
 *
 * See {@link ExperimentalConfig.registry}.
 */
interface RegistryConfig {
  /**
   * Base URL of the registry aggregator (an atproto AppView that indexes
   * the firehose for `pm.fair.package.*` and `com.emdashcms.*` records).
   *
   * Must be the origin where the aggregator's XRPC endpoints are mounted,
   * such that `${aggregatorUrl}/xrpc/<nsid>` resolves to a valid endpoint.
   *
   * Must be HTTPS in production; `http://localhost` or `http://127.0.0.1`
   * are accepted in dev.
   */
  aggregatorUrl: string;
  /**
   * Optional comma-separated list of bare labeller DIDs forwarded as the
   * `atproto-accept-labelers` header on every aggregator request. The
   * declaration contributes to the client's cache identity.
   *
   * The aggregator validates the declaration and rejects unknown sources or
   * a list that omits a required source. It does not let the declaration
   * override its configured approval, block, takedown, or withdrawal policy.
   */
  acceptLabelers?: string;
  /**
   * Site-level policy applied to the latest-release selection filter.
   *
   * These filters operate over the signed records the aggregator returns;
   * they are not protocol-level constraints. See the RFC's
   * "Update Discovery and Takedowns" section for the integration point.
   */
  policy?: {
    /**
     * Hold back releases newer than this when computing the recommended
     * install or update version. Mitigates "compromised publisher
     * account pushes a malicious release of an established plugin" by
     * giving the takedown labeller a detection window.
     *
     * Accepts a duration string (`"24h"`, `"48h"`, `"72h"`, `"7d"`) or a
     * number of seconds.
     *
     * Currently applies uniformly to all releases. A future addition
     * may exempt brand-new packages (those with no prior release
     * history) so the holdback doesn't block first-time publishing,
     * but that exemption is not implemented yet; use
     * {@link minimumReleaseAgeExclude} to allowlist trusted publishers
     * whose packages should install immediately.
     *
     * Defaults to `undefined` (no holdback). A future trust/moderation
     * RFC will specify the recommended default.
     */
    minimumReleaseAge?: string | number;
    /**
     * Packages exempt from the {@link minimumReleaseAge} holdback. Use
     * for publishers whose release tempo you've explicitly accepted --
     * your own first-party plugins, a trusted partner, etc.
     *
     * Each entry is either:
     *   - A bare publisher DID (e.g. `"did:plc:abc123"`) -- every
     *     package from that publisher is exempt.
     *   - A `<did>/<slug>` pair (e.g.
     *     `"did:plc:abc123/hotfix-plugin"`) -- only that specific
     *     package is exempt.
     *
     * Whole-publisher exemptions are the common case: trust is
     * naturally a property of the publisher, not of each individual
     * package. Per-package exemptions exist for cases where a publisher
     * has one plugin you want fast-track installs for and others you'd
     * rather hold back.
     *
     * Only DIDs are accepted -- not handles. Handles are mutable
     * aggregator-supplied envelope data, and accepting them as a
     * trust input would let a compromised aggregator bypass the
     * holdback by claiming any handle for any package. DIDs are
     * tied to the AT URI of the package record itself, so even a
     * compromised aggregator cannot lie about which DID published
     * a release.
     *
     * Mirrors pnpm's `minimumReleaseAgeExclude`.
     *
     * @example
     * ```ts
     * minimumReleaseAgeExclude: [
     *   "did:plc:emdashfirstparty",     // every package from this publisher
     *   "did:plc:abc123/hotfix-plugin", // just this one package
     * ]
     * ```
     */
    minimumReleaseAgeExclude?: readonly string[];
  };
}
/**
 * Shorthand: pass a bare aggregator URL string in place of a full
 * `RegistryConfig` object when you don't need `acceptLabelers` or
 * `policy`. The normalizer expands the string into
 * `{ aggregatorUrl: <string> }` before any downstream code sees it.
 *
 * @example
 * ```ts
 * experimental: {
 *   registry: "https://registry.emdashcms.com",
 * }
 * ```
 *
 * Equivalent to:
 * ```ts
 * experimental: {
 *   registry: { aggregatorUrl: "https://registry.emdashcms.com" },
 * }
 * ```
 */
type RegistryConfigInput = string | RegistryConfig;
/**
 * Experimental EmDash features. See `EmDashConfig.experimental`.
 *
 * Each field is independently opt-in. Fields may be promoted out of
 * `experimental` (becoming top-level `EmDashConfig` options) or removed
 * in minor releases; check the changelog when upgrading.
 */
interface ExperimentalConfig {
  /**
   * Decentralized plugin registry.
   *
   * When set, replaces the centralized `marketplace` for the admin UI's
   * browse and install flows. The registry is an atproto-backed
   * federation: package metadata lives in each publisher's PDS and
   * an aggregator (the `aggregatorUrl`) indexes the firehose and
   * exposes read-only XRPC endpoints for discovery.
   *
   * See [RFC 0001](https://github.com/emdash-cms/emdash/pull/694) for
   * the protocol design.
   *
   * **Trust model (v1, experimental).** Today EmDash trusts the
   * configured aggregator with these claims, per package and per
   * release:
   *
   *   - The publisher DID associated with a `(did, slug)` pair.
   *   - The artifact `url`, the artifact `checksum`, and any mirror
   *     URLs returned for a release.
   *   - The published handle for a DID (used for display only;
   *     EmDash separately verifies the DID->handle round-trip in the
   *     admin UI before treating a handle as confirmed).
   *
   * What EmDash verifies independently before activating an
   * installed plugin:
   *
   *   - The artifact bytes hash to the checksum the aggregator
   *     returned (so a malicious mirror or in-transit tamper can't
   *     swap the bundle).
   *   - The bundle's `manifest.id` matches the requested slug, and
   *     its `manifest.version` matches the release version (so an
   *     attacker who controls the aggregator can't trick the
   *     sandbox into addressing the wrong plugin id).
   *   - The bundle's `manifest.capabilities` matches what the admin
   *     acknowledged in the consent dialog (so a publisher can't
   *     ship a bundle that requests more permissions than the
   *     dialog displayed).
   *
   * What's NOT yet verified:
   *
   *   - Full MST proof / publisher signature on the release record.
   *     A compromised aggregator can forge a release for any DID
   *     and slug, and the install will succeed as long as the
   *     bundle matches the (forged) checksum.
   *   - Per-release replay / rollback: the aggregator chooses which
   *     release version is "latest".
   *
   * **Recommendation.** Until full signature verification lands,
   * point `aggregatorUrl` only at an aggregator you operate
   * yourself or one you trust with the same level of authority as
   * a centralized plugin source. `policy.minimumReleaseAge` widens
   * the detection window for takedowns. `acceptLabelers` declares a
   * request and cache identity; it does not change aggregator policy.
   *
   * Requires `sandboxRunner` to be configured -- registry plugins
   * always run sandboxed.
   *
   * Accepts a bare URL string as shorthand for
   * `{ aggregatorUrl: "..." }`. Use the full object form when you
   * need `acceptLabelers` or `policy`.
   */
  registry?: RegistryConfigInput;
}
//#endregion
//#region src/astro/storage/types.d.ts
/**
 * Serializable storage configuration descriptor
 */
interface StorageDescriptor {
  /** Module path exporting createStorage function */
  entrypoint: string;
  /** Serializable config passed to createStorage at runtime */
  config: unknown;
}
/**
 * S3-compatible storage configuration
 */
interface S3StorageConfig {
  /** S3 endpoint URL */
  endpoint: string;
  /** Bucket name */
  bucket: string;
  /**
   * Access key ID.
   * May be resolved from the `S3_ACCESS_KEY_ID` env var at runtime on Node.
   * Must be provided together with `secretAccessKey`, or both omitted.
   */
  accessKeyId?: string;
  /**
   * Secret access key.
   * May be resolved from the `S3_SECRET_ACCESS_KEY` env var at runtime on Node.
   * Must be provided together with `accessKeyId`, or both omitted.
   */
  secretAccessKey?: string;
  /** Optional region (defaults to "auto") */
  region?: string;
  /** Optional public URL prefix for CDN */
  publicUrl?: string;
}
/**
 * Local filesystem storage configuration
 */
interface LocalStorageConfig {
  /** Directory path for storing files */
  directory: string;
  /** Base URL for serving files */
  baseUrl: string;
}
//#endregion
//#region src/astro/integration/runtime.d.ts
/**
 * Admin page definition (copied from plugins/types to avoid circular deps)
 */
interface PluginAdminPage {
  path: string;
  label: string;
  icon?: string;
}
/**
 * Dashboard widget definition (copied from plugins/types to avoid circular deps)
 */
interface PluginDashboardWidget {
  id: string;
  size?: "full" | "half" | "third";
  title?: string;
}
/**
 * Plugin descriptor - returned by plugin factory functions
 *
 * Contains all static metadata needed for manifest and admin UI,
 * plus the entrypoint for runtime instantiation.
 *
 * @example
 * ```ts
 * export function myPlugin(options?: MyPluginOptions): PluginDescriptor {
 *   return {
 *     id: "my-plugin",
 *     version: "1.0.0",
 *     entrypoint: "@my-org/emdash-plugin-foo",
 *     options: options ?? {},
 *     adminEntry: "@my-org/emdash-plugin-foo/admin",
 *     adminPages: [{ path: "/settings", label: "Settings" }],
 *   };
 * }
 * ```
 */
/**
 * Storage collection declaration for sandboxed plugins
 */
interface StorageCollectionDeclaration {
  indexes?: string[];
  uniqueIndexes?: string[];
}
interface PluginDescriptor<TOptions = Record<string, unknown>> {
  /** Unique plugin identifier */
  id: string;
  /** Plugin version (semver) */
  version: string;
  /** Module specifier to import (e.g., "@premium-cms/plugin-api-test") */
  entrypoint: string;
  /**
   * Options to pass to createPlugin(). Native format only.
   * Standard-format plugins configure themselves via KV settings
   * and Block Kit admin pages -- not constructor options.
   */
  options?: TOptions;
  /**
   * Plugin format. Determines how the entrypoint is loaded:
   * - `"standard"` -- exports `definePlugin({ hooks, routes })` as default.
   *   Wrapped with `adaptSandboxEntry` for in-process execution. Can run in both
   *   `plugins: []` (in-process) and `sandboxed: []` (isolate).
   * - `"native"` -- exports `createPlugin(options)` returning a `ResolvedPlugin`.
   *   Can only run in `plugins: []`. Cannot be sandboxed or published to marketplace.
   *
   * Defaults to `"native"` when unset.
   *
   */
  format?: "standard" | "native";
  /** Admin UI module specifier (e.g., "@premium-cms/plugin-audit-log/admin") */
  adminEntry?: string;
  /** Module specifier for site-side Astro rendering components (must export `blockComponents`) */
  componentsEntry?: string;
  /** Admin pages for navigation */
  adminPages?: PluginAdminPage[];
  /** Dashboard widgets */
  adminWidgets?: PluginDashboardWidget[];
  /** Settings schema for the auto-generated admin settings form */
  settingsSchema?: Record<string, SettingField>;
  /**
   * Portable Text block types this plugin contributes to the editor.
   * Declarative (Block Kit) — surfaced in the admin slash menu and consumed
   * from the manifest, so standard/sandboxed plugins can contribute blocks
   * without a native render component.
   */
  portableTextBlocks?: PortableTextBlockConfig[];
  /** Field widget types this plugin contributes for schema-field editing UIs. */
  fieldWidgets?: FieldWidgetConfig[];
  /**
   * Capabilities the plugin requests.
   * For standard-format plugins, capabilities are enforced in both trusted and
   * sandboxed modes via the PluginContextFactory.
   */
  capabilities?: string[];
  /**
   * Allowed hosts for network:fetch capability
   * Supports wildcards like "*.example.com"
   */
  allowedHosts?: string[];
  /**
   * Storage collections the plugin declares
   * Sandboxed plugins can only access declared collections.
   */
  storage?: Record<string, StorageCollectionDeclaration>;
  /** Serialized MCP declarations emitted by the plugin build. */
  mcp?: PluginMcpManifestConfig;
  /**
   * Route declarations for sandboxed config-declared plugins. Mirrors
   * definePlugin({ routes }) and drives route auth decisions; omitted routes
   * default to non-public.
   */
  routes?: Array<ManifestRouteEntry | string>;
  /**
   * Hook declarations for sandboxed config-declared plugins. Mirrors
   * definePlugin({ hooks }).
   */
  hooks?: Array<ManifestHookEntry | string>;
}
/**
 * Sandboxed plugin descriptor - same format as PluginDescriptor
 *
 * These run in isolated V8 isolates via Worker Loader on Cloudflare.
 * The `entrypoint` is resolved to a file and bundled at build time.
 */
type SandboxedPluginDescriptor<TOptions = Record<string, unknown>> = PluginDescriptor<TOptions>;
interface EmDashConfig {
  /**
   * Database configuration
   *
   * Use one of the adapter functions:
   * - `sqlite({ url: "file:./data.db" })` - Local SQLite
   * - `libsql({ url: "...", authToken: "..." })` - Turso/libSQL
   * - `d1({ binding: "DB" })` - Cloudflare D1
   *
   * @example
   * ```ts
   * import { sqlite } from "@premium-cms/emdash/db";
   *
   * emdash({
   *   database: sqlite({ url: "file:./data.db" }),
   * })
   * ```
   */
  database?: DatabaseDescriptor;
  /** Core database migration behavior at runtime. Defaults to `auto`. */
  migrations?: RuntimeMigrationConfig;
  /**
   * Storage configuration (for media)
   */
  storage?: StorageDescriptor;
  /**
   * Optional distributed object cache for query results.
   *
   * Off by default. When configured, content and chrome (settings, menus,
   * taxonomies) reads are cached in a fast key/value store and served without
   * touching the database on repeat requests across isolates. This offloads
   * read pressure from D1/SQLite, which is especially valuable on Cloudflare
   * where D1 has far lower request capacity than KV.
   *
   * Use a backend adapter:
   * - `memoryCache()` from `emdash/astro` — in-isolate (Node / local dev)
   * - `kvCache({ binding: "CACHE" })` from `@premium-cms/cloudflare` — KV
   *
   * Preview and visual-edit requests bypass the cache, so editors previewing
   * see live content. All other reads — including authenticated browsing outside
   * edit mode — are served from the cache, which only ever stores published
   * content. After an edit, anonymous visitors may see stale content until other
   * isolates pick up the bumped epoch: immediate with the memory backend, and on
   * KV bounded by KV's edge-cache propagation (eventual consistency, up to ~60s)
   * plus the isolate-local `revalidate` window (default 1s).
   *
   * Scheduled content becomes visible at query time (no write event fires when
   * its publish time passes), so a cached list/entry won't surface a newly-due
   * scheduled item until the next write to that collection or until the
   * entry's TTL lapses (`defaultTtl`, default 1h). Sites that rely on precise
   * scheduled publishing should lower `defaultTtl` accordingly.
   *
   * @example
   * ```ts
   * import { kvCache } from "@premium-cms/cloudflare";
   *
   * emdash({
   *   database: d1({ binding: "DB" }),
   *   objectCache: kvCache({ binding: "CACHE" }),
   * })
   * ```
   */
  objectCache?: ObjectCacheDescriptor;
  /**
   * Image optimization.
   *
   * By default EmDash wraps Astro's image endpoint so media served from
   * storage is optimized through the normal `<Image>` / `getImage` pipeline,
   * loading source bytes directly from the storage adapter (works behind
   * Cloudflare Access). Set to `false` to leave Astro's image endpoint
   * untouched -- media then renders as a plain `<img>` unless your image
   * service can fetch it over HTTP.
   */
  images?: boolean;
  /**
   * Trusted plugins to load (run in main isolate)
   *
   * @example
   * ```ts
   * import auditLog from "@premium-cms/plugin-audit-log";
   * import webhookNotifier from "@premium-cms/plugin-webhook-notifier";
   *
   * emdash({
   *   plugins: [auditLog, webhookNotifier],
   * })
   * ```
   */
  plugins?: PluginDescriptor[];
  /**
   * Sandboxed plugins to load (run in isolated V8 isolates)
   *
   * Only works on Cloudflare with Worker Loader enabled.
   * Uses the same format as `plugins` - the difference is where they run.
   *
   * @example
   * ```ts
   * import { untrustedPlugin } from "some-third-party-plugin";
   *
   * emdash({
   *   plugins: [trustedPlugin()],     // runs in host
   *   sandboxed: [untrustedPlugin()], // runs in isolate
   *   sandboxRunner: "@premium-cms/sandbox-cloudflare",
   * })
   * ```
   */
  sandboxed?: SandboxedPluginDescriptor[];
  /**
   * Module that exports the sandbox runner factory.
   * Required if using sandboxed plugins.
   *
   * @example
   * ```ts
   * emdash({
   *   sandboxRunner: "@premium-cms/sandbox-cloudflare",
   * })
   * ```
   */
  sandboxRunner?: string;
  /**
   * Explicitly disable plugin sandboxing, even if a sandbox runner is configured.
   * Use this as a debugging escape hatch to determine whether a bug is in your
   * plugin code or in the sandbox runtime.
   *
   * When set to `false`, all plugins run in-process without isolation.
   *
   * @default true (sandboxing enabled if sandboxRunner is configured)
   */
  sandbox?: boolean;
  /**
   * Authentication configuration
   *
   * Use an auth adapter function from a platform package:
   * - `access({ teamDomain: "..." })` from `@premium-cms/cloudflare`
   *
   * When an external auth provider is configured, passkey auth is disabled.
   *
   * @example
   * ```ts
   * import { access } from "@premium-cms/cloudflare";
   *
   * emdash({
   *   auth: access({
   *     teamDomain: "myteam.cloudflareaccess.com",
   *     audience: "abc123...",
   *     roleMapping: {
   *       "Admins": 50,
   *       "Editors": 30,
   *     },
   *   }),
   * })
   * ```
   */
  auth?: AuthDescriptor;
  /**
   * Pluggable auth providers (login methods on the login page).
   *
   * Auth providers appear as options alongside passkey on the login page
   * and setup wizard. Any provider can be used to create the initial
   * admin account. Passkey is built-in; providers listed here are additive.
   *
   * @example
   * ```ts
   * import { atproto } from "@premium-cms/auth-atproto";
   *
   * emdash({
   *   authProviders: [atproto()],
   * })
   * ```
   */
  authProviders?: AuthProviderDescriptor[];
  /**
   * MCP (Model Context Protocol) server endpoint.
   *
   * Exposes an MCP Streamable HTTP server at `/_emdash/api/mcp`
   * that allows AI agents and tools to interact with the CMS using
   * the standardized MCP protocol.
   *
   * Enabled by default. The endpoint requires bearer token auth, so
   * it has no effect unless the user creates an API token and
   * configures a client. Set to `false` to disable.
   *
   * @default true
   */
  mcp?: boolean;
  /**
   * Plugin marketplace URL
   *
   * When set, enables the marketplace features: browse, install, update,
   * and uninstall plugins from a remote marketplace.
   *
   * Must be an HTTPS URL in production, or localhost/127.0.0.1 in dev.
   * Requires `sandboxRunner` to be configured (marketplace plugins run sandboxed).
   *
   * When `registry` is also configured, the registry replaces the marketplace
   * for the admin UI's browse and install flows. Existing marketplace-installed
   * plugins continue to work; new installs and updates come from the registry.
   *
   * @example
   * ```ts
   * emdash({
   *   marketplace: "https://marketplace.emdashcms.com",
   *   sandboxRunner: "@premium-cms/sandbox-cloudflare",
   * })
   * ```
   */
  marketplace?: string;
  /**
   * Experimental features.
   *
   * These options are not yet stable. Shape, defaults, and behavior may
   * change between minor versions. Use only if you're comfortable
   * tracking the release notes and updating your config when an
   * experimental feature graduates or changes.
   *
   * @example
   * ```ts
   * emdash({
   *   experimental: {
   *     registry: {
   *       aggregatorUrl: "https://registry.emdashcms.com",
   *     },
   *   },
   *   sandboxRunner: "@premium-cms/sandbox-cloudflare",
   * })
   * ```
   */
  experimental?: ExperimentalConfig;
  /**
   * Maximum allowed media file upload size in bytes.
   *
   * Applies to both direct multipart uploads and signed-URL uploads.
   * When unset, defaults to 52_428_800 (50 MB).
   *
   * @example
   * ```ts
   * emdash({ maxUploadSize: 100 * 1024 * 1024 }) // 100 MB
   * ```
   */
  maxUploadSize?: number;
  /**
   * Public browser-facing origin for the site.
   *
   * Use when `Astro.url` / `request.url` do not match what users open — common with a
   * **TLS-terminating reverse proxy**: the app often sees `http://` on the internal hop
   * while the browser uses `https://`, which breaks WebAuthn, CSRF, OAuth, and redirect URLs.
   *
   * Set to the full origin users type in the address bar (no path), e.g.
   * `https://mysite.example.com`. When not set, falls back to environment variables
   * `EMDASH_SITE_URL` > `SITE_URL`, then to the request URL's origin.
   *
   * Replaces `passkeyPublicOrigin` (which only fixed passkeys).
   */
  siteUrl?: string;
  /**
   * Additional origins accepted by passkey verification.
   *
   * When the same EmDash deployment is reachable under several hostnames sharing
   * a registrable parent (e.g. `https://example.com` plus
   * `https://preview.example.com`), the canonical `siteUrl` defines the `rpId`
   * and the entries here are the *additional* origins from which assertions
   * are accepted. Each entry must be the same hostname as `siteUrl` or a
   * subdomain of it — WebAuthn requires `rpId` to be a registrable suffix of
   * every origin.
   *
   * Merged at runtime with the `EMDASH_ALLOWED_ORIGINS` env var (comma-separated).
   * Validation:
   *   - Config-declared entries are shape-checked at Astro startup.
   *   - Subdomain relationship to `siteUrl` is checked at startup when
   *     `siteUrl` is also config-declared, otherwise at first passkey
   *     verification (since `siteUrl` may come from `EMDASH_SITE_URL`).
   *
   * Mismatches throw with a source-attributed message naming
   * `config.allowedOrigins` or `EMDASH_ALLOWED_ORIGINS`.
   *
   * @example
   * ```ts
   * emdash({
   *   siteUrl: "https://example.com",
   *   allowedOrigins: ["https://preview.example.com"],
   * })
   * ```
   */
  allowedOrigins?: string[];
  trustedProxyHeaders?: string[];
  /**
   * User middleware that wraps the complete EmDash request pipeline.
   *
   * Before `next()` it runs before EmDash initializes its runtime or database,
   * so `locals.emdash`, the authenticated user, and request-scoped EmDash state
   * are unavailable. This allows cached responses and request gates to return
   * without paying initialization cost. When it calls `next()`, the resolved
   * response includes EmDash HTML injection and all other response mutations,
   * allowing the middleware to finalize caching and response headers safely.
   */
  middleware?: {
    /** Astro middleware module entrypoint. */outer: string | URL;
  };
  /**
   * Enable playground mode for ephemeral "try EmDash" sites.
   *
   * When set, the integration injects a playground middleware (order: "pre")
   * that runs BEFORE the normal EmDash middleware chain. It creates an
   * isolated Durable Object database per session, runs migrations, applies
   * the seed, creates an anonymous admin user, and sets the DB in ALS.
   * By the time the runtime middleware runs, the database is fully ready.
   *
   * Setup and auth middleware are skipped (the playground handles both).
   *
   * Requires `@premium-cms/cloudflare` as a dependency and a DO binding
   * in wrangler.jsonc.
   *
   * @example
   * ```ts
   * emdash({
   *   database: playgroundDatabase({ binding: "PLAYGROUND_DB" }),
   *   playground: {
   *     middlewareEntrypoint: "@premium-cms/cloudflare/db/playground-middleware",
   *   },
   * })
   * ```
   */
  playground?: {
    /** Module path for the playground middleware. */middlewareEntrypoint: string;
  };
  /**
   * Media providers for browsing and uploading media
   *
   * The local media provider (using storage adapter) is available by default.
   * Additional providers can be added for external services like Unsplash,
   * Cloudinary, Mux, Cloudflare Images, etc.
   *
   * @example
   * ```ts
   * import { cloudflareImages, cloudflareStream } from "@premium-cms/cloudflare";
   * import { unsplash } from "@premium-cms/provider-unsplash";
   *
   * emdash({
   *   mediaProviders: [
   *     cloudflareImages({ accountId: "..." }),
   *     cloudflareStream({ accountId: "..." }),
   *     unsplash({ accessKey: "..." }),
   *   ],
   * })
   * ```
   */
  mediaProviders?: MediaProviderDescriptor[];
  /**
   * Admin UI font configuration.
   *
   * By default, EmDash loads Noto Sans via the Astro Font API, covering
   * Latin, Latin Extended, Cyrillic, Cyrillic Extended, Greek, Greek
   * Extended, Devanagari, and Vietnamese. Fonts are downloaded from
   * Google at build time and self-hosted, so there are no runtime CDN
   * requests.
   *
   * To add support for additional writing systems (Arabic, CJK, etc.),
   * pass script names. EmDash resolves the matching Noto Sans variant
   * from Google Fonts and merges all script faces under a single
   * font-family, so the browser downloads only the glyphs it needs
   * via unicode-range.
   *
   * Set to `false` to disable font injection entirely and use system fonts.
   *
   * @example
   * ```ts
   * // Add Arabic and Japanese support
   * emdash({
   *   fonts: {
   *     scripts: ["arabic", "japanese"],
   *   },
   * })
   * ```
   *
   * @example
   * ```ts
   * // Disable web fonts entirely (use system fonts)
   * emdash({
   *   fonts: false,
   * })
   * ```
   */
  fonts?: false | {
    /**
     * Additional Noto Sans script families to include.
     *
     * Available scripts: arabic, armenian, bengali, chinese-simplified,
     * chinese-traditional, chinese-hongkong, devanagari, ethiopic, farsi,
     * georgian, gujarati, gurmukhi, hebrew, japanese, kannada, khmer,
     * korean, lao, malayalam, myanmar, oriya, sinhala, tamil, telugu,
     * thai, tibetan.
     */
    scripts?: string[];
  };
  /**
   * Admin UI branding (white-labeling).
   *
   * Overrides the default EmDash logo and name in the admin panel.
   * Use this to white-label the CMS for agency or enterprise deployments.
   * These settings are separate from the public site settings (title, logo,
   * favicon) which remain available for SEO and front-end use.
   *
   * @example
   * ```ts
   * emdash({
   *   admin: {
   *     logo: "/images/agency-logo.webp",
   *     siteName: "AgencyX CMS",
   *     favicon: "/favicon.ico",
   *   },
   * })
   * ```
   */
  admin?: {
    /** URL or path to a custom logo image for the admin UI (login page, sidebar). */logo?: string; /** Custom name displayed in the admin sidebar and browser tab. */
    siteName?: string; /** URL or path to a custom favicon for the admin panel. */
    favicon?: string;
  };
  /**
   * Editor toolbar delivery on public pages.
   *
   * - `"server"` (default): the toolbar is injected server-side into every
   *   HTML response rendered for an authenticated editor. Simple and
   *   zero-config, but behind a shared cache (Cloudflare Cache Everything /
   *   Workers Cache, Fastly, Varnish, …) editors often receive the cached
   *   anonymous variant — without the toolbar — whenever an anonymous visitor
   *   primed the cache first, so the toolbar appears and disappears with
   *   cache state.
   * - `"client"`: public HTML is identical for everyone (nothing
   *   session-specific is injected server-side, so shared caches stay fully
   *   effective). A tiny bootstrap script shows an "Edit" pill for browsers
   *   that have logged into the admin (non-secret localStorage flag). Clicking
   *   it verifies the session and reloads the page with an `_edit` query
   *   param, which is always rendered fresh (never cached) with the full
   *   toolbar. Logged-out visitors opening an `_edit` URL are redirected to
   *   the canonical URL.
   * - `false`: never render the toolbar or bootstrap script.
   *
   * See the visual-editing docs for the cache-behavior details.
   */
  toolbar?: "server" | "client" | false;
  /**
   * Version of Astro the host project is building with. Populated by the
   * integration's `astro:config:setup` hook (not authored by the user) and
   * surfaced to the admin and the registry install gate so a plugin's
   * `env:astro` requirement can be evaluated against the real host version.
   */
  astroVersion?: string;
}
/**
 * Get stored config from global
 * This is set by the virtual module at build time
 */
declare function getStoredConfig(): EmDashConfig | null;
//#endregion
//#region src/plugins/sandbox/types.d.ts
/**
 * Resource limits for sandboxed plugins.
 * Enforced by the sandbox runtime (e.g., Worker Loader).
 */
interface ResourceLimits {
  /** CPU time per invocation in milliseconds (default: 200ms) */
  cpuMs?: number;
  /** Memory limit in MB (default: 128MB) */
  memoryMb?: number;
  /** Maximum subrequests per invocation — every bridge call counts (default: 64) */
  subrequests?: number;
  /** Wall-clock time limit in milliseconds (default: 60000ms) */
  wallTimeMs?: number;
}
/**
 * Storage interface for loading plugin code.
 * Could be R2, local filesystem, or any other storage backend.
 */
interface PluginCodeStorage {
  /** Get plugin bundle code by path */
  get(path: string): Promise<string | null>;
  /** Check if a bundle exists */
  exists(path: string): Promise<boolean>;
}
/**
 * Serialized email message for sandbox RPC transport.
 * Matches the core EmailMessage type but uses only serializable fields.
 */
interface SandboxEmailMessage {
  to: string;
  subject: string;
  text: string;
  html?: string;
}
/**
 * Callback for sending email from a sandboxed plugin.
 * The sandbox runner wires this up from the EmailPipeline.
 *
 * @param message - The email message to send
 * @param pluginId - The sending plugin's ID (used as source)
 */
type SandboxEmailSendCallback = (message: SandboxEmailMessage, pluginId: string) => Promise<void>;
/**
 * Options for creating a sandbox runner
 */
interface SandboxOptions {
  /** Storage interface for loading plugin code */
  storage?: PluginCodeStorage;
  /** Database for bridge operations */
  db: Kysely<Database>;
  /** Called immediately before a sandboxed plugin content mutation. */
  beforeContentWrite?: () => Promise<void>;
  /** Default resource limits */
  limits?: ResourceLimits;
  /** Site info for plugin context (injected into wrapper at generation time) */
  siteInfo?: {
    name: string;
    url: string;
    locale: string;
    trailingSlash?: "always" | "never" | "ignore";
  };
  /** Email send callback, wired from the EmailPipeline by the runtime */
  emailSend?: SandboxEmailSendCallback;
  /**
   * Media storage adapter for sandboxed plugin uploads and deletes.
   * When provided, plugins with write:media can upload and delete files
   * via ctx.media.upload() and ctx.media.delete().
   */
  mediaStorage?: {
    upload(options: {
      key: string;
      body: Uint8Array;
      contentType: string;
    }): Promise<unknown>;
    delete(key: string): Promise<unknown>;
  };
}
/**
 * Handle to a sandboxed plugin running inside an isolate. Returned
 * by `SandboxRunner.load` and held by the runtime's cache so hooks /
 * routes can be invoked across the isolate boundary. Distinct from
 * the author-facing `SandboxedPlugin` type in `emdash/plugin`, which
 * describes the source-level shape of a plugin's default export.
 */
interface SandboxedPluginInstance {
  /** Unique identifier: `${manifest.id}:${manifest.version}` */
  readonly id: string;
  /**
   * Invoke a hook in the sandboxed plugin.
   *
   * @param hookName - Name of the hook (e.g., "content:beforeSave")
   * @param event - Event data to pass to the hook
   * @returns Hook result (transformed content, void, etc.)
   */
  invokeHook(hookName: string, event: unknown): Promise<unknown>;
  /**
   * Invoke an API route in the sandboxed plugin.
   *
   * @param routeName - Name of the route
   * @param input - Validated input data
   * @param request - Serialized request info for context
   * @returns Route response data
   */
  invokeRoute(routeName: string, input: unknown, request: SerializedRequest): Promise<unknown>;
  /**
   * Terminate the sandboxed plugin.
   * Releases resources and prevents further invocations.
   */
  terminate(): Promise<void>;
}
/**
 * Serialized request for RPC transport.
 * Worker Loader can't pass Request objects directly.
 */
interface SerializedRequest {
  url: string;
  method: string;
  headers: Record<string, string>;
  /** Normalized request metadata extracted before RPC serialization */
  meta: RequestMeta;
  /**
   * Authenticated caller for private routes, resolved by the host before
   * dispatch. Undefined for public routes and unbound machine tokens.
   */
  user?: UserInfo;
}
declare const SANDBOX_ROUTE_ERROR_DEFINITIONS: {
  readonly MEDIA_USAGE_ACTIVATION_IN_PROGRESS: {
    readonly message: "Media usage activation is in progress";
    readonly status: 503;
  };
  readonly MEDIA_USAGE_ACTIVATION_CHECK_FAILED: {
    readonly message: "Unable to verify media usage activation state";
    readonly status: 503;
  };
};
type SandboxRouteErrorCode = keyof typeof SANDBOX_ROUTE_ERROR_DEFINITIONS;
interface SandboxRouteErrorDetails {
  code: SandboxRouteErrorCode;
  message: string;
  status: 503;
}
interface SandboxRouteErrorEnvelope {
  __emdashSandboxRouteError: true;
  error: SandboxRouteErrorDetails;
}
declare function getSandboxRouteErrorDetails(error: unknown): SandboxRouteErrorDetails | null;
declare function createSandboxRouteError(code: SandboxRouteErrorCode): Error & SandboxRouteErrorDetails;
declare function createSandboxRouteErrorEnvelope(error: unknown): SandboxRouteErrorEnvelope | null;
declare function getSandboxRouteErrorEnvelope(value: unknown): SandboxRouteErrorEnvelope | null;
/**
 * Sandbox runner interface.
 * Platform adapters implement this to provide plugin isolation.
 */
interface SandboxRunner {
  /**
   * Check if sandboxing is available on this platform.
   * Returns false for platforms that don't support isolation.
   */
  isAvailable(): boolean;
  /**
   * Check if the sandbox runtime is currently healthy.
   * For in-process runners this always returns true.
   * For sidecar-based runners (workerd), returns false if the
   * child process has crashed and hasn't been restarted yet.
   */
  isHealthy(): boolean;
  /**
   * Load a sandboxed plugin from code.
   *
   * @param manifest - Plugin manifest with metadata and capabilities
   * @param code - The bundled plugin JavaScript code
   * @returns A sandboxed plugin instance
   * @throws If sandboxing is not available or plugin can't be loaded
   */
  load(manifest: PluginManifest, code: string): Promise<SandboxedPluginInstance>;
  /**
   * Set the email send callback for sandboxed plugins.
   * Called after the EmailPipeline is created, since the pipeline
   * doesn't exist when the sandbox runner is constructed.
   */
  setEmailSend(callback: SandboxEmailSendCallback | null): void;
  /**
   * Terminate all loaded sandboxed plugins.
   * Called during shutdown or when reconfiguring.
   */
  terminateAll(): Promise<void>;
}
/**
 * Error thrown when the sandbox runtime is unavailable.
 * This happens when the sidecar process has crashed or hasn't started.
 */
declare class SandboxUnavailableError extends Error {
  constructor(pluginId: string, reason: string);
}
/**
 * Factory function type for creating sandbox runners.
 * Exported by platform adapters (e.g., @premium-cms/adapter-cloudflare/sandbox).
 *
 * @example
 * ```typescript
 * // In @premium-cms/adapter-cloudflare/sandbox.ts
 * export const createSandboxRunner: SandboxRunnerFactory = (options) => {
 *   return new CloudflareSandboxRunner(options);
 * };
 * ```
 */
type SandboxRunnerFactory = (options: SandboxOptions) => SandboxRunner;
//#endregion
//#region src/plugins/cron.d.ts
/**
 * Callback to invoke a plugin's cron hook.
 * Provided by PluginManager so CronExecutor stays decoupled from the hook pipeline.
 */
type InvokeCronHookFn = (pluginId: string, event: CronEvent) => Promise<void>;
/**
 * Callback to notify the scheduler that the next due time may have changed.
 */
type RescheduleFn = () => void;
/**
 * Executes overdue cron tasks.
 *
 * Called by the platform driver: the NodeCronScheduler timer on Node, or the
 * Worker's `scheduled()` handler (via runScheduledTasks) on Cloudflare.
 * Stateless — all state lives in the database.
 */
declare class CronExecutor {
  private invokeCronHook;
  /**
   * Resolves the database connection to use for this tick. A resolver (not a
   * captured instance) so connection-backed adapters work across events: on
   * Cloudflare the `scheduled()` handler installs an event-scoped connection
   * in ALS, and this resolves to it instead of the per-isolate singleton
   * whose socket belongs to an earlier request. Accepts a plain `Kysely` too
   * (wrapped in a constant resolver) for callers/tests that don't need ALS.
   */
  private readonly resolveDb;
  constructor(db: Kysely<Database> | (() => Kysely<Database>), invokeCronHook: InvokeCronHookFn);
  private get db();
  /**
   * Process all overdue tasks.
   *
   * 1. Atomically claim tasks whose next_run_at <= now, status = idle, enabled = 1.
   * 2. For each claimed task, invoke the plugin's cron hook.
   * 3. On success: compute next_run_at and reset to idle, or delete one-shots.
   * 4. On failure: reset to idle (retry on next tick).
   */
  tick(): Promise<number>;
  /**
   * Recover tasks stuck in 'running' for more than STALE_LOCK_MINUTES.
   * These likely crashed mid-execution.
   */
  recoverStaleLocks(): Promise<number>;
  /**
   * Get the next due time across all enabled tasks.
   * Returns null if no tasks are scheduled.
   */
  getNextDueTime(): Promise<string | null>;
}
/**
 * Per-plugin cron API implementation.
 * Scoped to a single plugin ID — plugins cannot see or modify other plugins' tasks.
 */
declare class CronAccessImpl implements CronAccess {
  private db;
  private pluginId;
  private reschedule;
  constructor(db: Kysely<Database>, pluginId: string, reschedule: RescheduleFn);
  schedule(name: string, opts: {
    schedule: string;
    data?: Record<string, unknown>;
  }): Promise<void>;
  cancel(name: string): Promise<void>;
  list(): Promise<CronTaskInfo[]>;
}
//#endregion
//#region src/plugins/context.d.ts
/**
 * Create HTTP access with host validation.
 *
 * Uses redirect: "manual" to re-validate each redirect target against
 * the allowedHosts list, preventing redirects to unauthorized hosts.
 */
declare function createHttpAccess(pluginId: string, allowedHosts: string[]): HttpAccess;
/**
 * Create unrestricted HTTP access (for plugins with network:fetch:any capability).
 * No host validation, but applies SSRF protection on redirect targets to
 * prevent plugins from being tricked into reaching internal services.
 */
declare function createUnrestrictedHttpAccess(pluginId: string): HttpAccess;
/**
 * Options for creating site info
 */
interface SiteInfoOptions {
  /** Site name from options table */
  siteName?: string;
  /** Site URL from options table or Astro config */
  siteUrl?: string;
  /** The site's platform origin (`custom_domain:default_url`), when hosted by a control plane. */
  platformUrl?: string;
  /** Site locale from options table */
  locale?: string;
  /** Astro's `trailingSlash` config (from `virtual:emdash/config`). */
  trailingSlash?: "always" | "never" | "ignore";
}
interface PluginContextFactoryOptions {
  db: Kysely<Database>;
  beforeContentWrite?: () => Promise<void>;
  /**
   * Resolver for the database connection, preferred over `db` when present.
   * Called per `createContext()` so connection-backed adapters (e.g. Postgres
   * over Hyperdrive) get the current request/event-scoped connection from ALS
   * rather than a snapshot of the per-isolate singleton — reusing the
   * singleton's socket from a later event trips workerd's cross-request I/O
   * guard. When omitted, `db` is used directly (correct for stateless
   * adapters like D1 and Node SQLite). `db` remains required as the fallback.
   */
  getDb?: () => Kysely<Database>;
  /**
   * Storage backend for direct media uploads.
   * If not provided, upload() will throw.
   */
  storage?: Storage;
  /**
   * Explicit provider for `ctx.media.getUploadUrl()`. Optional: when omitted
   * but `storage` is configured, the factory derives a working `getUploadUrl()`
   * (and `upload()`) from storage. Only when neither `getUploadUrl` nor
   * `storage` is present do media write operations become unavailable.
   */
  getUploadUrl?: (filename: string, contentType: string) => Promise<{
    uploadUrl: string;
    mediaId: string;
  }>;
  /**
   * Site information for ctx.site and ctx.url().
   * If not provided, site info will have empty defaults.
   */
  siteInfo?: SiteInfoOptions;
  /**
   * Callback to notify the cron scheduler that the next due time may have changed.
   * If not provided, ctx.cron will not be available.
   */
  cronReschedule?: () => void;
  /**
   * Email pipeline instance for ctx.email.
   * If not provided (or no provider configured), ctx.email will be undefined.
   */
  emailPipeline?: EmailPipeline;
  /**
   * Pre-resolved list of trusted proxy header names (from the runtime
   * `EmDashConfig.trustedProxyHeaders` or the env var). Plugin route
   * handlers pass this to `extractRequestMeta` so plugins see the same
   * client IP the core auth path does.
   */
  trustedProxyHeaders?: string[];
}
//#endregion
//#region src/plugins/hooks.d.ts
type HookNameV2 = "plugin:install" | "plugin:activate" | "plugin:deactivate" | "plugin:uninstall" | "content:beforeSave" | "content:afterSave" | "content:beforeDelete" | "content:afterDelete" | "content:afterPublish" | "content:afterUnpublish" | "content:afterRestore" | "content:afterSchedule" | "content:afterUnschedule" | "media:beforeUpload" | "media:afterUpload" | "cron" | "email:beforeSend" | "email:deliver" | "email:afterSend" | "comment:beforeCreate" | "comment:moderate" | "comment:afterCreate" | "comment:afterModerate" | "page:metadata" | "page:fragments";
/**
 * Hook execution result
 */
interface HookResult<T> {
  success: boolean;
  value?: T;
  error?: Error;
  pluginId: string;
  duration: number;
}
/**
 * Hook pipeline for executing hooks in order
 */
declare class HookPipeline {
  private hooks;
  private pluginMap;
  private contextFactory;
  /** Stored so setContextFactory can merge incrementally. */
  private contextFactoryOptions;
  /** Hook names where at least one handler declared exclusive: true */
  private exclusiveHookNames;
  /**
   * Selected provider plugin ID for each exclusive hook.
   * Set by the PluginManager after resolution.
   */
  private exclusiveSelections;
  constructor(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions);
  /**
   * Set or update the context factory options.
   *
   * When called on a pipeline that already has a factory, the new options
   * are merged on top of the existing ones so that callers don't need to
   * repeat every field (e.g. adding `cronReschedule` without losing
   * `storage` / `getUploadUrl`).
   */
  setContextFactory(options: Partial<PluginContextFactoryOptions>): void;
  /**
   * Get context for a plugin
   */
  private getContext;
  /**
   * Get typed hooks for a specific hook name.
   * The internal map stores ResolvedHook<unknown>, but we know each name
   * maps to a specific handler type via HookHandlerMap.
   *
   * Exclusive hooks that have a selected provider are filtered out — they
   * should only run via invokeExclusiveHook(), not in the regular pipeline.
   */
  private getTypedHooks;
  /**
   * Register all hooks from plugins.
   *
   * Registers each hook name individually to preserve type safety. The
   * internal map stores ResolvedHook<unknown> since it's keyed by string,
   * but getTypedHooks() restores the correct handler type on retrieval.
   */
  private registerPlugins;
  /**
   * Maps hook names to the capability required to register them.
   *
   * Hooks not listed here have no capability requirement (e.g. lifecycle
   * hooks, cron). Any plugin declaring a listed hook without the required
   * capability will have that hook silently skipped at registration time.
   */
  private static readonly HOOK_REQUIRED_CAPABILITY;
  /**
   * Register a single plugin's hook by name
   */
  private registerPluginHook;
  /**
   * Register a single hook
   */
  private registerHook;
  /**
   * Sort hooks by priority and dependencies
   */
  private sortHooks;
  /**
   * Execute a hook with timeout
   */
  private executeWithTimeout;
  /**
   * Run plugin:install hooks
   */
  runPluginInstall(pluginId: string): Promise<HookResult<void>[]>;
  /**
   * Run plugin:activate hooks
   */
  runPluginActivate(pluginId: string): Promise<HookResult<void>[]>;
  /**
   * Run plugin:deactivate hooks
   */
  runPluginDeactivate(pluginId: string): Promise<HookResult<void>[]>;
  /**
   * Run plugin:uninstall hooks
   */
  runPluginUninstall(pluginId: string, deleteData: boolean): Promise<HookResult<void>[]>;
  private runLifecycleHook;
  /**
   * Run content:beforeSave hooks
   * Returns modified content from the pipeline
   */
  runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<{
    content: Record<string, unknown>;
    results: HookResult<Record<string, unknown>>[];
  }>;
  /**
   * Run content:afterSave hooks
   */
  runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<HookResult<void>[]>;
  /**
   * Run content:beforeDelete hooks
   * Returns whether deletion is allowed
   */
  runContentBeforeDelete(id: string, collection: string): Promise<{
    allowed: boolean;
    results: HookResult<boolean>[];
  }>;
  /**
   * Run content:afterDelete hooks
   */
  runContentAfterDelete(id: string, collection: string, permanent: boolean): Promise<HookResult<void>[]>;
  /**
   * Run content state-change hooks that all share the same event shape.
   */
  private runContentStateChangeHook;
  /**
   * Run content:afterPublish hooks (fire-and-forget).
   */
  runContentAfterPublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterUnpublish hooks (fire-and-forget).
   */
  runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterRestore hooks (fire-and-forget).
   */
  runContentAfterRestore(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterSchedule hooks (fire-and-forget).
   */
  runContentAfterSchedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterUnschedule hooks (fire-and-forget).
   */
  runContentAfterUnschedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run media:beforeUpload hooks
   */
  runMediaBeforeUpload(file: {
    name: string;
    type: string;
    size: number;
  }): Promise<{
    file: {
      name: string;
      type: string;
      size: number;
    };
    results: HookResult<{
      name: string;
      type: string;
      size: number;
    }>[];
  }>;
  /**
   * Run media:afterUpload hooks
   */
  runMediaAfterUpload(media: {
    id: string;
    filename: string;
    mimeType: string;
    size: number | null;
    url: string;
    createdAt: string;
  }): Promise<HookResult<void>[]>;
  /**
   * Invoke the cron hook for a specific plugin.
   *
   * Unlike other hooks which broadcast to all plugins, the cron hook is
   * dispatched only to the target plugin — the one that owns the task.
   */
  invokeCronHook(pluginId: string, event: CronEvent): Promise<HookResult<void>>;
  /**
   * Run email:beforeSend hooks (middleware pipeline).
   *
   * Each handler receives the message and returns a modified message or
   * `false` to cancel delivery. The pipeline chains message transformations —
   * each handler receives the output of the previous one.
   */
  runEmailBeforeSend(message: EmailMessage, source: string): Promise<{
    message: EmailMessage | false;
    results: HookResult<EmailMessage | false>[];
  }>;
  /**
   * Run email:afterSend hooks (fire-and-forget).
   *
   * Errors are logged but don't propagate — they don't affect the caller.
   */
  runEmailAfterSend(message: EmailMessage, source: string): Promise<HookResult<void>[]>;
  /**
   * Run comment:beforeCreate hooks (middleware pipeline).
   *
   * Each handler receives the event and returns a modified event or
   * `false` to reject the comment. The pipeline chains transformations —
   * each handler receives the output of the previous one.
   */
  runCommentBeforeCreate(event: CommentBeforeCreateEvent): Promise<CommentBeforeCreateEvent | false>;
  /**
   * Run comment:afterCreate hooks (fire-and-forget).
   *
   * Errors are logged but don't propagate — they don't affect the caller.
   */
  runCommentAfterCreate(event: CommentAfterCreateEvent): Promise<void>;
  /**
   * Run comment:afterModerate hooks (fire-and-forget).
   *
   * Errors are logged but don't propagate — they don't affect the caller.
   */
  runCommentAfterModerate(event: CommentAfterModerateEvent): Promise<void>;
  /**
   * Run page:metadata hooks. Each handler returns contributions that are
   * merged by the metadata collector. Errors are logged but don't propagate.
   */
  runPageMetadata(event: PageMetadataEvent): Promise<Array<{
    pluginId: string;
    contributions: PageMetadataContribution[];
  }>>;
  /**
   * Run page:fragments hooks. Only trusted plugins should be registered
   * for this hook. Errors are logged but don't propagate.
   */
  runPageFragments(event: PageFragmentEvent): Promise<Array<{
    pluginId: string;
    contributions: PageFragmentContribution[];
  }>>;
  /**
   * Check if any hooks are registered for a given name
   */
  hasHooks(name: HookNameV2): boolean;
  /**
   * Get hook count for debugging
   */
  getHookCount(name: HookNameV2): number;
  /**
   * Get all registered hook names
   */
  getRegisteredHooks(): HookNameV2[];
  /**
   * Returns hook names where at least one handler declared exclusive: true
   */
  getRegisteredExclusiveHooks(): string[];
  /**
   * Check if a hook is exclusive
   */
  isExclusiveHook(name: string): boolean;
  /**
   * Set the selected provider for an exclusive hook.
   * Called by PluginManager after resolution.
   */
  setExclusiveSelection(hookName: string, pluginId: string): void;
  /**
   * Clear the selected provider for an exclusive hook.
   */
  clearExclusiveSelection(hookName: string): void;
  /**
   * Get the selected provider for an exclusive hook (if any).
   */
  getExclusiveSelection(hookName: string): string | undefined;
  /**
   * Get all plugins that registered a handler for a given exclusive hook.
   */
  getExclusiveHookProviders(hookName: string): Array<{
    pluginId: string;
  }>;
  /**
   * Get all plugins that registered a non-exclusive handler for a given
   * hook (e.g. `email:beforeSend`, `email:afterSend`), preserving priority
   * order. Partitions with `getExclusiveHookProviders()`, which returns
   * plugins whose registration is marked `exclusive: true`.
   */
  getHookProviders(hookName: string): Array<{
    pluginId: string;
  }>;
  /**
   * Invoke an exclusive hook — dispatch only to the selected provider.
   * Returns null if no provider is selected or if the selected hook
   * is not found in the pipeline.
   *
   * This is a generic dispatch used by the email pipeline and other
   * exclusive hook consumers. The handler type is unknown — callers
   * must know the expected signature.
   *
   * Errors are isolated: a failing handler returns an error result
   * instead of propagating the exception to the caller.
   */
  invokeExclusiveHook(hookName: string, event: unknown): Promise<{
    result: unknown;
    pluginId: string;
    error?: Error;
    duration: number;
  } | null>;
}
/**
 * Create a hook pipeline from plugins
 */
declare function createHookPipeline(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions): HookPipeline;
//#endregion
//#region src/plugins/email.d.ts
/**
 * EmailPipeline orchestrates email delivery through the plugin hook system.
 *
 * The pipeline runs in three stages:
 * 1. email:beforeSend — middleware hooks that can transform or cancel messages
 * 2. email:deliver — exclusive hook dispatching to the selected provider
 * 3. email:afterSend — fire-and-forget hooks for logging/analytics
 */
declare class EmailPipeline {
  private pipeline;
  constructor(pipeline: HookPipeline);
  /**
   * Replace the underlying hook pipeline.
   *
   * Called by the runtime when rebuilding the hook pipeline after a
   * plugin is enabled or disabled, so the email pipeline dispatches
   * to the current set of active hooks.
   */
  setPipeline(pipeline: HookPipeline): void;
  /**
   * Send an email through the full pipeline.
   *
   * @param message - The email to send
   * @param source - Where the email originated ("system" for auth, plugin ID for plugins)
   * @throws EmailNotConfiguredError if no provider is selected
   * @throws EmailRecursionError if called re-entrantly from within a hook
   * @throws Error if the provider handler throws
   */
  send(message: EmailMessage, source: string): Promise<void>;
  /**
   * Inner send implementation, separated from the recursion guard.
   */
  private sendInner;
  /**
   * Check if an email provider is configured and available.
   *
   * Returns true if an email:deliver provider is selected in the exclusive
   * hook system. Plugins and auth code use this to decide whether to show
   * "send invite" vs "copy invite link" UI.
   */
  isAvailable(): boolean;
}
//#endregion
//#region src/plugins/routes.d.ts
/**
 * Route metadata (public flag) without the handler.
 * Used by the catch-all route to decide auth before dispatch.
 */
interface RouteMeta {
  public: boolean;
  permission?: string;
  /**
   * Cache-Control value for successful GET responses. Only ever set for
   * public routes — authenticated responses must stay `private, no-store`.
   */
  cacheControl?: string;
}
/**
 * Result from a route invocation
 */
interface RouteResult<T = unknown> {
  success: boolean;
  data?: T;
  error?: {
    code: string;
    message: string;
    details?: unknown;
  };
  status: number;
}
/**
 * Host-side user shape accepted when dispatching a plugin route. Structurally
 * matches `User` from `@premium-cms/auth` so hosts can pass `locals.user`
 * directly without the plugin layer depending on the auth package.
 */
interface RouteCallerInput {
  id: string;
  email: string;
  name: string | null;
  role: number;
  roleId?: string | null;
  createdAt: Date | string;
  tokenAuth?: boolean;
}
/**
 * Route invocation options
 */
interface InvokeRouteOptions {
  /** The original request */
  request: Request;
  /** Request body (already parsed) */
  body?: unknown;
  /**
   * Authenticated caller resolved by the host, exposed to the handler as
   * `ctx.user`. Undefined for public routes and unbound machine tokens.
   */
  user?: UserInfo;
}
/**
 * Error class for plugin routes
 * Allows plugins to return structured errors with specific HTTP status codes
 */
declare class PluginRouteError extends Error {
  code: string;
  status: number;
  details?: unknown | undefined;
  constructor(code: string, message: string, status?: number, details?: unknown | undefined);
  /**
   * Create a bad request error (400)
   */
  static badRequest(message: string, details?: unknown): PluginRouteError;
  /**
   * Create an unauthorized error (401)
   */
  static unauthorized(message?: string): PluginRouteError;
  /**
   * Create a forbidden error (403)
   */
  static forbidden(message?: string): PluginRouteError;
  /**
   * Create a not found error (404)
   */
  static notFound(message?: string): PluginRouteError;
  /**
   * Create a conflict error (409)
   */
  static conflict(message: string, details?: unknown): PluginRouteError;
  /**
   * Create an internal error (500)
   */
  static internal(message?: string): PluginRouteError;
}
//#endregion
//#region src/plugins/scheduler/types.d.ts
/**
 * Platform-specific cron scheduler interface.
 *
 * Schedulers are responsible for calling CronExecutor.tick() at the right
 * time. The executor handles all business logic; the scheduler only manages
 * timing.
 *
 * Implementations receive the CronExecutor via constructor.
 *
 */
interface CronScheduler {
  /** Start the scheduler. */
  start(): void | Promise<void>;
  /** Stop the scheduler and clean up timers/alarms. */
  stop(): void | Promise<void>;
  /** Signal that the next due time may have changed (task added/cancelled). */
  reschedule(): void;
  /** Register a system cleanup function to run alongside each tick. */
  setSystemCleanup(fn: SystemCleanupFn): void;
  /** Register bounded Media Usage maintenance to run after the general tick settles. */
  setMediaUsageMaintenance?(fn: SystemCleanupFn): void;
}
/**
 * System cleanup callback invoked alongside each scheduler tick.
 * Fire-and-forget -- failures are logged internally and never propagate.
 */
type SystemCleanupFn = () => Promise<void>;
//#endregion
//#region src/scheduled-publish.d.ts
/** A content item that was promoted to published by a sweep. */
interface PublishedRef {
  collection: string;
  id: string;
}
//#endregion
//#region src/emdash-runtime.d.ts
/** Combined result from a single-pass page contribution collection */
interface PageContributions {
  metadata: PageMetadataContribution[];
  fragments: PageFragmentContribution[];
}
/**
 * Sandboxed plugin entry from virtual module
 */
interface SandboxedPluginEntry {
  id: string;
  version: string;
  options: Record<string, unknown>;
  code: string;
  /** Capabilities the plugin requests */
  capabilities: PluginCapability[];
  /** Allowed hosts for network:fetch */
  allowedHosts: string[];
  /** Declared storage collections */
  storage: PluginStorageConfig;
  /** Serialized MCP declarations emitted at plugin build time. */
  mcp?: PluginMcpManifestConfig;
  /** Route declarations (name + public/permission/cacheControl), used for route auth decisions */
  routes?: PluginManifest["routes"];
  /** Hook declarations this plugin implements */
  hooks?: PluginManifest["hooks"];
  /** Admin pages */
  adminPages?: Array<{
    path: string;
    label?: string;
    icon?: string;
  }>;
  /** Dashboard widgets */
  adminWidgets?: Array<{
    id: string;
    title?: string;
    size?: string;
  }>;
  /** Settings schema for the auto-generated admin settings form */
  settingsSchema?: Record<string, SettingField>;
  /** Portable Text block types contributed to the editor (declarative Block Kit) */
  portableTextBlocks?: PortableTextBlockConfig[];
  /** Field widget types contributed for schema-field editing UIs */
  fieldWidgets?: FieldWidgetConfig[];
  /** Admin entry module */
  adminEntry?: string;
  /**
   * Exclusive hooks this plugin should be auto-selected for.
   * Weaker than an existing admin DB selection — config order wins when no selection exists.
   */
  preferred?: string[];
}
/**
 * Media provider entry from virtual module
 */
interface MediaProviderEntry {
  id: string;
  name: string;
  icon?: string;
  capabilities: MediaProviderCapabilities;
  /** Factory function to create the provider instance */
  createProvider: (ctx: MediaProviderContext) => MediaProvider;
}
/**
 * Context passed to media provider factory functions
 */
interface MediaProviderContext {
  db: Kysely<Database>;
  /**
   * Resolver for the live connection, preferred over `db` by providers that
   * query EmDash's database. Resolves the current request/event-scoped
   * connection from ALS so connection-backed adapters (Postgres over
   * Hyperdrive) don't reuse the per-isolate singleton's socket across events.
   * Providers should resolve per operation rather than capturing `db` once.
   * Omitted-safe: falls back to `db` for stateless adapters (D1, Node SQLite).
   */
  getDb?: () => Kysely<Database>;
  storage: Storage | null;
}
/**
 * Builds the timer-based scheduler that drives cron ticks and maintenance.
 * Injected via `virtual:emdash/scheduler` so the platform — not core — decides
 * whether a long-lived heartbeat exists.
 */
type CreateSchedulerFn = (executor: CronExecutor) => CronScheduler;
/**
 * Dependencies injected from virtual modules (middleware reads these)
 */
interface RuntimeDependencies {
  config: EmDashConfig;
  /** Effective migration mode, resolved once by the runtime entrypoint. */
  migrationMode?: RuntimeMigrationMode;
  plugins: ResolvedPlugin[];
  createDialect: (config: any) => Dialect;
  /**
   * Factory for a dialect that batches same-turn reads into one round trip
   * ({@link EmDashRuntime.create} uses it for the cold-start read phase).
   * Present only on batching backends (D1, DO); absent backends fall back to
   * the singleton. Returns a fresh connection each call — it must never be the
   * long-lived singleton, whose coalescing buffer would be shared across
   * requests.
   */
  createCoalescingDialect?: (config: any) => Dialect | null;
  createStorage: ((config: any) => Storage) | null;
  sandboxEnabled: boolean;
  /** sandbox: false escape hatch - load sandboxed plugins in-process */
  sandboxBypassed?: boolean;
  /**
   * Factory for the timer-based cron/maintenance heartbeat. Supplied by the
   * generated `virtual:emdash/scheduler` module: a `NodeCronScheduler` factory
   * on long-lived runtimes (Node/Bun), or `null` on serverless adapters where
   * an external driver (e.g. the Cloudflare Worker's `scheduled()` Cron
   * Trigger) calls `runScheduledTasks()` instead. When absent or null, the
   * runtime starts no scheduler. Keeping the platform decision in the
   * integration means core has no adapter-specific runtime checks.
   */
  createScheduler?: CreateSchedulerFn | null;
  /** Media provider entries from virtual module */
  mediaProviderEntries?: MediaProviderEntry[];
  sandboxedPluginEntries: SandboxedPluginEntry[];
  /** Factory function supplied by the active platform adapter. */
  createSandboxRunner: SandboxRunnerFactory | null;
}
/**
 * Constructor parameters for `EmDashRuntime`.
 *
 * Production code should use `EmDashRuntime.create()` which discovers and
 * loads all parts (database, plugins, hooks, cron, etc.) and then calls the
 * constructor. Direct construction is supported for callers that already
 * have all the dependencies in hand — for example, integration tests that
 * supply a pre-migrated database and an empty plugin set.
 *
 * Every field corresponds 1:1 to internal state set on the runtime — none of
 * these are derived. If you don't have a value for one, see what `create()`
 * passes for that field as the canonical default.
 */
interface EmDashRuntimeParts {
  db: Kysely<Database>;
  storage: Storage | null;
  configuredPlugins: ResolvedPlugin[];
  sandboxedPlugins: Map<string, SandboxedPluginInstance>;
  sandboxedPluginEntries: SandboxedPluginEntry[];
  hooks: HookPipeline;
  enabledPlugins: Set<string>;
  pluginStates: Map<string, string>;
  config: EmDashConfig;
  mediaProviders: Map<string, MediaProvider>;
  mediaProviderEntries: MediaProviderEntry[];
  cronExecutor: CronExecutor | null;
  cronScheduler: CronScheduler | null;
  emailPipeline: EmailPipeline | null;
  allPipelinePlugins: ResolvedPlugin[];
  pipelineFactoryOptions: {
    db: Kysely<Database>;
    getDb?: () => Kysely<Database>;
    beforeContentWrite?: () => Promise<void>;
    storage?: Storage;
    siteInfo?: {
      siteName?: string;
      siteUrl?: string;
      platformUrl?: string;
      locale?: string;
      trailingSlash?: "always" | "never" | "ignore";
    };
  };
  runtimeDeps: RuntimeDependencies;
  pipelineRef: {
    current: HookPipeline;
  };
}
type MediaUsageMaintenanceTaskClass = "entry_work" | "collection_deletion" | "reconciliation";
type MediaUsageMaintenanceResult = {
  outcome: "inactive" | "admission_closed";
  taskClass: null;
  turn: null;
} | {
  outcome: "processed";
  taskClass: MediaUsageMaintenanceTaskClass;
  turn: number;
};
/**
 * EmDashRuntime - singleton per worker
 */
declare class EmDashRuntime {
  /**
   * The singleton database instance (worker-lifetime cached).
   * Use the `db` getter instead — it checks the request context first
   * for per-request overrides (D1 read replica sessions, DO multi-site).
   */
  private readonly _db;
  readonly storage: Storage | null;
  readonly configuredPlugins: ResolvedPlugin[];
  readonly sandboxedPlugins: Map<string, SandboxedPluginInstance>;
  readonly sandboxedPluginEntries: SandboxedPluginEntry[];
  /**
   * Schema registry bound to the current request/event-scoped connection.
   * Built per access (SchemaRegistry just wraps a db) against `this.db`, the
   * ALS-aware getter — never a captured snapshot of the singleton. On a
   * connection-backed adapter (Postgres over Hyperdrive) a captured singleton
   * would query a socket opened by an earlier event and trip workerd's
   * cross-request I/O guard; the catch in handlers like handleContentUpdate
   * would then silently treat a revision-enabled collection as non-revisioned
   * and write draft edits to live columns. Same reasoning as the per-call
   * registry in _buildManifest().
   */
  get schemaRegistry(): SchemaRegistry;
  private _hooks;
  readonly config: EmDashConfig;
  readonly mediaProviders: Map<string, MediaProvider>;
  readonly mediaProviderEntries: MediaProviderEntry[];
  readonly cronExecutor: CronExecutor | null;
  readonly email: EmailPipeline | null;
  private cronScheduler;
  private enabledPlugins;
  private pluginStates;
  /**
   * Isolate-lifetime guard so FTS indexes are verified at most once per
   * worker rather than on every admin request. See ensureSearchHealthy().
   * Uses the poison-immune single-flight cache (never a shared awaitable
   * promise) so a cancelled first caller can't wedge later ones.
   */
  private readonly _searchHealthCache;
  /** Current hook pipeline. Use the `hooks` getter for external access. */
  get hooks(): HookPipeline;
  /** All plugins eligible for the hook pipeline (includes built-in plugins).
   *  Stored so we can rebuild the pipeline when plugins are enabled/disabled. */
  private allPipelinePlugins;
  /** Guards the once-per-process plugin storage-index sync. */
  private storageIndexesSynced;
  /** Factory options for the hook pipeline context factory */
  private pipelineFactoryOptions;
  /** Dependencies needed for exclusive hook resolution */
  private runtimeDeps;
  /** Mutable ref for the cron invokeCronHook closure to read the current pipeline */
  private pipelineRef;
  /**
   * Get the database instance for the current request.
   *
   * Checks the ALS-based request context first — middleware sets a
   * per-request Kysely instance there for D1 read replica sessions
   * or DO preview databases. Falls back to the singleton instance.
   */
  get db(): Kysely<Database>;
  constructor(parts: EmDashRuntimeParts);
  /**
   * Get the sandbox runner instance (for marketplace install/update)
   */
  getSandboxRunner(): SandboxRunner | null;
  /**
   * Whether the sandbox bypass mode (sandbox: false) is active.
   * Marketplace install/update handlers use this to skip the
   * SANDBOX_NOT_AVAILABLE gate, since the bypass path loads
   * marketplace plugins in-process via syncMarketplacePlugins().
   */
  isSandboxBypassed(): boolean;
  /**
   * Publish any content whose scheduled time has passed.
   * Returns the items promoted so callers can invalidate their cache tags.
   */
  publishScheduled(): Promise<PublishedRef[]>;
  private publishScheduledWithFence;
  /**
   * Run the full scheduled-maintenance batch: cron tasks, scheduled
   * publishing, and system cleanup. For request-less drivers — the
   * Cloudflare `scheduled()` handler invokes this from a Cron Trigger.
   * (On Node the timer-based scheduler drives the same work itself.)
   *
   * Each step is independent and non-fatal. Returns the content promoted
   * by the publishing sweep so the caller can purge edge-cache tags.
   *
   * `onPublished` (optional) is awaited after each collection's batch so a
   * request-less driver can invalidate edge-cache tags incrementally rather
   * than only after the whole sweep — bounding stale-cache exposure if the
   * runtime is killed mid-sweep.
   */
  runScheduledTasks(options?: {
    onPublished?: (refs: PublishedRef[]) => Promise<void>;
  }): Promise<{
    published: PublishedRef[];
  }>;
  runScheduledMediaUsageTasks(): Promise<MediaUsageMaintenanceResult>;
  /**
   * Materialize plugin-declared storage indexes, once per process.
   *
   * Called from the scheduler path, not from request handlers — configured
   * plugins have no install handler, so the tick is their only sync moment.
   */
  syncPluginStorageIndexesOnce(): Promise<void>;
  /**
   * Stop the cron scheduler gracefully.
   * Call during worker shutdown or hot-reload.
   */
  stopCron(): Promise<void>;
  /**
   * Update in-memory plugin status and rebuild the hook pipeline.
   *
   * Rebuilding the pipeline ensures disabled plugins' hooks stop firing
   * and re-enabled plugins' hooks start firing again without a restart.
   * Exclusive hook selections are re-resolved after each rebuild.
   */
  setPluginStatus(pluginId: string, status: "active" | "inactive"): Promise<void>;
  /**
   * Rebuild the hook pipeline from the current set of enabled plugins.
   *
   * Filters `allPipelinePlugins` to only those in `enabledPlugins`,
   * creates a fresh HookPipeline, re-resolves exclusive hook selections,
   * and re-wires the context factory so existing references (cron
   * callbacks, email pipeline) use the new pipeline.
   */
  private rebuildHookPipeline;
  /**
   * Synchronize marketplace plugin runtime state with DB + storage.
   *
   * Ensures install/update/uninstall changes take effect immediately in the
   * current worker: loads newly active plugins and removes uninstalled ones.
   */
  /** When this isolate last reconciled its loaded plugins with `plugin_state` (see `resyncPluginsIfStale`). */
  private pluginSyncAt;
  /**
   * Plugins change in ONE isolate: the install / update / enable / uninstall
   * route calls `syncMarketplacePlugins()` there, and every other isolate of the
   * worker (other colos, other instances) keeps serving the build it loaded at
   * start until it is recycled — which can take hours on a quiet site. Request
   * handling calls this instead: at most once per `maxAgeMs` per isolate it
   * re-reads `plugin_state` (one small query) and loads what changed, so a
   * plugin update reaches every isolate within the window.
   */
  resyncPluginsIfStale(maxAgeMs?: number): Promise<void>;
  syncMarketplacePlugins(): Promise<void>;
  /**
   * Synchronize registry plugin runtime state with DB + storage.
   *
   * Mirrors {@link syncMarketplacePlugins} for plugins installed via the
   * experimental decentralized plugin registry. Called after install,
   * update, and uninstall handlers complete.
   */
  syncRegistryPlugins(): Promise<void>;
  /**
   * Internal: reconcile in-memory sandboxed-plugin state with the
   * `_plugin_state` table for the given source tier. Shared
   * implementation behind {@link syncMarketplacePlugins} and
   * {@link syncRegistryPlugins}.
   *
   * Each source tier has its own key set in `${source}PluginKeys` so a
   * sync for one tier doesn't invalidate the other.
   */
  private syncSandboxedSourcePlugins;
  /**
   * Remove a plugin from the in-memory pipeline lists by ID.
   * Mutates allPipelinePlugins and configuredPlugins in place.
   */
  private removePluginFromLists;
  /**
   * Sync marketplace plugin metadata in sandbox: false bypass mode.
   *
   * In bypass mode the noop runner can't load plugins, but admin pages,
   * widgets, and route metadata still need to refresh in-process when an
   * admin installs/updates/uninstalls a marketplace plugin. Otherwise the
   * admin UI shows stale data until the server restarts.
   *
   * Hooks and routes still won't execute under bypass (matches the
   * cold-start bypass behavior in loadMarketplacePluginsBypassed).
   *
   * Known limitation: bypass plugins are loaded via `import(dataUrl)`,
   * which Node's ESM cache keys on the full URL. Updates create fresh
   * module objects, but old ones remain cached for the worker's lifetime.
   * In practice this is a few KB per update — only matters for sites with
   * very frequent marketplace updates running long-lived processes. The
   * fix would be vm.SourceTextModule for explicit lifecycle management.
   */
  private syncMarketplacePluginsBypassed;
  /**
   * Create and initialize the runtime
   */
  static create(deps: RuntimeDependencies, timings?: Array<{
    name: string;
    dur: number;
    desc?: string;
  }>): Promise<EmDashRuntime>;
  /**
   * Get a media provider by ID
   */
  getMediaProvider(providerId: string): MediaProvider | undefined;
  /**
   * Get all media provider entries (for admin UI)
   */
  getMediaProviderList(): Array<{
    id: string;
    name: string;
    icon?: string;
    capabilities: MediaProviderCapabilities;
  }>;
  /**
   * Get or create database instance
   */
  private static getDatabase;
  /**
   * Get or create storage instance
   */
  private static getStorage;
  /**
   * Load sandboxed plugin entries as trusted in-process plugins.
   * Used by the sandbox: false debugging escape hatch.
   *
   * Imports each plugin's bundled ESM code via a data URL, adapts it
   * with adaptSandboxEntry, and returns ResolvedPlugin objects ready
   * to be merged into the pipeline plugin list.
   */
  private static loadBypassedPlugins;
  /**
   * Load sandboxed plugins using SandboxRunner
   */
  private static loadSandboxedPlugins;
  /**
   * Cold-start: load marketplace-installed plugins from site-local R2 storage
   *
   * Queries _plugin_state for source='marketplace' rows, fetches each bundle
   * from R2, and loads via SandboxRunner.
   */
  /**
   * Cold-start load of all active sandboxed plugins for one install
   * tier (marketplace or registry) from site-local R2.
   *
   * Mirrors {@link syncSandboxedSourcePlugins} but runs once at runtime
   * creation, before request traffic arrives; the sync method runs on
   * demand after install / update / uninstall handlers.
   */
  private static loadInstalledSandboxedPlugins;
  /**
   * Cold-start: load marketplace plugins in bypass mode (sandbox: false).
   *
   * Each active marketplace bundle is read, evaluated via data URL, adapted
   * with adaptSandboxEntry, and returned as a ResolvedPlugin. The caller is
   * responsible for merging these into allPipelinePlugins / configuredPlugins
   * BEFORE the hook pipeline is created, so hooks and routes register in
   * the trusted pipeline.
   *
   * Also caches manifest and route metadata so admin UI / getManifest() work.
   *
   * Returns ResolvedPlugins to be merged into the pipeline.
   */
  private static loadMarketplacePluginsBypassed;
  /**
   * Resolve exclusive hook selections on startup.
   *
   * Delegates to the shared resolveExclusiveHooks() in hooks.ts.
   * The runtime version considers all pipeline providers as "active" since
   * the pipeline was already built from only active/enabled plugins.
   */
  private static resolveExclusiveHooks;
  /**
   * Build the admin manifest from the live database.
   *
   * Used by the admin UI (sidebar collections, content editor field
   * dispatch, manifest endpoint) and by WordPress import — it's never
   * read on a public request, so this isn't on any anonymous hot path.
   *
   * No cross-request cache. The previous worker-isolate cache produced
   * a class of cross-isolate staleness bugs (#776, #873, #876, #877)
   * because Cloudflare Workers keeps multiple warm isolates per region
   * and there's no fan-out primitive to invalidate them in step. The
   * cache existed to amortize an N+1 schema query pattern; now that
   * `listCollectionsWithFields()` does the same work in two queries,
   * the rebuild is fast enough to pay on every admin request.
   *
   * Within a single request, `requestCached` deduplicates concurrent
   * callers (the manifest endpoint and an admin SSR template, say).
   */
  getManifest(): Promise<EmDashManifest>;
  /**
   * Build the manifest from the database.
   *
   * Constant query shapes via `listCollectionsWithFields()` — one query
   * for collections, one batched query for fields (chunked at
   * `SQL_BATCH_SIZE` collection IDs to stay under D1's bound-parameter
   * limit). Typical sites stay well under the chunk threshold, so this
   * is two queries in practice; never N+1.
   */
  private _buildManifest;
  /**
   * Verify and repair FTS indexes on demand. Runs at most once per worker
   * lifetime.
   *
   * Originally called from `EmDashRuntime.create()`, but on a busy D1 link
   * (e.g. SIN replica ~80-150ms per query) it added ~1.5s to every cold
   * start for a modest-sized site — more than every other init phase
   * combined. Anonymous public reads never touch the search write path,
   * so the cost isn't paid back for the vast majority of requests.
   *
   * Instead, search endpoints call this lazily: the first request that
   * actually needs the index pays the verify cost (usually fast — no
   * rebuild needed), everyone else runs cold-free.
   *
   * Uses the runtime's singleton database (`this._db`) rather than the
   * request-scoped DB. Verify reads only, but `rebuildIndex` writes, and
   * a GET search request on D1 carries a `first-unconstrained` session
   * that's free to route at a read replica — unsafe for writes. The
   * singleton always goes through the default binding, which the D1
   * adapter will promote to `first-primary` for write statements.
   *
   * Safe to call concurrently: repeated callers share the same in-flight
   * promise. Errors are swallowed internally so callers don't need to
   * defend against FTS not existing yet (pre-setup).
   */
  ensureSearchHealthy(): Promise<void>;
  /**
   * The git-backed store for a collection whose entries live in the site's
   * repo (`storage: "git"`), or null for database collections. Throws when
   * the collection is git-backed but GitHub isn't connected yet.
   */
  private gitStoreFor;
  private gitError;
  handleContentList(collection: string, params: {
    cursor?: string;
    limit?: number;
    status?: string;
    orderBy?: string;
    order?: "asc" | "desc";
    locale?: string;
    q?: string;
    authorId?: string;
    dateField?: ContentDateField;
    dateFrom?: string;
    dateTo?: string;
    bylines?: string[];
    bylinesNone?: boolean;
    includeInferredBylines?: boolean;
    fieldFilters?: ContentFieldFilters;
  }): Promise<{
    success: false;
    error: {
      code: string;
      message: string;
    };
  } | {
    success: true;
    data: ContentListResponse;
  } | {
    success: true;
    data: {
      items: ContentItem$1[];
      nextCursor: undefined;
      total: number;
    };
  }>;
  handleContentAuthors(collection: string): Promise<ApiResult<{
    items: ContentAuthor[];
  }>>;
  handleContentGet(collection: string, id: string, locale?: string): Promise<{
    success: false;
    error: {
      code: string;
      message: string;
    };
  } | {
    success: true;
    data: ContentResponse;
  } | {
    success: true;
    data: {
      item: ContentItem$1;
      _rev: string;
    };
  }>;
  handleContentGetIncludingTrashed(collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
  /**
   * If the response item has a `draftRevisionId`, replace `item.data` with
   * the draft revision's data and expose the original published values as
   * `liveData`. This makes the content_get / content_update round-trip
   * intuitive — read returns the latest content the caller has saved
   * (their pending draft), with the previously-published values still
   * accessible for compare-style flows.
   *
   * No-op when no draft exists or the response is an error.
   */
  private hydrateDraftData;
  handleContentCreate(collection: string, body: {
    data: Record<string, unknown>;
    slug?: string | null;
    status?: string;
    authorId?: string;
    bylines?: Array<{
      bylineId: string;
      roleLabel?: string | null;
    }>;
    locale?: string;
    translationOf?: string;
    taxonomies?: Record<string, string[]>;
  }): Promise<{
    success: false;
    error: {
      code: string;
      message: string;
    };
  } | {
    success: true;
    data: ContentResponse;
  } | {
    success: true;
    data: {
      item: ContentItem$1;
      _rev: string;
    };
  }>;
  handleContentUpdate(collection: string, id: string, body: {
    data?: Record<string, unknown>;
    slug?: string | null;
    status?: string;
    authorId?: string | null;
    bylines?: Array<{
      bylineId: string;
      roleLabel?: string | null;
    }>;
    seo?: {
      title?: string | null;
      description?: string | null;
      image?: string | null;
      canonical?: string | null;
      noIndex?: boolean;
    };
    taxonomies?: Record<string, string[]>;
    publishedAt?: string | null;
    locale?: string; /** Replace the previous autosave revision after staging this save. */
    skipRevision?: boolean;
    _rev?: string;
  }): Promise<{
    success: false;
    error: {
      code: string;
      message: string;
    };
  } | {
    success: true;
    data: {
      item: ContentItem$1;
      _rev: string;
    };
  } | {
    liveContentChanged: boolean;
    success: true;
    data: ContentResponse;
  }>;
  handleContentDelete(collection: string, id: string): Promise<{
    success: true;
    data: {
      deleted: true;
      id: string;
    };
  } | {
    success: true;
    data: {
      deleted: boolean;
    };
    error?: undefined;
  } | {
    success: boolean;
    error: {
      code: string;
      message: string;
    };
    data?: undefined;
  }>;
  handleContentListTrashed(collection: string, params?: {
    cursor?: string;
    limit?: number;
  }): Promise<ApiResult<{
    items: TrashedContentItem[];
    nextCursor?: string;
  }>>;
  handleContentRestore(collection: string, id: string): Promise<ApiResult<{
    restored: true;
    item: ContentItem;
  }>>;
  handleContentPermanentDelete(collection: string, id: string): Promise<ApiResult<{
    deleted: true;
    id: string;
  }>>;
  handleContentCountTrashed(collection: string): Promise<ApiResult<{
    count: number;
  }>>;
  handleContentDuplicate(collection: string, id: string, authorId?: string): Promise<ApiResult<{
    item: ContentItem;
  }>>;
  handleContentPublish(collection: string, id: string, options?: {
    publishedAt?: string;
    requireScheduledDue?: boolean;
    expectedScheduledAt?: string;
  }): Promise<{
    success: false;
    error: {
      code: string;
      message: string;
    };
  } | {
    success: true;
    data: ContentResponse;
  } | {
    success: true;
    data: {
      item: ContentItem$1;
    };
  }>;
  handleContentUnpublish(collection: string, id: string): Promise<{
    success: false;
    error: {
      code: string;
      message: string;
    };
  } | {
    success: true;
    data: ContentResponse;
  } | {
    success: true;
    data: {
      item: ContentItem$1;
    };
  }>;
  handleContentSchedule(collection: string, id: string, scheduledAt: string): Promise<ApiResult<ContentResponse>>;
  handleContentUnschedule(collection: string, id: string): Promise<ApiResult<ContentResponse>>;
  handleContentCountScheduled(collection: string): Promise<ApiResult<{
    count: number;
  }>>;
  handleContentDiscardDraft(collection: string, id: string): Promise<ApiResult<ContentResponse>>;
  handleContentCompare(collection: string, id: string): Promise<ApiResult<{
    hasChanges: boolean;
    live: Record<string, unknown> | null;
    draft: Record<string, unknown> | null;
  }>>;
  handleContentTranslations(collection: string, id: string): Promise<ApiResult<{
    translationGroup: string;
    translations: Array<{
      id: string;
      locale: string | null;
      slug: string | null;
      status: string;
      updatedAt: string;
    }>;
  }>>;
  handleMediaList(params: {
    cursor?: string;
    limit?: number;
    mimeType?: string | readonly string[];
    q?: string;
  }): Promise<ApiResult<MediaListResponse>>;
  handleMediaGet(id: string): Promise<ApiResult<MediaResponse>>;
  handleMediaCreate(input: {
    filename: string;
    mimeType: string;
    size?: number;
    width?: number;
    height?: number;
    storageKey: string;
    contentHash?: string;
    blurhash?: string;
    dominantColor?: string;
    authorId?: string;
  }): Promise<ApiResult<MediaResponse>>;
  handleMediaUpdate(id: string, input: {
    alt?: string;
    caption?: string;
    width?: number;
    height?: number;
  }): Promise<ApiResult<MediaResponse>>;
  handleMediaDelete(id: string): Promise<ApiResult<{
    deleted: true;
    storageKey: string;
  }>>;
  handleRevisionList(collection: string, entryId: string, params?: {
    limit?: number;
  }): Promise<ApiResult<RevisionListResponse>>;
  handleRevisionGet(revisionId: string): Promise<ApiResult<RevisionResponse>>;
  handleRevisionRestore(revisionId: string, callerUserId: string): Promise<ApiResult<ContentResponse>>;
  private refreshContentUsageAfterSuccessfulWrite;
  private deleteContentUsageAfterSuccessfulPermanentDelete;
  /**
   * Get route metadata for a plugin route without invoking the handler.
   * Used by the catch-all route to decide auth before dispatch.
   * Returns null if the plugin or route doesn't exist.
   */
  /**
   * Every route enabled plugins expose under /_emdash/api/plugins/<id>/…,
   * with the access each one requires — the plugin half of the route
   * catalogue policies are written against.
   */
  listPluginRoutes(): Array<{
    pluginId: string;
    route: string;
    public: boolean;
    permission: string;
  }>;
  getPluginRouteMeta(pluginId: string, path: string): RouteMeta | null;
  /**
   * Resolve the settings schema for a runtime-installed (marketplace or
   * registry) plugin from its cached manifest. Returns `{}` for a known
   * plugin without a schema and `null` for unknown plugins, matching the
   * contract of `getPluginSettingsSchema` for build-time plugins.
   */
  getRuntimePluginSettingsSchema(pluginId: string): Record<string, SettingField> | null;
  handlePluginApiRoute(pluginId: string, _method: string, path: string, request: Request, user?: RouteCallerInput | null): Promise<{
    success: boolean;
    data?: unknown;
    error?: {
      code: string;
      message: string;
    };
    status?: number;
  }>;
  getPluginMcpTools(pluginId?: string): Promise<{
    pluginId: string;
    name: string;
    description: string;
    route: string;
    permission: string;
    destructive: boolean;
    inputSchema: z$1.ZodType;
    outputSchema?: z$1.ZodType;
  }[]>;
  getEnabledPluginMcpTools(): Promise<{
    pluginId: string;
    name: string;
    description: string;
    route: string;
    permission: string;
    destructive: boolean;
    inputSchema: z$1.ZodType;
    outputSchema?: z$1.ZodType;
  }[]>;
  serializePluginMcpConsent(tools: Awaited<ReturnType<EmDashRuntime["getPluginMcpTools"]>>, pluginId: string): string;
  handlePluginMcpTool(pluginId: string, toolName: string, route: string, input: unknown, actorId: string, request: Request, caller?: RouteCallerInput | null): Promise<{
    success: boolean;
    data?: unknown;
    error?: {
      code: string;
      message: string;
    };
    status?: number;
  }>;
  handlePluginMcpDenied(pluginId: string, toolName: string, route: string, actorId: string, request: Request, reason: string): Promise<void>;
  private findSandboxedPlugin;
  /**
   * Normalize image/file fields in content data.
   * Fills missing dimensions, storageKey, mimeType, and filename from providers.
   */
  private normalizeMediaFields;
  private runSandboxedBeforeSave;
  private runSandboxedBeforeDelete;
  private runAfterSaveHooks;
  private runAfterDeleteHooks;
  private runDeferredContentHook;
  private runAfterPublishHooks;
  private runAfterUnpublishHooks;
  private runAfterRestoreHooks;
  private runAfterScheduleHooks;
  private runAfterUnscheduleHooks;
  private handleSandboxedRoute;
  /**
   * Cache for page contributions. Uses a WeakMap keyed on the PublicPageContext
   * object so results are collected once per page context per request, even when
   * multiple render components (EmDashHead, EmDashBodyStart, EmDashBodyEnd)
   * request contributions from the same page.
   */
  private pageContributionCache;
  /**
   * Collect all page contributions (metadata + fragments) in a single pass.
   * Results are cached by page context object identity.
   */
  collectPageContributions(page: PublicPageContext): Promise<PageContributions>;
  private doCollectPageContributions;
  /**
   * Collect page metadata contributions from trusted and sandboxed plugins.
   * Delegates to the single-pass collector and returns the metadata portion.
   */
  collectPageMetadata(page: PublicPageContext): Promise<PageMetadataContribution[]>;
  /**
   * Collect page fragment contributions from trusted plugins only.
   * Delegates to the single-pass collector and returns the fragments portion.
   */
  collectPageFragments(page: PublicPageContext): Promise<PageFragmentContribution[]>;
  private isPluginEnabled;
}
//#endregion
//#region src/sections/types.d.ts
/**
 * Section source types
 */
type SectionSource = "theme" | "user" | "import";
/**
 * Section as returned to templates/admin
 */
interface Section {
  id: string;
  slug: string;
  title: string;
  description?: string;
  keywords: string[];
  content: PortableTextBlock$1[];
  previewUrl?: string;
  source: SectionSource;
  themeId?: string;
  createdAt: string;
  updatedAt: string;
}
/**
 * Input for creating a section
 */
interface CreateSectionInput {
  slug: string;
  title: string;
  description?: string;
  keywords?: string[];
  content: PortableTextBlock$1[];
  previewMediaId?: string;
  source?: SectionSource;
  themeId?: string;
}
/**
 * Input for updating a section
 */
interface UpdateSectionInput {
  slug?: string;
  title?: string;
  description?: string;
  keywords?: string[];
  content?: PortableTextBlock$1[];
  previewMediaId?: string | null;
}
/**
 * Options for querying sections
 */
interface GetSectionsOptions {
  /** Filter by source */
  source?: SectionSource;
  /** Search title, description, keywords */
  search?: string;
  /** Limit results */
  limit?: number;
  /** Cursor for pagination */
  cursor?: string;
}
//#endregion
//#region src/sections/index.d.ts
/**
 * Get a section by slug
 *
 * @example
 * ```ts
 * import { getSection } from "@premium-cms/emdash";
 *
 * const section = await getSection("hero-centered");
 * if (section) {
 *   console.log(section.content); // Portable Text array
 * }
 * ```
 */
declare function getSection(slug: string): Promise<Section | null>;
/**
 * Get all sections with optional filtering
 *
 * @example
 * ```ts
 * import { getSections } from "@premium-cms/emdash";
 *
 * // Get all theme-provided sections
 * const themeSections = await getSections({ source: "theme" });
 *
 * // Search sections
 * const results = await getSections({ search: "pricing" });
 * ```
 */
declare function getSections(options?: GetSectionsOptions): Promise<FindManyResult<Section>>;
//#endregion
//#region src/content/converters/types.d.ts
/**
 * Portable Text Types
 *
 * Defines the structure of Portable Text blocks used in EmDash.
 */
/**
 * Base span (inline text)
 */
interface PortableTextSpan {
  _type: "span";
  _key: string;
  text: string;
  marks?: string[];
}
/**
 * Mark definition (bold, italic, link, etc.)
 */
interface PortableTextMarkDef {
  _type: string;
  _key: string;
  [key: string]: unknown;
}
/**
 * Link mark definition
 */
interface PortableTextLinkMark extends PortableTextMarkDef {
  _type: "link";
  href: string;
  blank?: boolean;
}
/**
 * Text block (paragraph, heading, etc.)
 */
interface PortableTextTextBlock {
  _type: "block";
  _key: string;
  style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
  listItem?: "bullet" | "number";
  level?: number;
  listId?: string;
  listStart?: number;
  children: PortableTextSpan[];
  markDefs?: PortableTextMarkDef[];
  textAlign?: "left" | "center" | "right" | "justify";
}
/**
 * Image block
 */
interface PortableTextImageBlock {
  _type: "image";
  _key: string;
  asset: {
    _ref: string;
    url?: string; /** Provider ID for external media (e.g., "cloudflare-images") */
    provider?: string;
  };
  alt?: string;
  caption?: string;
  /** Original image width */
  width?: number;
  /** Original image height */
  height?: number;
  /** Display width for this instance (overrides original) */
  displayWidth?: number;
  /** Display height for this instance (overrides original) */
  displayHeight?: number;
}
/**
 * A single image inside a gallery block. Mirrors the shape produced by
 * gutenberg-to-portable-text and consumed by Gallery.astro.
 */
interface PortableTextGalleryImage {
  _type: "image";
  _key: string;
  asset: {
    /** Present on WordPress-imported galleries; always emitted on round-trip */_type?: "reference";
    _ref: string;
    url?: string; /** Provider ID for external media (e.g., "cloudflare-images") */
    provider?: string;
  };
  alt?: string;
  caption?: string;
  width?: number;
  height?: number;
  /** LQIP blurhash placeholder (images only) */
  blurhash?: string;
  /** LQIP dominant-color placeholder, as a CSS color (images only) */
  dominantColor?: string;
}
/**
 * Gallery block (grid of images with optional per-image captions)
 */
interface PortableTextGalleryBlock {
  _type: "gallery";
  _key: string;
  images: PortableTextGalleryImage[];
  columns?: number;
}
/**
 * Code block
 */
interface PortableTextCodeBlock {
  _type: "code";
  _key: string;
  code: string;
  language?: string;
  filename?: string;
}
/**
 * HTML block (raw HTML content)
 */
interface PortableTextHtmlBlock {
  _type: "htmlBlock";
  _key: string;
  html: string;
}
/**
 * Unknown/custom block (preserved for plugin compatibility)
 */
interface PortableTextUnknownBlock {
  _type: string;
  _key: string;
  [key: string]: unknown;
}
/**
 * Any Portable Text block
 */
type PortableTextBlock = PortableTextTextBlock | PortableTextImageBlock | PortableTextGalleryBlock | PortableTextCodeBlock | PortableTextHtmlBlock | PortableTextUnknownBlock;
/**
 * ProseMirror JSON types (simplified for TipTap)
 */
interface ProseMirrorMark {
  type: string;
  attrs?: Record<string, unknown>;
}
interface ProseMirrorNode {
  type: string;
  attrs?: Record<string, unknown>;
  content?: ProseMirrorNode[];
  marks?: ProseMirrorMark[];
  text?: string;
}
interface ProseMirrorDocument {
  type: "doc";
  content: ProseMirrorNode[];
}
//#endregion
//#region src/content/converters/prosemirror-to-portable-text.d.ts
/**
 * Convert ProseMirror document to Portable Text
 */
declare function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTextBlock[];
//#endregion
//#region src/content/converters/portable-text-to-prosemirror.d.ts
/**
 * Convert Portable Text to ProseMirror document
 */
declare function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMirrorDocument;
//#endregion
//#region src/utils/hash.d.ts
/**
 * SHA-256 hash of a string, truncated to 16 hex chars (64 bits).
 * For cache invalidation / ETags — not for security.
 */
declare function hashString(content: string): Promise<string>;
/**
 * Compute content hash using Web Crypto API
 *
 * Uses SHA-1 which is the fastest option in SubtleCrypto.
 * SHA-1 is cryptographically weak but fine for content deduplication
 * where we only need to detect identical files, not resist attacks.
 *
 * Returns hex string prefixed with "sha1:" for future-proofing
 */
declare function computeContentHash(content: Uint8Array | ArrayBuffer): Promise<string>;
//#endregion
//#region src/utils/url.d.ts
/**
 * URL scheme validation utilities
 *
 * Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
 * by allowlisting known-safe schemes before rendering into href attributes.
 */
/**
 * Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
 *
 * Use this at the render layer as the primary defense against XSS via
 * dangerous URL schemes like `javascript:`, `data:`, or `vbscript:`.
 *
 * @example
 * ```ts
 * sanitizeHref("https://example.com")        // "https://example.com"
 * sanitizeHref("/about")                      // "/about"
 * sanitizeHref("#section")                    // "#section"
 * sanitizeHref("mailto:a@b.com")              // "mailto:a@b.com"
 * sanitizeHref("javascript:alert(1)")         // "#"
 * sanitizeHref("data:text/html,<script>")     // "#"
 * sanitizeHref("")                            // "#"
 * ```
 */
declare function sanitizeHref(url: string | undefined | null): string;
/**
 * Returns true if the URL uses a safe scheme for rendering in href attributes.
 */
declare function isSafeHref(url: string): boolean;
//#endregion
//#region src/loader.d.ts
/**
 * Entry data type - generic object
 */
type EntryData = Record<string, unknown>;
/**
 * Sort direction
 */
type SortDirection$1 = "asc" | "desc";
/**
 * Order by specification - field name to direction
 * @example { created_at: "desc" } - Sort by created_at descending
 * @example { title: "asc" } - Sort by title ascending
 */
type OrderBySpec$1 = Record<string, SortDirection$1>;
/**
 * Range filter for comparison operators on field values.
 * Values are compared as strings in the database. This works correctly for
 * ISO 8601 dates (e.g. "2024-01-01T00:00:00Z") because lexicographic ordering
 * matches chronological ordering. Ensure date values use a consistent format.
 */
interface WhereRange {
  gt?: string;
  gte?: string;
  lt?: string;
  lte?: string;
}
/**
 * A where clause value: exact match, multi-value match, or range comparison.
 */
type WhereValue = string | string[] | WhereRange;
/**
 * Fields shared by every collection filter, independent of pagination mode.
 *
 * Cursor and offset pagination are mutually exclusive, so they live on the
 * `CursorCollectionFilter` / `OffsetCollectionFilter` variants rather than
 * here. Use the {@link CollectionFilter} union for any value that may be
 * either.
 */
interface CollectionFilterBase$1 {
  type: string;
  status?: "draft" | "published" | "archived";
  limit?: number;
  /**
   * Filter by field values, taxonomy terms, byline credits, or ranges.
   *
   * Taxonomy names are detected automatically and filtered via JOIN.
   * The reserved `byline` key filters by byline credit (any credit, not
   * just the primary one) via the `_emdash_content_bylines` junction
   * table; its value is one or more byline translation groups.
   * Other keys are treated as column filters on the content table.
   *
   * @example { category: 'news' } - taxonomy term
   * @example { byline: '01HXYZ...' } - entries credited to a byline (any position)
   * @example { series: 'main' } - exact match on a content field
   * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - date range
   */
  where?: Record<string, WhereValue>;
  /**
   * Order results by field(s)
   * @default { created_at: "desc" }
   */
  orderBy?: OrderBySpec$1;
  /**
   * Filter by locale (e.g. 'en', 'fr').
   * When set, only returns content in this locale.
   */
  locale?: string;
}
/** Keyset-paginated collection filter. Cannot also carry an `offset`. */
interface CursorCollectionFilter$1 extends CollectionFilterBase$1 {
  /**
   * Opaque cursor for keyset pagination.
   * Pass the `nextCursor` value from a previous result to fetch the next page.
   */
  cursor?: string;
  offset?: never;
}
/** Offset-paginated collection filter. Cannot also carry a `cursor`. */
interface OffsetCollectionFilter$1 extends CollectionFilterBase$1 {
  /**
   * Skip this many rows before returning results (offset pagination).
   * Use with `limit` for numbered archive routes (`/page/2`):
   * `offset = (page - 1) * perPage`. Ignored unless it is a positive
   * integer.
   */
  offset?: number;
  cursor?: never;
}
/**
 * Filter for loadCollection - type is required.
 *
 * A union of the cursor and offset pagination variants: supplying both
 * `cursor` and `offset` is a compile-time error, since they are mutually
 * exclusive ways to express "the next page" (cursor wins at runtime).
 */
type CollectionFilter$1 = CursorCollectionFilter$1 | OffsetCollectionFilter$1;
/**
 * Filter for loadEntry - type and id are required
 */
interface EntryFilter {
  type: string;
  id: string;
  /**
   * When set, fetch content data from this revision instead of the content table.
   * Used by preview mode to serve draft revision data.
   */
  revisionId?: string;
  /**
   * Locale to scope slug lookup. Only affects slug resolution;
   * IDs are globally unique and always resolve regardless of locale.
   */
  locale?: string;
}
/**
 * Get the database instance. Used by query wrapper functions and middleware.
 *
 * Checks the ALS request context first — if a per-request DB override is set
 * (e.g. by DO preview middleware), it takes precedence over the module-level
 * cached instance. This allows preview mode to route queries to an isolated
 * Durable Object database without modifying any calling code.
 *
 * Initializes the default database on first call using config from virtual module.
 */
declare function getDb(): Promise<Kysely<Database>>;
/**
 * Create an EmDash Live Collections loader
 *
 * This loader handles ALL content types in a single Astro collection.
 * Use `getEmDashCollection()` and `getEmDashEntry()` to query
 * specific content types.
 *
 * Database is configured in astro.config.mjs via the emdash() integration.
 *
 * @example
 * ```ts
 * // src/live.config.ts
 * import { defineLiveCollection } from "astro:content";
 * import { emdashLoader } from "@premium-cms/emdash";
 *
 * export const collections = {
 *   emdash: defineLiveCollection({
 *     loader: emdashLoader(),
 *   }),
 * };
 * ```
 */
declare function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFilter$1>;
//#endregion
//#region src/visual-editing/editable.d.ts
/**
 * Visual editing annotation system
 *
 * Creates Proxy objects that emit data-emdash-ref attributes when spread onto elements.
 */
interface CMSAnnotation {
  collection: string;
  id: string;
  field?: string;
  /** Entry status — only present on entry-level annotations (not field-level) */
  status?: string;
  /** Whether the entry has unpublished draft changes */
  hasDraft?: boolean;
}
/** The shape returned when spreading an edit annotation onto an element */
interface FieldAnnotation {
  "data-emdash-ref": string;
}
interface EditableOptions {
  /** Entry status: "draft", "published", "scheduled" */
  status?: string;
  /** true when draftRevisionId exists and differs from liveRevisionId */
  hasDraft?: boolean;
}
/**
 * Create an editable proxy for an entry.
 *
 * Usage:
 * - `{...entry.edit}` - entry-level annotation (includes status/hasDraft)
 * - `{...entry.edit.title}` - field-level annotation
 * - `{...entry.edit['nested.field']}` - nested field (bracket notation)
 */
declare function createEditable(collection: string, id: string, options?: EditableOptions): EditProxy;
/**
 * Create a noop proxy for production mode.
 * Spreading this produces no attributes.
 */
declare function createNoop(): EditProxy;
/**
 * Visual editing proxy type.
 *
 * Spread directly onto elements for entry-level annotations: `{...entry.edit}`
 * Access a field for field-level annotations: `{...entry.edit.title}`
 *
 * In production, spreading produces no attributes (noop).
 */
type EditProxy = {
  readonly [field: string]: Partial<FieldAnnotation>;
};
//#endregion
//#region src/query.d.ts
/**
 * Collection type registry for type-safe queries.
 *
 * This interface is extended by the generated emdash-env.d.ts file
 * to provide type inference for collection names and their data shapes.
 *
 * @example
 * ```ts
 * // In emdash-env.d.ts (generated):
 * declare module "@premium-cms/emdash" {
 *   interface EmDashCollections {
 *     posts: { title: string; content: PortableTextBlock[]; };
 *     pages: { title: string; body: PortableTextBlock[]; };
 *   }
 * }
 *
 * // Then in your code:
 * const { entries } = await getEmDashCollection("posts");
 * // entries[0].data.title is typed as string
 * ```
 */
interface EmDashCollections {}
/**
 * Helper type to infer the data type for a collection.
 * Returns the registered type if known, otherwise falls back to Record<string, unknown>.
 */
type InferCollectionData<T extends string> = T extends keyof EmDashCollections ? EmDashCollections[T] : Record<string, unknown>;
/**
 * Sort direction
 */
type SortDirection = "asc" | "desc";
/**
 * Order by specification - field name to direction
 * @example { created_at: "desc" } - Sort by created_at descending
 * @example { title: "asc" } - Sort by title ascending
 * @example { published_at: "desc", title: "asc" } - Multi-field sort
 */
type OrderBySpec = Record<string, SortDirection>;
/**
 * Fields shared by every collection query, independent of pagination mode.
 *
 * Cursor and offset pagination are mutually exclusive, so they live on the
 * `CursorCollectionFilter` / `OffsetCollectionFilter` variants rather than
 * here. Use the {@link CollectionFilter} union for any value that may be
 * either.
 */
interface CollectionFilterBase {
  status?: "draft" | "published" | "archived";
  limit?: number;
  /**
   * Filter by field values, taxonomy terms, byline credits, or ranges.
   *
   * Taxonomy names are detected automatically and filtered via JOIN.
   * The reserved `byline` key filters by byline credit (any credit, not
   * just the primary one) via the `_emdash_content_bylines` junction
   * table; its value is one or more byline translation groups. This
   * matches co-authored entries, which `primary_byline_id` alone misses.
   * Other keys are treated as column filters on the content table.
   *
   * @example { category: 'news' } - Filter by taxonomy term
   * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
   * @example { byline: '01HXYZ...' } - Entries credited to a byline (any position)
   * @example { byline: ['01HXYZ...', '01HABC...'] } - Credited to any of these bylines (OR)
   * @example { series: 'main' } - Exact match on a content field
   * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - Date range
   */
  where?: Record<string, WhereValue>;
  /**
   * Order results by field(s)
   * @default { created_at: "desc" }
   * @example { created_at: "desc" } - Sort by created_at descending (default)
   * @example { title: "asc" } - Sort by title ascending
   * @example { published_at: "desc", title: "asc" } - Multi-field sort
   */
  orderBy?: OrderBySpec;
  /**
   * Filter by locale. When set, only returns entries in this locale.
   * Only relevant when i18n is configured.
   * @example "en" — English entries only
   * @example "fr" — French entries only
   */
  locale?: string;
}
/** Keyset-paginated query filter. Cannot also carry an `offset`. */
interface CursorCollectionFilter extends CollectionFilterBase {
  /**
   * Opaque cursor for keyset pagination.
   * Pass the `nextCursor` value from a previous result to fetch the next page.
   * @example
   * ```ts
   * const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
   * const { entries, nextCursor } = await getEmDashCollection("posts", {
   *   limit: 10,
   *   cursor,
   * });
   * ```
   */
  cursor?: string;
  offset?: never;
}
/** Offset-paginated query filter. Cannot also carry a `cursor`. */
interface OffsetCollectionFilter extends CollectionFilterBase {
  /**
   * Skip this many entries before returning results (offset pagination).
   *
   * Use with `limit` to render numbered archive routes like `/page/2`
   * without walking cursors or over-fetching from the start:
   *
   * ```ts
   * const perPage = 20;
   * const { entries, hasMore } = await getEmDashCollection("posts", {
   *   limit: perPage,
   *   offset: (page - 1) * perPage,
   *   orderBy: { published_at: "desc" },
   * });
   * ```
   *
   * Only a positive integer applies.
   */
  offset?: number;
  cursor?: never;
}
/**
 * Filter for `getEmDashCollection`.
 *
 * A union of the cursor and offset pagination variants: supplying both
 * `cursor` and `offset` is a compile-time error, since they are mutually
 * exclusive ways to express "the next page" (cursor wins at runtime).
 */
type CollectionFilter = CursorCollectionFilter | OffsetCollectionFilter;
interface ContentEntry<T = Record<string, unknown>> {
  id: string;
  data: T;
  /** Visual editing annotations. Spread onto elements: {...entry.edit.title} */
  edit: EditProxy;
}
/** Cache hint returned by the content loader for route caching */
interface CacheHint {
  tags?: string[];
  lastModified?: Date;
}
/**
 * Result from getEmDashCollection
 */
interface CollectionResult<T> {
  /** The entries (empty array if error or none found) */
  entries: ContentEntry<T>[];
  /** Error if the query failed */
  error?: Error;
  /** Cache hint for route caching (pass to Astro.cache.set()) */
  cacheHint: CacheHint;
  /**
   * Opaque cursor for the next page.
   * Undefined when there are no more results.
   * Pass this as `cursor` in the next query to get the next page.
   */
  nextCursor?: string;
  /**
   * Whether more entries exist beyond this page. Set whenever `limit` is
   * provided (cursor or offset pagination), so numbered archive routes can
   * render a "next page" link without computing a total count.
   */
  hasMore?: boolean;
}
/**
 * Result from getEmDashEntry
 */
interface EntryResult<T> {
  /** The entry, or null if not found */
  entry: ContentEntry<T> | null;
  /** Error if the query failed (not set for "not found", only for actual errors) */
  error?: Error;
  /** Whether we're in preview mode (valid token was provided) */
  isPreview: boolean;
  /** Set when a fallback locale was used instead of the requested locale */
  fallbackLocale?: string;
  /** Cache hint for route caching (pass to Astro.cache.set()) */
  cacheHint: CacheHint;
}
/** Edit metadata attached to PT arrays in edit mode */
interface EditFieldMeta {
  collection: string;
  id: string;
  field: string;
}
/**
 * Read edit metadata from a value (returns undefined if not tagged).
 * Uses Object.getOwnPropertyDescriptor to access Symbol-keyed property
 * without an unsafe type assertion.
 */
declare function getEditMeta(value: unknown): EditFieldMeta | undefined;
/**
 * Get all entries of a content type
 *
 * Returns { entries, error } for graceful error handling.
 *
 * When emdash-env.d.ts is generated, the collection name will be
 * type-checked and the return type will be inferred automatically.
 *
 * @example
 * ```ts
 * import { getEmDashCollection } from "@premium-cms/emdash";
 *
 * const { entries: posts, error } = await getEmDashCollection("posts");
 * if (error) {
 *   console.error("Failed to load posts:", error);
 *   return;
 * }
 * // posts[0].data.title is typed (if emdash-env.d.ts exists)
 *
 * // With filters
 * const { entries: drafts } = await getEmDashCollection("posts", { status: "draft" });
 * ```
 */
declare function getEmDashCollection<T extends string, D = InferCollectionData<T>>(type: T, filter?: CollectionFilter): Promise<CollectionResult<D>>;
/**
 * Get a single entry by type and ID/slug
 *
 * Returns { entry, error, isPreview } for graceful error handling.
 * - entry is null if not found (not an error)
 * - error is set only for actual errors (db issues, etc.)
 *
 * Preview mode is detected automatically from request context (ALS).
 * When the URL has a valid `_preview` token, the middleware sets preview
 * context and this function serves draft revision data if available.
 *
 * @example
 * ```ts
 * import { getEmDashEntry } from "@premium-cms/emdash";
 *
 * // Simple usage — preview just works via middleware
 * const { entry: post, isPreview, error } = await getEmDashEntry("posts", "my-slug");
 * if (!post) return Astro.redirect("/404");
 * ```
 */
declare function getEmDashEntry<T extends string, D = InferCollectionData<T>>(type: T, id: string, options?: {
  locale?: string;
}): Promise<EntryResult<D>>;
/**
 * Translation summary for a single locale variant
 */
interface TranslationSummary {
  /** Content item ID */
  id: string;
  /** Locale code (e.g. "en", "fr") */
  locale: string;
  /** URL slug */
  slug: string | null;
  /** Current status */
  status: string;
}
/**
 * Result from getTranslations
 */
interface TranslationsResult {
  /** The translation group ID (shared across locales) */
  translationGroup: string;
  /** All locale variants in this group */
  translations: TranslationSummary[];
  /** Error if the query failed */
  error?: Error;
}
/**
 * Get all translations of a content item.
 *
 * Given a content entry, returns all locale variants that share the same
 * translation group. This is useful for building language switcher UI.
 *
 * @example
 * ```ts
 * import { getEmDashEntry, getTranslations } from "@premium-cms/emdash";
 *
 * const { entry: post } = await getEmDashEntry("posts", "hello-world", { locale: "en" });
 * const { translations } = await getTranslations("posts", post.data.id);
 * // translations = [{ id: "...", locale: "en", slug: "hello-world", status: "published" }, ...]
 * ```
 */
declare function getTranslations(type: string, id: string): Promise<TranslationsResult>;
/**
 * Result from resolveEmDashPath
 */
interface ResolvePathResult<T = Record<string, unknown>> {
  /** The matched entry */
  entry: ContentEntry<T>;
  /** The collection slug that matched */
  collection: string;
  /** Extracted parameters from the URL pattern (e.g. { slug: "my-post" }) */
  params: Record<string, string>;
}
/**
 * Resolve a URL path to a content entry by matching against collection URL patterns.
 *
 * Loads all collections with a `urlPattern` set, converts each pattern to a regex,
 * and tests the given path. On match, extracts the slug and fetches the entry.
 *
 * @example
 * ```ts
 * import { resolveEmDashPath } from "@premium-cms/emdash";
 *
 * // Given pages with urlPattern "/{slug}" and posts with "/blog/{slug}":
 * const result = await resolveEmDashPath("/blog/hello-world");
 * if (result) {
 *   console.log(result.collection); // "posts"
 *   console.log(result.params.slug); // "hello-world"
 *   console.log(result.entry.data); // post data
 * }
 * ```
 */
declare function resolveEmDashPath<T = Record<string, unknown>>(path: string): Promise<ResolvePathResult<T> | null>;
//#endregion
//#region src/after.d.ts
/**
 * Defer work past the HTTP response.
 *
 * Use for bookkeeping that doesn't need to complete before the client
 * gets bytes — writes that record state, maintenance queries, cache
 * refreshes. `after()` hands the promise to the host's lifetime
 * extender when one is available (Cloudflare's `waitUntil` under
 * workerd), or fires-and-forgets on Node (the process lives for the
 * next request anyway).
 *
 * Host binding is resolved lazily via a dynamic import of the
 * `virtual:emdash/wait-until` virtual module. Lazy — rather than a
 * static top-level import — so tools that walk the dist in a plain
 * Node loader (`astro check`, Vitest, etc.) don't trip over the
 * `virtual:` scheme: they'd only fail if they actually called
 * `after()`, which they don't during type-checking.
 */
type WaitUntilFn = (promise: Promise<unknown>) => void;
/**
 * Schedule `fn` to run without blocking the response.
 *
 * Errors are caught and logged — a deferred task should never surface
 * as an unhandled rejection because the response is long gone. Callers
 * that care about errors should handle them inside `fn`.
 */
declare function after(fn: () => void | Promise<void>): void;
//#endregion
//#region src/object-cache/index.d.ts
/** Options for {@link cachedQuery}. */
interface CachedQueryOptions<T> {
  /**
   * Invalidation namespace(s). A single string for self-contained data
   * (`settings`, `menus`), or several when the cached value depends on data
   * owned by other namespaces — e.g. a content entry hydrates bylines and
   * taxonomy terms, so it caches under
   * `[content:posts, "bylines", "taxonomies"]` and is invalidated when *any*
   * of them is bumped. Every namespace's epoch is folded into the key.
   */
  namespace: string | readonly string[];
  /** Stable, fully-qualifying cache key *within* the namespace. */
  key: string;
  /** Loader run on a miss (or when caching is disabled/bypassed). */
  load: () => Promise<T>;
  /** TTL override in seconds. Falls back to the configured `defaultTtl`. */
  ttl?: number;
  /**
   * Predicate gating whether a freshly-loaded value is stored. Defaults to
   * always-cache. Use it to skip caching error/empty sentinels.
   */
  cacheable?: (value: T) => boolean;
}
/**
 * Distributed read-through cache around `load`.
 *
 * `T` must be the value as it should be *stored* — i.e. JSON-serializable with
 * the codec's `Date` support, carrying no functions or symbol-keyed props.
 * Callers caching richer objects (content entries) reduce to a serializable
 * snapshot here and rebuild on the way out; see `query.ts`.
 *
 * On a miss or when the cache is disabled/bypassed, this is equivalent to
 * `await load()`. Backend errors never propagate: a failing `get` is a miss, a
 * failing `set` is dropped.
 */
declare function cachedQuery<T>(options: CachedQueryOptions<T>): Promise<T>;
/**
 * Invalidate every cached value in `namespace` by bumping its epoch.
 *
 * Sync and non-blocking: the local epoch is stamped immediately (so the
 * writing isolate is instantly consistent) and the backend write is deferred
 * via `after`. Other isolates pick up the new epoch within their `revalidate`
 * window. No-ops when the cache is disabled.
 *
 * Content namespaces (`content:*`) also stamp {@link getLastContentWriteAt}.
 */
declare function invalidateObjectCache(namespace: string): void;
/**
 * Fixed namespaces for data shared across collections. Content reads fold the
 * `BYLINES` and `TAXONOMIES` epochs into their keys (via {@link cachedQuery})
 * because entries hydrate byline and taxonomy-term data — so renaming an
 * author or a category correctly invalidates every cached entry that displays
 * it, without tracking which collections reference it.
 */
declare const CacheNamespace: {
  readonly SETTINGS: "settings";
  readonly MENUS: "menus";
  readonly TAXONOMIES: "taxonomies";
  readonly BYLINES: "bylines"; /** Collection schema/metadata (label, supports, commentsEnabled, fields). */
  readonly SCHEMA: "schema"; /** Public (approved) comments. */
  readonly COMMENTS: "comments";
};
/** Namespace for a content collection's cached queries. */
declare function contentNamespace(collection: string): string;
/**
 * Namespaces a content read depends on: the collection itself plus the shared
 * byline/taxonomy data folded into each entry.
 */
declare function contentNamespaces(collection: string): readonly string[];
/**
 * Invalidate all cached reads (list + entry) for a content collection.
 * Call from every write path that mutates rows in `ec_<collection>`.
 */
declare function invalidateCollectionCache(collection: string): void;
/** Invalidate cached taxonomy definitions/terms and all content that hydrates them. */
declare function invalidateTaxonomyObjectCache(): void;
/** Invalidate cached bylines and all content that hydrates them. */
declare function invalidateBylineObjectCache(): void;
/** Invalidate cached navigation menus. */
declare function invalidateMenuObjectCache(): void;
/** Invalidate cached collection schema/metadata reads (e.g. getCollectionInfo). */
declare function invalidateSchemaObjectCache(): void;
/** Invalidate cached public comment reads. */
declare function invalidateCommentObjectCache(): void;
//#endregion
//#region src/plugins/define-plugin.d.ts
/**
 * Define a native EmDash plugin.
 *
 * Native plugins ship as regular npm modules, get installed via
 * `pnpm add` + an `astro.config.mjs` edit, and run in the host
 * process. They have full access to the runtime — capabilities are
 * still enforced by `PluginContextFactory`, but there is no isolation
 * boundary.
 *
 * @example
 * ```typescript
 * import { definePlugin } from "@premium-cms/emdash";
 *
 * export default definePlugin({
 *   id: "my-plugin",
 *   version: "1.0.0",
 *   capabilities: ["content:read"],
 *   hooks: {
 *     "content:beforeSave": async (event, ctx) => {
 *       ctx.log.info("Saving content", { collection: event.collection });
 *       return event.content;
 *     }
 *   },
 *   routes: {
 *     "sync": {
 *       handler: async (ctx) => {
 *         return { status: "ok" };
 *       }
 *     }
 *   }
 * });
 * ```
 *
 * Sandboxed-format plugins do not use `definePlugin`. They
 * default-export a bare `{ hooks?, routes? }` object with a
 * `satisfies SandboxedPlugin` annotation from `emdash/plugin`. Calling
 * `definePlugin` with an object that has no `id` throws at runtime
 * (the type system already rejects it at compile time — this check is
 * for callers that bypass typechecking).
 */
declare function definePlugin<TStorage extends PluginStorageConfig>(definition: PluginDefinition<TStorage>): ResolvedPlugin<TStorage>;
//#endregion
//#region src/plugins/manifest-schema.d.ts
/**
 * Zod schema matching the PluginManifest interface from types.ts.
 *
 * Every JSON.parse of a manifest.json should validate through this.
 *
 * `declaredAccess` is the trust contract; `capabilities`/`allowedHosts` are the
 * runtime's enforcement currency. Apply `reconcileManifestAccess` after parsing
 * to make them consistent (declaredAccess authoritative when present). Kept a
 * plain object (no `.transform`) because callers `.pick()`/`.extend()` it.
 */
declare const pluginManifestSchema: z$1.ZodObject<{
  id: z$1.ZodString;
  version: z$1.ZodString;
  declaredAccess: z$1.ZodOptional<z$1.ZodObject<{
    content: z$1.ZodOptional<z$1.ZodObject<{
      read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
      write: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    taxonomies: z$1.ZodOptional<z$1.ZodObject<{
      read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    media: z$1.ZodOptional<z$1.ZodObject<{
      read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
      write: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    network: z$1.ZodOptional<z$1.ZodObject<{
      request: z$1.ZodOptional<z$1.ZodObject<{
        allowedHosts: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
      }, z$1.core.$strip>>;
    }, z$1.core.$strip>>;
    email: z$1.ZodOptional<z$1.ZodObject<{
      send: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
      events: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
      transport: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    page: z$1.ZodOptional<z$1.ZodObject<{
      fragments: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    users: z$1.ZodOptional<z$1.ZodObject<{
      read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    github: z$1.ZodOptional<z$1.ZodObject<{
      connection: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    agents: z$1.ZodOptional<z$1.ZodObject<{
      run: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
    sandbox: z$1.ZodOptional<z$1.ZodObject<{
      build: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
  }, z$1.core.$strip>>;
  capabilities: z$1.ZodArray<z$1.ZodEnum<{
    "network:request": "network:request";
    "network:request:unrestricted": "network:request:unrestricted";
    "content:read": "content:read";
    "content:write": "content:write";
    "taxonomies:read": "taxonomies:read";
    "media:read": "media:read";
    "media:write": "media:write";
    "users:read": "users:read";
    "github:connection": "github:connection";
    "email:send": "email:send";
    "hooks.email-transport:register": "hooks.email-transport:register";
    "hooks.email-events:register": "hooks.email-events:register";
    "hooks.page-fragments:register": "hooks.page-fragments:register";
    "agents:run": "agents:run";
    "sandbox:build": "sandbox:build";
    "network:fetch": "network:fetch";
    "network:fetch:any": "network:fetch:any";
    "read:content": "read:content";
    "write:content": "write:content";
    "read:media": "read:media";
    "write:media": "write:media";
    "read:users": "read:users";
    "email:provide": "email:provide";
    "email:intercept": "email:intercept";
    "page:inject": "page:inject";
  }>>;
  allowedHosts: z$1.ZodArray<z$1.ZodString>;
  storage: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
    indexes: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
    uniqueIndexes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>>;
  }, z$1.core.$strip>>;
  hooks: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodEnum<{
    "plugin:install": "plugin:install";
    "plugin:activate": "plugin:activate";
    "plugin:deactivate": "plugin:deactivate";
    "plugin:uninstall": "plugin:uninstall";
    "content:beforeSave": "content:beforeSave";
    "content:afterSave": "content:afterSave";
    "content:beforeDelete": "content:beforeDelete";
    "content:afterDelete": "content:afterDelete";
    "content:afterPublish": "content:afterPublish";
    "content:afterUnpublish": "content:afterUnpublish";
    "content:afterRestore": "content:afterRestore";
    "content:afterSchedule": "content:afterSchedule";
    "content:afterUnschedule": "content:afterUnschedule";
    "media:beforeUpload": "media:beforeUpload";
    "media:afterUpload": "media:afterUpload";
    cron: "cron";
    "email:beforeSend": "email:beforeSend";
    "email:deliver": "email:deliver";
    "email:afterSend": "email:afterSend";
    "comment:beforeCreate": "comment:beforeCreate";
    "comment:moderate": "comment:moderate";
    "comment:afterCreate": "comment:afterCreate";
    "comment:afterModerate": "comment:afterModerate";
    "page:metadata": "page:metadata";
    "page:fragments": "page:fragments";
  }>, z$1.ZodObject<{
    name: z$1.ZodEnum<{
      "plugin:install": "plugin:install";
      "plugin:activate": "plugin:activate";
      "plugin:deactivate": "plugin:deactivate";
      "plugin:uninstall": "plugin:uninstall";
      "content:beforeSave": "content:beforeSave";
      "content:afterSave": "content:afterSave";
      "content:beforeDelete": "content:beforeDelete";
      "content:afterDelete": "content:afterDelete";
      "content:afterPublish": "content:afterPublish";
      "content:afterUnpublish": "content:afterUnpublish";
      "content:afterRestore": "content:afterRestore";
      "content:afterSchedule": "content:afterSchedule";
      "content:afterUnschedule": "content:afterUnschedule";
      "media:beforeUpload": "media:beforeUpload";
      "media:afterUpload": "media:afterUpload";
      cron: "cron";
      "email:beforeSend": "email:beforeSend";
      "email:deliver": "email:deliver";
      "email:afterSend": "email:afterSend";
      "comment:beforeCreate": "comment:beforeCreate";
      "comment:moderate": "comment:moderate";
      "comment:afterCreate": "comment:afterCreate";
      "comment:afterModerate": "comment:afterModerate";
      "page:metadata": "page:metadata";
      "page:fragments": "page:fragments";
    }>;
    exclusive: z$1.ZodOptional<z$1.ZodBoolean>;
    priority: z$1.ZodOptional<z$1.ZodNumber>;
    timeout: z$1.ZodOptional<z$1.ZodNumber>;
  }, z$1.core.$strip>]>>;
  routes: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodObject<{
    name: z$1.ZodString;
    public: z$1.ZodOptional<z$1.ZodBoolean>;
    permission: z$1.ZodOptional<z$1.ZodString>;
    cacheControl: z$1.ZodOptional<z$1.ZodString>;
  }, z$1.core.$strip>]>>;
  mcp: z$1.ZodOptional<z$1.ZodObject<{
    tools: z$1.ZodArray<z$1.ZodObject<{
      name: z$1.ZodString;
      description: z$1.ZodString;
      route: z$1.ZodString;
      permission: z$1.ZodString;
      destructive: z$1.ZodBoolean;
      inputSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
      outputSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
    }, z$1.core.$strip>>;
  }, z$1.core.$strip>>;
  admin: z$1.ZodObject<{
    entry: z$1.ZodOptional<z$1.ZodString>;
    settingsSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
      type: z$1.ZodLiteral<"string">;
      default: z$1.ZodOptional<z$1.ZodString>;
      multiline: z$1.ZodOptional<z$1.ZodBoolean>;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>, z$1.ZodObject<{
      type: z$1.ZodLiteral<"number">;
      default: z$1.ZodOptional<z$1.ZodNumber>;
      min: z$1.ZodOptional<z$1.ZodNumber>;
      max: z$1.ZodOptional<z$1.ZodNumber>;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>, z$1.ZodObject<{
      type: z$1.ZodLiteral<"boolean">;
      default: z$1.ZodOptional<z$1.ZodBoolean>;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>, z$1.ZodObject<{
      type: z$1.ZodLiteral<"select">;
      options: z$1.ZodArray<z$1.ZodObject<{
        value: z$1.ZodString;
        label: z$1.ZodString;
      }, z$1.core.$strip>>;
      default: z$1.ZodOptional<z$1.ZodString>;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>, z$1.ZodObject<{
      type: z$1.ZodLiteral<"secret">;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>, z$1.ZodObject<{
      type: z$1.ZodLiteral<"url">;
      default: z$1.ZodOptional<z$1.ZodString>;
      placeholder: z$1.ZodOptional<z$1.ZodString>;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>, z$1.ZodObject<{
      type: z$1.ZodLiteral<"email">;
      default: z$1.ZodOptional<z$1.ZodString>;
      placeholder: z$1.ZodOptional<z$1.ZodString>;
      label: z$1.ZodString;
      description: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>], "type">>>;
    pages: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
      path: z$1.ZodString;
      label: z$1.ZodString;
      icon: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>>>;
    widgets: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
      id: z$1.ZodString;
      size: z$1.ZodOptional<z$1.ZodEnum<{
        full: "full";
        half: "half";
        third: "third";
      }>>;
      title: z$1.ZodOptional<z$1.ZodString>;
    }, z$1.core.$strip>>>;
    fieldWidgets: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
      name: z$1.ZodString;
      label: z$1.ZodString;
      fieldTypes: z$1.ZodArray<z$1.ZodEnum<{
        string: "string";
        number: "number";
        boolean: "boolean";
        file: "file";
        image: "image";
        datetime: "datetime";
        slug: "slug";
        text: "text";
        integer: "integer";
        select: "select";
        multiSelect: "multiSelect";
        portableText: "portableText";
        reference: "reference";
        json: "json";
        repeater: "repeater";
      }>>;
      elements: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
        type: z$1.ZodString;
        action_id: z$1.ZodString;
        label: z$1.ZodOptional<z$1.ZodString>;
      }, z$1.core.$loose>>>;
    }, z$1.core.$strip>>>;
  }, z$1.core.$strip>;
}, z$1.core.$strip>;
type ValidatedPluginManifest = z$1.infer<typeof pluginManifestSchema>;
//#endregion
//#region src/plugins/manager.d.ts
/**
 * Plugin state in the manager
 */
type PluginState = "registered" | "installed" | "active" | "inactive";
/**
 * Plugin manager options
 */
interface PluginManagerOptions {
  /** Database instance */
  db: Kysely<Database>;
  /** Storage backend for direct media uploads */
  storage?: Storage;
  /** Function to generate upload URLs for media */
  getUploadUrl?: (filename: string, contentType: string) => Promise<{
    uploadUrl: string;
    mediaId: string;
  }>;
  /**
   * Pre-resolved list of trusted proxy header names for client-IP
   * resolution in plugin route handlers. Thread through from the runtime.
   */
  trustedProxyHeaders?: string[];
}
/**
 * Plugin Manager v2
 *
 * Manages the full lifecycle of plugins and coordinates hooks/routes.
 */
declare class PluginManager {
  private options;
  private plugins;
  private hookPipeline;
  private routeRegistry;
  private factoryOptions;
  private initialized;
  constructor(options: PluginManagerOptions);
  /**
   * Set the email pipeline used when creating plugin contexts.
   * Reinitializes routes/hooks if already initialized so ctx.email is available immediately.
   */
  setEmailPipeline(pipeline: EmailPipeline): void;
  /**
   * Register a plugin definition
   * This resolves the definition and adds it to the manager, but doesn't install it
   */
  register<TStorage extends PluginStorageConfig>(definition: PluginDefinition<TStorage>): ResolvedPlugin<TStorage>;
  /**
   * Register multiple plugins
   */
  registerAll(definitions: PluginDefinition[]): void;
  /**
   * Unregister a plugin
   * Plugin must be inactive or just registered
   */
  unregister(pluginId: string): boolean;
  /**
   * Install a plugin (run install hooks, set up storage)
   */
  install(pluginId: string): Promise<HookResult<void>[]>;
  /**
   * Activate a plugin (run activate hooks, enable hooks/routes)
   */
  activate(pluginId: string): Promise<HookResult<void>[]>;
  /**
   * Deactivate a plugin (run deactivate hooks, disable hooks/routes)
   */
  deactivate(pluginId: string): Promise<HookResult<void>[]>;
  /**
   * Uninstall a plugin (run uninstall hooks, optionally delete data)
   */
  uninstall(pluginId: string, deleteData?: boolean): Promise<HookResult<void>[]>;
  /**
   * Run content:beforeSave hooks across all active plugins
   */
  runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<{
    content: Record<string, unknown>;
    results: HookResult<Record<string, unknown>>[];
  }>;
  /**
   * Run content:afterSave hooks across all active plugins
   */
  runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<HookResult<void>[]>;
  /**
   * Run content:beforeDelete hooks across all active plugins
   */
  runContentBeforeDelete(id: string, collection: string): Promise<{
    allowed: boolean;
    results: HookResult<boolean>[];
  }>;
  /**
   * Run content:afterDelete hooks across all active plugins
   */
  runContentAfterDelete(id: string, collection: string, permanent: boolean): Promise<HookResult<void>[]>;
  /**
   * Run content:afterPublish hooks across all active plugins
   */
  runContentAfterPublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterUnpublish hooks across all active plugins
   */
  runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterRestore hooks across all active plugins
   */
  runContentAfterRestore(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterSchedule hooks across all active plugins
   */
  runContentAfterSchedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run content:afterUnschedule hooks across all active plugins
   */
  runContentAfterUnschedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
  /**
   * Run media:beforeUpload hooks across all active plugins
   */
  runMediaBeforeUpload(file: {
    name: string;
    type: string;
    size: number;
  }): Promise<{
    file: {
      name: string;
      type: string;
      size: number;
    };
    results: HookResult<{
      name: string;
      type: string;
      size: number;
    }>[];
  }>;
  /**
   * Run media:afterUpload hooks across all active plugins
   */
  runMediaAfterUpload(media: MediaItem$1): Promise<HookResult<void>[]>;
  /**
   * Invoke the cron hook for a specific plugin (per-plugin dispatch).
   * Used as the InvokeCronHookFn callback for CronExecutor.
   */
  invokeCronHook(pluginId: string, event: CronEvent): Promise<void>;
  /**
   * Invoke a plugin route
   */
  invokeRoute(pluginId: string, routeName: string, options: InvokeRouteOptions): Promise<RouteResult>;
  /**
   * Get all routes for a plugin
   */
  getPluginRoutes(pluginId: string): string[];
  /**
   * Get a plugin by ID
   */
  getPlugin(pluginId: string): ResolvedPlugin | undefined;
  /**
   * Get plugin state
   */
  getPluginState(pluginId: string): PluginState | undefined;
  /**
   * Get all registered plugins
   */
  getAllPlugins(): Array<{
    plugin: ResolvedPlugin;
    state: PluginState;
  }>;
  /**
   * Get all active plugins
   */
  getActivePlugins(): ResolvedPlugin[];
  /**
   * Check if a plugin exists
   */
  hasPlugin(pluginId: string): boolean;
  /**
   * Check if a plugin is active
   */
  isActive(pluginId: string): boolean;
  /**
   * Get all plugins that registered a handler for an exclusive hook.
   */
  getExclusiveHookProviders(hookName: string): Array<{
    pluginId: string;
    pluginName: string;
  }>;
  /**
   * Read the selected provider for an exclusive hook from the options table.
   */
  getExclusiveHookSelection(hookName: string): Promise<string | null>;
  /**
   * Set the selected provider for an exclusive hook in the options table.
   * Pass null to clear the selection.
   */
  setExclusiveHookSelection(hookName: string, pluginId: string | null): Promise<void>;
  /**
   * Resolution algorithm for exclusive hooks.
   *
   * Delegates to the shared resolveExclusiveHooks() function.
   * See hooks.ts for the full algorithm description.
   */
  resolveExclusiveHooks(preferredHints?: Map<string, string[]>): Promise<void>;
  /**
   * Get all exclusive hooks with their providers and current selections.
   * Used by the admin API.
   */
  getExclusiveHooksInfo(): Promise<Array<{
    hookName: string;
    providers: Array<{
      pluginId: string;
    }>;
    selectedPluginId: string | null;
  }>>;
  /**
   * Initialize or reinitialize the hook pipeline and route registry
   */
  private ensureInitialized;
  /**
   * Force reinitialization (useful after plugin state changes)
   */
  reinitialize(): void;
  /**
   * Delete all cron tasks for a plugin.
   * Used during uninstall.
   */
  private deleteCronTasks;
}
/**
 * Create a plugin manager
 */
declare function createPluginManager(options: PluginManagerOptions): PluginManager;
//#endregion
//#region src/plugins/scheduler/node.d.ts
declare class NodeCronScheduler implements CronScheduler {
  private executor;
  private timer;
  private running;
  private systemCleanup;
  private mediaUsageMaintenance;
  constructor(executor: CronExecutor);
  setSystemCleanup(fn: SystemCleanupFn): void;
  setMediaUsageMaintenance(fn: SystemCleanupFn): void;
  start(): void;
  stop(): void;
  reschedule(): void;
  private arm;
  private executeTick;
}
//#endregion
//#region src/plugins/sandbox/noop.d.ts
/**
 * Error thrown when attempting to use sandboxing on an unsupported platform.
 */
declare class SandboxNotAvailableError extends Error {
  constructor();
}
/**
 * No-op sandbox runner for platforms without isolation support.
 *
 * - `isAvailable()` returns false
 * - `load()` throws SandboxNotAvailableError
 * - `terminateAll()` is a no-op
 *
 * This is the default runner when no platform adapter is configured.
 */
declare class NoopSandboxRunner implements SandboxRunner {
  /**
   * Always returns false - sandboxing is not available.
   */
  isAvailable(): boolean;
  /**
   * Always returns false - no sandbox runtime to be healthy.
   */
  isHealthy(): boolean;
  /**
   * Always throws - can't load sandboxed plugins without isolation.
   */
  load(_manifest: PluginManifest, _code: string): Promise<SandboxedPluginInstance>;
  /**
   * No-op - sandboxing not available, email callback is irrelevant.
   */
  setEmailSend(): void;
  /**
   * No-op - nothing to terminate.
   */
  terminateAll(): Promise<void>;
}
/**
 * Create a no-op sandbox runner.
 * This is used as the default when no platform adapter is configured.
 */
declare function createNoopSandboxRunner(_options?: SandboxOptions): SandboxRunner;
//#endregion
//#region src/preview/tokens.d.ts
/**
 * Preview token generation and verification
 *
 * Tokens are compact, URL-safe, and HMAC-signed.
 * Format: base64url(JSON payload).base64url(HMAC signature)
 *
 * Payload: { cid: contentId, exp: expiryTimestamp, iat: issuedAt }
 */
/**
 * Preview token payload
 */
interface PreviewTokenPayload {
  /** Content ID in format "collection:id" (e.g., "posts:abc123") */
  cid: string;
  /** Expiry timestamp (seconds since epoch) */
  exp: number;
  /** Issued at timestamp (seconds since epoch) */
  iat: number;
}
/**
 * Options for generating a preview token
 */
interface GeneratePreviewTokenOptions {
  /** Content ID in format "collection:id" */
  contentId: string;
  /** How long the token is valid. Accepts "1h", "30m", "1d", or seconds as number. Default: "1h" */
  expiresIn?: string | number;
  /** Secret key for signing. Should be from environment variable. */
  secret: string;
}
/**
 * Generate a preview token for content
 *
 * @example
 * ```ts
 * const token = await generatePreviewToken({
 *   contentId: "posts:abc123",
 *   expiresIn: "1h",
 *   secret: process.env.PREVIEW_SECRET!,
 * });
 * ```
 */
declare function generatePreviewToken(options: GeneratePreviewTokenOptions): Promise<string>;
/**
 * Result of verifying a preview token
 */
type VerifyPreviewTokenResult = {
  valid: true;
  payload: PreviewTokenPayload;
} | {
  valid: false;
  error: "invalid" | "expired" | "malformed" | "none";
};
/**
 * Options for verifyPreviewToken
 */
type VerifyPreviewTokenOptions = {
  /** Secret key for verifying tokens */secret: string;
} & ({
  url: URL;
} | {
  /** Preview token string (can be null) */token: string | null | undefined;
});
/**
 * Verify a preview token and return the payload
 *
 * @example
 * ```ts
 * // With URL (extracts _preview query param)
 * const result = await verifyPreviewToken({
 *   url: Astro.url,
 *   secret: import.meta.env.PREVIEW_SECRET,
 * });
 *
 * // With token directly
 * const result = await verifyPreviewToken({
 *   token: someToken,
 *   secret: import.meta.env.PREVIEW_SECRET,
 * });
 *
 * if (result.valid) {
 *   console.log(result.payload.cid); // "posts:abc123"
 * }
 * ```
 */
declare function verifyPreviewToken(options: VerifyPreviewTokenOptions): Promise<VerifyPreviewTokenResult>;
/**
 * Parse a content ID into collection and id
 */
declare function parseContentId(contentId: string): {
  collection: string;
  id: string;
};
//#endregion
//#region src/preview/urls.d.ts
/**
 * Preview URL generation
 *
 * Creates preview URLs that include a signed token for accessing draft content.
 */
/**
 * Options for generating a preview URL
 */
interface GetPreviewUrlOptions {
  /** Collection slug (e.g., "posts") */
  collection: string;
  /** Content ID or slug */
  id: string;
  /** Secret key for signing the token */
  secret: string;
  /** How long the preview URL is valid. Default: "1h" */
  expiresIn?: string | number;
  /** Base URL of the site. If not provided, returns a relative URL. */
  baseUrl?: string;
  /**
   * Custom path pattern. Supports `{collection}`, `{id}` and `{locale}`
   * placeholders. Default: `"/{collection}/{id}"`.
   */
  pathPattern?: string;
  /**
   * Locale segment substituted for the `{locale}` placeholder in `pathPattern`.
   * Pass an empty string to omit the locale prefix (e.g. for the default locale
   * when `prefixDefaultLocale` is `false`); adjacent slashes left by an empty
   * value are collapsed and any trailing slash is trimmed.
   */
  locale?: string;
}
/**
 * Generate a preview URL for content
 *
 * The URL includes a `_preview` query parameter with a signed token.
 *
 * @example
 * ```ts
 * const url = await getPreviewUrl({
 *   collection: "posts",
 *   id: "hello-world",
 *   secret: process.env.PREVIEW_SECRET!,
 * });
 * // Returns: /posts/hello-world?_preview=eyJj...
 *
 * // With base URL:
 * const fullUrl = await getPreviewUrl({
 *   collection: "posts",
 *   id: "hello-world",
 *   secret: process.env.PREVIEW_SECRET!,
 *   baseUrl: "https://example.com",
 * });
 * // Returns: https://example.com/posts/hello-world?_preview=eyJj...
 *
 * // Custom path pattern:
 * const customUrl = await getPreviewUrl({
 *   collection: "posts",
 *   id: "hello-world",
 *   secret: process.env.PREVIEW_SECRET!,
 *   pathPattern: "/blog/{id}",
 * });
 * // Returns: /blog/hello-world?_preview=eyJj...
 * ```
 */
declare function getPreviewUrl(options: GetPreviewUrlOptions): Promise<string>;
/**
 * Build a preview URL from a token (when you already have the token)
 *
 * @example
 * ```ts
 * const url = buildPreviewUrl({
 *   path: "/posts/hello-world",
 *   token: existingToken,
 * });
 * ```
 */
declare function buildPreviewUrl(options: {
  path: string;
  token: string;
  baseUrl?: string;
}): string;
//#endregion
//#region src/preview/helpers.d.ts
/**
 * Preview helpers for Astro pages
 */
/**
 * Check if a request is a preview request
 *
 * @example
 * ```ts
 * const isPreview = isPreviewRequest(Astro.url);
 * ```
 */
declare function isPreviewRequest(url: URL): boolean;
/**
 * Get the preview token from a URL
 *
 * @example
 * ```ts
 * const token = getPreviewToken(Astro.url);
 * ```
 */
declare function getPreviewToken(url: URL): string | null;
//#endregion
//#region src/settings/index.d.ts
/**
 * Get a single site setting by key
 *
 * Returns `undefined` if the setting has not been configured.
 * For media settings (logo, favicon), the URL is resolved automatically.
 *
 * @param key - The setting key (e.g., "title", "logo", "social")
 * @returns The setting value, or undefined if not set
 *
 * @example
 * ```ts
 * import { getSiteSetting } from "@premium-cms/emdash";
 *
 * const title = await getSiteSetting("title");
 * const logo = await getSiteSetting("logo");
 * console.log(logo?.url); // Resolved URL
 * ```
 */
declare function getSiteSetting<K extends SiteSettingKey>(key: K): Promise<SiteSettings[K] | undefined>;
/**
 * Get all site settings
 *
 * Returns all configured settings. Unset values are undefined.
 * Media references (logo/favicon) are resolved to include URLs.
 *
 * @example
 * ```ts
 * import { getSiteSettings } from "@premium-cms/emdash";
 *
 * const settings = await getSiteSettings();
 * console.log(settings.title); // "My Site"
 * console.log(settings.logo?.url); // "/_emdash/api/media/file/abc123"
 * ```
 */
declare function getSiteSettings(): Promise<Partial<SiteSettings>>;
/**
 * Set site settings (internal function used by admin API)
 *
 * Merges provided settings with existing ones. Only provided fields are updated.
 * Media references should include just the mediaId; URLs are resolved on read.
 *
 * @param settings - Partial settings object with values to update
 * @param db - Kysely database instance
 * @returns Promise that resolves when settings are saved
 *
 * @internal
 *
 * @example
 * ```ts
 * // Update multiple settings at once
 * await setSiteSettings({
 *   title: "My Site",
 *   tagline: "Welcome",
 *   logo: { mediaId: "med_123", alt: "Logo" }
 * }, db);
 * ```
 */
declare function setSiteSettings(settings: Partial<SiteSettings>, db: Kysely<Database>): Promise<void>;
/**
 * Get a single plugin setting by key.
 *
 * Plugin settings are stored in the options table under
 * `plugin:<pluginId>:settings:<key>`.
 */
declare function getPluginSetting<T = unknown>(pluginId: string, key: string): Promise<T | undefined>;
/**
 * Get all persisted plugin settings for a plugin.
 *
 * Defaults declared in `admin.settingsSchema` are not materialized
 * automatically; callers should apply their own fallback defaults.
 */
declare function getPluginSettings(pluginId: string): Promise<Record<string, unknown>>;
/**
 * The site's applied color scheme (tweakcn-adapted EmDash tokens), or null.
 * Read from the `emdash:color_scheme` option. Request-cached so `EmDashHead`
 * can inject it into every page without repeat queries. See
 * `api/handlers/color-schemes.ts` for how it is applied from the marketplace.
 */
declare function getColorScheme(): Promise<{
  id: string;
  title: string;
  declarations: string;
  adminCss: string;
} | null>;
//#endregion
//#region src/comments/query.d.ts
interface GetCommentsOptions {
  collection: string;
  contentId: string;
  threaded?: boolean;
  /** Attach aggregate reaction counts to each comment. */
  reactions?: boolean;
  /**
   * Order of top-level comments. `oldest` (default) preserves the existing
   * chronological display; `best` ranks by Wilson-scored reactions (implies
   * `reactions`). Replies always stay chronological.
   */
  sort?: "oldest" | "best";
}
interface GetCommentsResult {
  items: PublicComment[];
  total: number;
}
/**
 * Get approved comments for a content item.
 *
 * @example
 * ```ts
 * import { getComments } from "@premium-cms/emdash";
 *
 * const { items, total } = await getComments({
 *   collection: "posts",
 *   contentId: post.id,
 *   threaded: true,
 * });
 * ```
 */
declare function getComments(options: GetCommentsOptions): Promise<GetCommentsResult>;
/**
 * Get the count of approved comments for a content item.
 *
 * @example
 * ```ts
 * import { getCommentCount } from "@premium-cms/emdash";
 *
 * const count = await getCommentCount("posts", post.id);
 * ```
 */
declare function getCommentCount(collection: string, contentId: string): Promise<number>;
//#endregion
//#region src/menus/types.d.ts
/**
 * Menu item types
 */
type MenuItemType = string;
/**
 * Menu item as returned to templates (with resolved URL)
 */
interface MenuItem {
  id: string;
  label: string;
  url: string;
  target?: string;
  titleAttr?: string;
  cssClasses?: string;
  children: MenuItem[];
}
/**
 * Menu as returned to templates
 */
interface Menu {
  id: string;
  name: string;
  label: string;
  items: MenuItem[];
  locale: string;
  translationGroup: string | null;
}
/**
 * Input for creating a menu item
 */
interface CreateMenuItemInput {
  type: MenuItemType;
  label: string;
  /**
   * Identifier of the referenced entity. For `reference_collection` items it is
   * the content's translation_group (locale-agnostic); for `taxonomy` items it
   * is the term's translation_group.
   */
  referenceCollection?: string;
  referenceId?: string;
  customUrl?: string;
  target?: string;
  titleAttr?: string;
  cssClasses?: string;
  parentId?: string;
  sortOrder?: number;
}
/**
 * Input for updating a menu item
 */
interface UpdateMenuItemInput {
  label?: string;
  customUrl?: string;
  target?: string;
  titleAttr?: string;
  cssClasses?: string;
  parentId?: string | null;
  sortOrder?: number;
}
/**
 * Input for creating a menu
 */
interface CreateMenuInput {
  name: string;
  label: string;
  locale?: string;
  /** When set, links the new menu into an existing translation_group. */
  translationOf?: string;
}
/**
 * Input for updating a menu
 */
interface UpdateMenuInput {
  label?: string;
}
/**
 * Input for reordering menu items
 */
interface ReorderMenuItemsInput {
  items: Array<{
    id: string;
    parentId: string | null;
    sortOrder: number;
  }>;
}
//#endregion
//#region src/menus/index.d.ts
interface MenuQueryOptions {
  /** Override the locale used for the lookup. When omitted, the locale comes
   * from the request context or the configured defaultLocale. */
  locale?: string;
}
/**
 * Get a menu by name with resolved URLs.
 *
 * @example
 * ```ts
 * const menu = await getMenu("primary");
 * const menuEs = await getMenu("primary", { locale: "es" });
 * ```
 */
declare function getMenu(name: string, options?: MenuQueryOptions): Promise<Menu | null>;
/**
 * Get all menus (without items, locale-filtered — for admin list / site nav
 * summaries). When no locale is configured, returns menus across all locales.
 */
declare function getMenus(options?: MenuQueryOptions): Promise<Array<{
  id: string;
  name: string;
  label: string;
  locale: string;
}>>;
//#endregion
//#region src/bylines/index.d.ts
/**
 * Get a byline by ID.
 *
 * @example
 * ```ts
 * import { getByline } from "@premium-cms/emdash";
 *
 * const byline = await getByline("01HXYZ...");
 * if (byline) {
 *   console.log(byline.displayName);
 * }
 * ```
 */
declare function getByline(id: string): Promise<BylineSummary | null>;
/**
 * Get a byline by slug.
 *
 * Standalone identity lookup (e.g. rendering an author profile page). Walks
 * the configured locale fallback chain — same pattern as `getMenu` and
 * `getTerm`, see PR #916. Returns the first match found, walking
 * `[requestedLocale, ...fallbacks, defaultLocale]` in order.
 *
 * Note: this is intentionally different from credit hydration on a content
 * entry (`getEntryBylines`), which is strict per locale with no fallback.
 * The distinction: identity lookups answer "give me this byline", and
 * falling back to another locale's display name is acceptable. Credit
 * hydration answers "what should render on this entry", where falling back
 * silently surfaces a stale-locale name and contradicts editorial intent.
 *
 * @example
 * ```ts
 * import { getBylineBySlug } from "@premium-cms/emdash";
 *
 * const byline = await getBylineBySlug("jane-doe", { locale: "de-de" });
 * if (byline) {
 *   console.log(byline.displayName);
 * }
 * ```
 */
declare function getBylineBySlug(slug: string, options?: {
  locale?: string;
}): Promise<BylineSummary | null>;
/**
 * Get content entries credited to a byline, in any credit position.
 *
 * Unlike filtering on the content table's `primary_byline_id` column (which
 * only finds entries where the byline is the first/primary credit), this
 * matches every explicit credit recorded in `_emdash_content_bylines`, so
 * co-authored entries where the byline is a secondary credit are included.
 *
 * `byline` is matched against the byline's `translation_group` (the value
 * stored on credits since migration 040), so a single credit spans every
 * locale variant of the byline. Pass `byline.translationGroup ?? byline.id`
 * from `getByline` / `getBylineBySlug`. An array matches any of the given
 * bylines (OR).
 *
 * The result respects the active locale, status, ordering, and eager
 * hydration of `getEmDashCollection`.
 *
 * @example
 * ```ts
 * import { getBylineBySlug, getEntriesByByline } from "@premium-cms/emdash";
 *
 * const byline = await getBylineBySlug("jane-doe");
 * if (byline) {
 *   const posts = await getEntriesByByline("posts", byline.translationGroup ?? byline.id, {
 *     orderBy: { published_at: "desc" },
 *   });
 * }
 * ```
 *
 * @param collection - The collection slug (e.g. "posts")
 * @param byline - A byline translation group, or an array of them (OR)
 * @param options - Optional locale, ordering, status, and limit
 */
declare function getEntriesByByline(collection: string, byline: string | string[], options?: {
  locale?: string;
  orderBy?: Record<string, "asc" | "desc">;
  status?: "draft" | "published" | "archived";
  limit?: number;
}): Promise<Array<{
  id: string;
  data: Record<string, unknown>;
}>>;
//#endregion
//#region src/taxonomies/types.d.ts
/**
 * Taxonomy types for EmDash CMS
 */
/**
 * Taxonomy definition - describes a taxonomy like "category" or "tag"
 */
interface TaxonomyDef {
  id: string;
  name: string;
  label: string;
  labelSingular?: string;
  hierarchical: boolean;
  collections: string[];
  locale: string;
  translationGroup: string | null;
}
/**
 * Taxonomy term - a specific term within a taxonomy (e.g., "News" in "category")
 */
interface TaxonomyTerm {
  id: string;
  name: string;
  slug: string;
  label: string;
  parentId?: string;
  description?: string;
  children: TaxonomyTerm[];
  count?: number;
  locale: string;
  translationGroup: string | null;
}
/**
 * Flat version for DB row
 */
interface TaxonomyTermRow {
  id: string;
  name: string;
  slug: string;
  label: string;
  parent_id: string | null;
  data: string | null;
  locale: string;
  translation_group: string | null;
}
/**
 * Input for creating a term
 */
interface CreateTermInput {
  slug: string;
  label: string;
  parentId?: string;
  description?: string;
  locale?: string;
  /** When set, links the new term into an existing translation_group (sourced
   * from the term being translated). */
  translationOf?: string;
}
/**
 * Input for updating a term
 */
interface UpdateTermInput {
  slug?: string;
  label?: string;
  parentId?: string | null;
  description?: string;
}
//#endregion
//#region src/taxonomies/index.d.ts
interface TaxonomyQueryOptions {
  locale?: string;
}
interface TaxonomyTermsOptions extends TaxonomyQueryOptions {
  /**
   * Populate each term's `count`. Counts aggregate the whole
   * `content_taxonomies` pivot against every declared collection, so callers
   * that don't render a count should opt out. Defaults to `true`.
   */
  includeCounts?: boolean;
}
/** Invalidate cached taxonomy term data and any content that hydrates terms. */
declare function invalidateTermCache(): void;
/**
 * Get every taxonomy definition. Definitions are per-locale (one row per
 * locale inside the same translation_group) — by default we resolve to the
 * active locale.
 *
 * Two-tier cache: per-request via `requestCached` (so a single render that
 * hydrates terms for several collections pays at most one call), then
 * per-isolate via the global holder (so warm renders issue zero queries).
 * The `requestCached` key is unchanged so `getTaxonomyDef`'s peek still hits.
 */
declare function getTaxonomyDefs(options?: TaxonomyQueryOptions): Promise<TaxonomyDef[]>;
/**
 * Get a single taxonomy definition by name. Uses the fallback chain so even
 * if there is no translation for the active locale we still return something.
 *
 * If `getTaxonomyDefs()` has already loaded the full list in this request
 * (which happens during entry-term hydration on every page that renders a
 * collection), search the matching def in memory rather than running a
 * second query against `_emdash_taxonomy_defs`.
 */
declare function getTaxonomyDef(name: string, options?: TaxonomyQueryOptions): Promise<TaxonomyDef | null>;
/**
 * All terms of a taxonomy in a specific locale (flat for non-hierarchical,
 * tree for hierarchical).
 *
 * The term list and the visible-entry counts are loaded and cached separately:
 * the list depends only on the taxonomy epoch, while the counts additionally
 * depend on every counted collection's content epoch and cost an aggregate over
 * the whole assignment pivot. Callers that don't render counts pass
 * `includeCounts: false` and skip that aggregate entirely, while still sharing
 * the term list with callers that do.
 */
declare function getTaxonomyTerms(taxonomyName: string, options?: TaxonomyTermsOptions): Promise<TaxonomyTerm[]>;
/**
 * Get a single term by (taxonomy, slug). Honours the fallback chain — if the
 * slug exists in a fallback locale, we return that row (useful for deep-linking
 * to a term page when the translation is missing).
 */
declare function getTerm(taxonomyName: string, slug: string, options?: TaxonomyQueryOptions): Promise<TaxonomyTerm | null>;
/**
 * Terms assigned to a content entry, resolved into the active locale and then
 * the configured default locale.
 */
declare function getEntryTerms(collection: string, entryId: string, taxonomyName?: string, options?: TaxonomyQueryOptions): Promise<TaxonomyTerm[]>;
/**
 * Terms for multiple entries of one taxonomy, single query.
 */
declare function getTermsForEntries(collection: string, entryIds: string[], taxonomyName: string, options?: TaxonomyQueryOptions): Promise<Map<string, TaxonomyTerm[]>>;
/**
 * Batch-fetch terms for multiple entries across ALL taxonomies in one query.
 * Primes the request-cache for subsequent per-entry calls to `getEntryTerms`.
 */
declare function getAllTermsForEntries(collection: string, entryIds: string[], options?: TaxonomyQueryOptions): Promise<Map<string, Record<string, TaxonomyTerm[]>>>;
/**
 * Get entries by term. Both the lookup (term slug in the active locale) and
 * the content query respect the active locale.
 */
declare function getEntriesByTerm(collection: string, taxonomyName: string, termSlug: string, options?: TaxonomyQueryOptions): Promise<Array<{
  id: string;
  data: Record<string, unknown>;
}>>;
//#endregion
//#region src/widgets/types.d.ts
type WidgetType = "content" | "menu" | "component";
interface Widget {
  id: string;
  type: WidgetType;
  title?: string;
  content?: PortableTextBlock$1[];
  menuName?: string;
  componentId?: string;
  componentProps?: Record<string, unknown>;
}
interface WidgetArea {
  id: string;
  name: string;
  label: string;
  description?: string;
  widgets: Widget[];
}
interface WidgetComponentDef {
  id: string;
  label: string;
  description?: string;
  props: Record<string, PropDef>;
}
interface PropDef {
  type: "string" | "number" | "boolean" | "select";
  label: string;
  default?: unknown;
  options?: Array<{
    value: string;
    label: string;
  }>;
}
interface CreateWidgetAreaInput {
  name: string;
  label: string;
  description?: string;
}
interface CreateWidgetInput {
  type: WidgetType;
  title?: string;
  content?: PortableTextBlock$1[];
  menuName?: string;
  componentId?: string;
  componentProps?: Record<string, unknown>;
}
interface UpdateWidgetInput extends Partial<CreateWidgetInput> {}
interface ReorderWidgetsInput {
  widgetIds: string[];
}
//#endregion
//#region src/widgets/index.d.ts
/**
 * Get a widget area by name, with all its widgets.
 *
 * Single query with a left join rather than area-then-widgets so the
 * common case costs one round-trip. An area with no widgets yields one
 * row with null widget columns, which we skip when mapping.
 */
declare function getWidgetArea(name: string): Promise<WidgetArea | null>;
/**
 * Get all widget areas with their widgets
 */
declare function getWidgetAreas(): Promise<WidgetArea[]>;
/**
 * Get available widget components (for admin UI)
 */
declare function getWidgetComponents(): WidgetComponentDef[];
//#endregion
//#region src/search/types.d.ts
/**
 * Search Types
 *
 * Type definitions for the EmDash search system.
 */
/**
 * Search configuration for a collection
 */
declare const SEARCH_TOKENIZERS: readonly ["porter unicode61", "unicode61", "trigram"];
type SearchTokenizer = (typeof SEARCH_TOKENIZERS)[number];
interface SearchConfig {
  /** Whether search is enabled for this collection */
  enabled: boolean;
  /** Field weights for ranking (higher = more important) */
  weights?: Record<string, number>;
  /** Field slug used as the result title, from the collection's titleField. */
  titleField?: string;
  /** FTS5 tokenizer configuration (defaults to English Porter stemming) */
  tokenize?: SearchTokenizer;
}
/**
 * Options for search queries
 */
interface SearchOptions {
  /** Collections to search (defaults to all searchable collections) */
  collections?: string[];
  /** Filter by content status (defaults to 'published') */
  status?: string;
  /** Filter by locale (omit to search all locales) */
  locale?: string;
  /** Maximum results to return (defaults to 20) */
  limit?: number;
  /** Pagination cursor */
  cursor?: string;
}
/**
 * Options for collection-specific search
 */
interface CollectionSearchOptions {
  /** Filter by content status (defaults to 'published') */
  status?: string;
  /** Filter by locale (omit to search all locales) */
  locale?: string;
  /** Maximum results to return (defaults to 20) */
  limit?: number;
  /** Pagination cursor */
  cursor?: string;
}
/**
 * A single search result
 */
interface SearchResult {
  /** Collection the result belongs to */
  collection: string;
  /** Entry ID */
  id: string;
  /** Entry slug */
  slug: string | null;
  /** Content locale */
  locale: string;
  /** Entry title (if available) */
  title?: string;
  /**
   * Highlighted snippet showing match context.
   *
   * Sanitized server-side to be safe for `set:html` / `innerHTML`:
   * all HTML metacharacters in the source text are escaped, and
   * matched terms are wrapped in literal `<mark>...</mark>` tags
   * (the only HTML the snippet is allowed to contain).
   */
  snippet?: string;
  /** Relevance score (higher = more relevant) */
  score: number;
}
/**
 * Response from a search query
 */
interface SearchResponse {
  /** Search results */
  items: SearchResult[];
  /** Cursor for next page of results */
  nextCursor?: string;
}
/**
 * Options for suggestion/autocomplete queries
 */
interface SuggestOptions {
  /** Collections to search (defaults to all searchable collections) */
  collections?: string[];
  /** Filter by locale (omit to search all locales) */
  locale?: string;
  /** Maximum suggestions to return (defaults to 5) */
  limit?: number;
}
/**
 * A single suggestion result
 */
interface Suggestion {
  /** Collection the suggestion belongs to */
  collection: string;
  /** Entry ID */
  id: string;
  /** Entry slug, when available */
  slug?: string | null;
  /** Entry title */
  title: string;
}
/**
 * Search index statistics
 */
interface SearchStats {
  collections: Record<string, {
    /** Number of indexed entries */indexed: number; /** When the index was last rebuilt */
    lastRebuilt?: string;
  }>;
}
//#endregion
//#region src/search/fts-manager.d.ts
/**
 * FTS5 Manager
 *
 * Handles creation, deletion, and management of FTS5 virtual tables
 * for full-text search on content collections.
 */
declare class FTSManager {
  private db;
  constructor(db: Kysely<Database>);
  /**
   * Validate a collection slug and its searchable field names.
   * Must be called before any raw SQL interpolation.
   */
  private validateInputs;
  /**
   * Get the FTS table name for a collection
   * Uses _emdash_ prefix to clearly mark as internal/system table
   */
  getFtsTableName(collectionSlug: string): string;
  /**
   * Get the content table name for a collection
   */
  getContentTableName(collectionSlug: string): string;
  /**
   * Check if an FTS table exists for a collection
   */
  ftsTableExists(collectionSlug: string): Promise<boolean>;
  /**
   * Create an FTS5 virtual table for a collection.
   * FTS5 is SQLite-only; on other dialects this is a no-op.
   *
   * @param collectionSlug - The collection slug
   * @param searchableFields - Array of field names to index
   * @param weights - Optional field weights for ranking
   * @param tokenize - Optional FTS5 tokenizer configuration
   */
  createFtsTable(collectionSlug: string, searchableFields: string[], _weights?: Record<string, number>, tokenize?: SearchTokenizer): Promise<void>;
  /**
   * SQL expression producing the indexed value for one searchable field.
   *
   * Portable Text fields are stored as JSON; indexing the raw JSON pollutes
   * the index with structural tokens (`_type`, style values like `normal`,
   * `_key` ULIDs) and makes snippets show JSON fragments. Extract the prose
   * instead: every JSON string under a `text`, `alt`, `caption`, or `code`
   * key (span text, image alt/caption, code blocks). This is a superset of
   * `extractPlainText` in text-extraction.ts, which walks only known block
   * shapes — the SQL variant takes those keys at any depth, so search and
   * the extractPlainText consumers (vectorize/ai-search) can see different
   * text for the same document. Only JSON documents
   * (arrays/objects) are extracted; legacy rows holding a bare string or a
   * JSON scalar (`Some title`, `2024`) are indexed as-is. Extraction must
   * live in SQL because the sync triggers cannot call into JS.
   *
   * `ref` must be a validated column reference (`NEW.x`, `OLD.x`, `"x"`).
   */
  private searchValueExpr;
  /**
   * Field type per slug for a collection, for choosing the indexed-value
   * expression. Fields missing from the schema fall back to raw indexing.
   */
  private getFieldTypes;
  /**
   * Create triggers to keep FTS table in sync with content table.
   *
   * The insert and update triggers only add rows to the FTS index when
   * `deleted_at IS NULL`. This keeps soft-deleted content out of the
   * search index and ensures the FTS row count matches the non-deleted
   * content count (which `verifyAndRepairIndex` relies on).
   *
   * The FTS table stores its own values (no `content=` option), so removal
   * is a plain `DELETE FROM fts WHERE rowid = OLD.rowid` — a harmless no-op
   * for rows that were never indexed (soft-deleted content). The
   * external-content `'delete'`-command choreography and its corruption
   * modes (migration 039) do not apply to self-contained tables.
   *
   * `INSERT OR REPLACE` keeps the insert path idempotent: re-running a
   * populate (D1 has no migration lock, so two isolates can race) converges
   * on one index row per content row instead of failing on the rowid
   * constraint.
   *
   * The trigger SQL emitted here MUST stay in lock-step with migration
   * `064_fts_plain_text.ts`. If this changes again, add a new migration
   * rather than editing shipped ones — migrations are forward-only.
   */
  private createTriggers;
  /**
   * Drop triggers for a collection
   */
  private dropTriggers;
  /**
   * Drop the FTS table and triggers for a collection
   */
  dropFtsTable(collectionSlug: string): Promise<void>;
  /**
   * Rebuild the FTS index for a collection
   *
   * This is useful after bulk imports or if the index gets out of sync.
   */
  rebuildIndex(collectionSlug: string, searchableFields: string[], weights?: Record<string, number>, tokenize?: SearchTokenizer): Promise<void>;
  /**
   * Populate the FTS table from existing content.
   *
   * `INSERT OR REPLACE` so a concurrent double-populate (D1 has no
   * migration lock) converges instead of failing on the rowid constraint.
   */
  populateFromContent(collectionSlug: string, searchableFields: string[]): Promise<void>;
  /**
   * Get the search configuration for a collection
   */
  getSearchConfig(collectionSlug: string): Promise<SearchConfig | null>;
  /**
   * Update the search configuration for a collection
   */
  setSearchConfig(collectionSlug: string, config: SearchConfig): Promise<void>;
  /**
   * Get searchable fields for a collection
   */
  getSearchableFields(collectionSlug: string): Promise<string[]>;
  /**
   * Whether a collection has a user-defined `title` field.
   *
   * `title` is not a system column on `ec_*` tables -- it exists only when a
   * collection defines a field with slug `title`. Search and suggestion SQL
   * that selects `c.title` must check this first; otherwise collections
   * without a title field raise "no such column: c.title".
   */
  hasTitleColumn(collectionSlug: string): Promise<boolean>;
  /**
   * Bulk variant of `hasTitleColumn()`: which of the given collections have
   * a user-defined `title` field. One query instead of one `hasTitleColumn`
   * round-trip pair per collection -- callers that check this once per
   * collection in a loop (multi-collection search, suggestions) should use
   * this instead (AGENTS.md: "one query beats two").
   */
  getCollectionsWithTitleColumn(collectionSlugs: string[]): Promise<Set<string>>;
  /**
   * Enable search for a collection.
   *
   * Uses rebuildIndex to ensure a clean state -- drop any existing FTS
   * table/triggers, recreate them, and populate from content. This avoids
   * duplicate rows when triggers have already populated the index (e.g.
   * during seeding where content is inserted before search is enabled).
   */
  enableSearch(collectionSlug: string, options?: {
    weights?: Record<string, number>;
    tokenize?: SearchTokenizer;
  }): Promise<void>;
  /**
   * Disable search for a collection
   *
   * Drops the FTS table and triggers.
   */
  disableSearch(collectionSlug: string): Promise<void>;
  /**
   * Get index statistics for a collection
   */
  getIndexStats(collectionSlug: string): Promise<{
    indexed: number;
    lastRebuilt?: string;
  } | null>;
  /**
   * Verify FTS index integrity and rebuild if drift is detected.
   *
   * Cheap belt-and-braces check, run lazily on the first search request
   * per isolate. The expensive cases (corrupted indexes from pre-fix
   * EmDash versions, broken legacy triggers) are handled at boot time by
   * migration `039_fix_fts5_triggers`, not here. This routine sticks to:
   *
   *   1. FTS table missing while config says search is enabled -> rebuild.
   *   2. Row count mismatch between content table and FTS docsize -> rebuild.
   *
   * Returns true if the index was rebuilt, false if it was healthy.
   */
  verifyAndRepairIndex(collectionSlug: string): Promise<boolean>;
  /**
   * Verify and repair FTS indexes for all search-enabled collections.
   *
   * Intended to run at startup to auto-heal any corruption from
   * previous process crashes.
   */
  verifyAndRepairAll(): Promise<number>;
}
//#endregion
//#region src/search/query.d.ts
/**
 * Search across multiple collections
 *
 * Public API that auto-injects the database.
 *
 * @param query - Search query (FTS5 syntax supported)
 * @param options - Search options
 * @returns Search results with pagination
 *
 * @example
 * ```typescript
 * import { search } from "@premium-cms/emdash";
 *
 * const results = await search("hello world", {
 *   collections: ["posts", "pages"],
 *   limit: 20
 * });
 * ```
 */
declare function search(query: string, options?: SearchOptions): Promise<SearchResponse>;
/**
 * Search across multiple collections (with explicit db)
 *
 * @internal Use `search()` in templates. This variant is for admin routes
 * that already have a database handle.
 *
 * @param db - Kysely database instance
 * @param query - Search query (FTS5 syntax supported)
 * @param options - Search options
 * @returns Search results with pagination
 */
declare function searchWithDb(db: Kysely<Database>, query: string, options?: SearchOptions): Promise<SearchResponse>;
/**
 * Search within a single collection
 *
 * @param db - Kysely database instance
 * @param collection - Collection slug
 * @param query - Search query (FTS5 syntax supported)
 * @param options - Search options
 * @returns Search results with pagination
 *
 * @example
 * ```typescript
 * const results = await searchCollection(db, "posts", "hello world", {
 *   limit: 10
 * });
 * ```
 */
declare function searchCollection(db: Kysely<Database>, collection: string, query: string, options?: CollectionSearchOptions): Promise<SearchResponse>;
/**
 * Get search suggestions for autocomplete
 *
 * @param db - Kysely database instance
 * @param query - Partial search query
 * @param options - Suggestion options
 * @returns Array of suggestions
 */
declare function getSuggestions(db: Kysely<Database>, query: string, options?: SuggestOptions): Promise<Suggestion[]>;
/**
 * Get search statistics for all collections
 */
declare function getSearchStats(db: Kysely<Database>): Promise<SearchStats>;
//#endregion
//#region src/search/text-extraction.d.ts
/**
 * Extract plain text from Portable Text blocks
 *
 * Uses @portabletext/toolkit's toPlainText for standard blocks,
 * plus extracts text from custom block types (code, images with alt/caption).
 *
 * @param blocks - Array of Portable Text blocks (or a JSON string)
 * @returns Plain text content
 *
 * @example
 * ```typescript
 * const text = extractPlainText([
 *   {
 *     _type: "block",
 *     _key: "abc",
 *     children: [{ _type: "span", _key: "s1", text: "Hello World" }]
 *   }
 * ]);
 * // Returns: "Hello World"
 * ```
 */
declare function extractPlainText(blocks: PortableTextBlock[] | string | null | undefined): string;
/**
 * Extract searchable text from a content entry
 *
 * Extracts text from specified fields, handling both plain text and Portable Text.
 *
 * @param entry - Content entry data
 * @param fields - Field names to extract text from
 * @returns Object mapping field names to extracted text
 */
declare function extractSearchableFields(entry: Record<string, unknown>, fields: string[]): Record<string, string>;
//#endregion
export { MenuItem as $, PluginRouteError as $n, handleContentDiscardDraft as $r, EditFieldMeta as $t, WidgetType as A, EmDashDatabaseError as Ai, PortableTextHtmlBlock as An, getCollectionInfo as Ar, PluginManager as At, CreateTermInput as B, getSection as Bn, handleMediaUpdate as Br, invalidateBylineObjectCache as Bt, CreateWidgetInput as C, PluginStorageRepository as Ci, isSafeHref as Cn, getSandboxRouteErrorEnvelope as Cr, generatePreviewToken as Ct, Widget as D, MediaRepository as Di, portableTextToProsemirror as Dn, LocalStorageConfig as Dr, SandboxNotAvailableError as Dt, UpdateWidgetInput as E, MediaItem as Ei, hashString as En, getStoredConfig as Er, NoopSandboxRunner as Et, getTaxonomyDefs as F, PortableTextTextBlock as Fn, MediaResponse as Fr, CacheNamespace as Ft, getByline as G, SectionSource as Gn, handleRevisionRestore as Gr, invalidateSchemaObjectCache as Gt, TaxonomyTerm as H, CreateSectionInput as Hn, RevisionResponse as Hr, invalidateCommentObjectCache as Ht, getTaxonomyTerms as I, PortableTextUnknownBlock as In, handleMediaCreate as Ir, CachedQueryOptions as It, getMenu as J, MediaUsageMaintenanceResult as Jn, handleContentCompare as Jr, after as Jt, getBylineBySlug as K, UpdateSectionInput as Kn, generateManifest as Kr, invalidateTaxonomyObjectCache as Kt, getTerm as L, ProseMirrorDocument as Ln, handleMediaDelete as Lr, cachedQuery as Lt, getEntriesByTerm as M, PortableTextLinkMark as Mn, SchemaRegistry as Mr, ValidatedPluginManifest as Mt, getEntryTerms as N, PortableTextMarkDef as Nn, markContentMediaUsageCollectionStaleSafely as Nr, pluginManifestSchema as Nt, WidgetArea as O, ContentRepository as Oi, prosemirrorToPortableText as On, S3StorageConfig as Or, createNoopSandboxRunner as Ot, getTaxonomyDef as P, PortableTextSpan as Pn, MediaListResponse as Pr, definePlugin as Pt, Menu as Q, SystemCleanupFn as Qn, handleContentDelete as Qr, ContentEntry as Qt, getTermsForEntries as R, ProseMirrorMark as Rn, handleMediaGet as Rr, contentNamespace as Rt, CreateWidgetAreaInput as S, CompoundSelectLimitedAdapter as Si, getDb as Sn, getSandboxRouteErrorDetails as Sr, VerifyPreviewTokenResult as St, ReorderWidgetsInput as T, CreateMediaInput as Ti, computeContentHash as Tn, PluginDescriptor as Tr, verifyPreviewToken as Tt, TaxonomyTermRow as U, GetSectionsOptions as Un, handleRevisionGet as Ur, invalidateMenuObjectCache as Ut, TaxonomyDef as V, getSections as Vn, RevisionListResponse as Vr, invalidateCollectionCache as Vt, UpdateTermInput as W, Section as Wn, handleRevisionList as Wr, invalidateObjectCache as Wt, CreateMenuInput as X, PublishedRef as Xn, handleContentCountTrashed as Xr, CollectionFilter as Xt, getMenus as Y, SandboxedPluginEntry as Yn, handleContentCountScheduled as Yr, CacheHint as Yt, CreateMenuItemInput as Z, CronScheduler as Zn, handleContentCreate as Zr, CollectionResult as Zt, SuggestOptions as _, FieldDefinition as _i, EntryData as _n, SandboxUnavailableError as _r, buildPreviewUrl as _t, search as a, handleContentPermanentDelete as ai, TranslationsResult as an, createHookPipeline as ar, GetCommentsResult as at, getWidgetAreas as b, ImageValue as bi, WhereValue as bn, createSandboxRouteError as br, PreviewTokenPayload as bt, FTSManager as c, handleContentSchedule as ci, getEmDashEntry as cn, CronAccessImpl as cr, getColorScheme as ct, SearchConfig as d, handleContentUnschedule as di, CMSAnnotation as dn, SandboxOptions as dr, getSiteSetting as dt, handleContentDuplicate as ei, EmDashCollections as en, RouteCallerInput as er, MenuItemType as et, SearchOptions as f, handleContentUpdate as fi, EditProxy as fn, SandboxRouteErrorCode as fr, getSiteSettings as ft, SearchTokenizer as g, image as gi, CollectionFilter$1 as gn, SandboxRunnerFactory as gr, GetPreviewUrlOptions as gt, SearchStats as h, file as hi, createNoop as hn, SandboxRunner as hr, isPreviewRequest as ht, getSuggestions as i, handleContentListTrashed as ii, TranslationSummary as in, HookResult as ir, GetCommentsOptions as it, getAllTermsForEntries as j, PortableTextImageBlock as jn, SchemaError as jr, createPluginManager as jt, WidgetComponentDef as k, DatabaseConfig as ki, PortableTextCodeBlock as kn, StorageDescriptor as kr, NodeCronScheduler as kt, CollectionSearchOptions as l, handleContentTranslations as li, getTranslations as ln, SandboxEmailMessage as lr, getPluginSetting as lt, SearchResult as m, reference as mi, createEditable as mn, SandboxRouteErrorEnvelope as mr, getPreviewToken as mt, extractSearchableFields as n, handleContentGetIncludingTrashed as ni, InferCollectionData as nn, EmailPipeline as nr, UpdateMenuInput as nt, searchCollection as o, handleContentPublish as oi, getEditMeta as on, createHttpAccess as or, getCommentCount as ot, SearchResponse as p, portableText as pi, FieldAnnotation as pn, SandboxRouteErrorDetails as pr, setSiteSettings as pt, getEntriesByByline as q, EmDashRuntime as qn, handleContentAuthors as qr, WaitUntilFn as qt, getSearchStats as r, handleContentList as ri, ResolvePathResult as rn, HookPipeline as rr, UpdateMenuItemInput as rt, searchWithDb as s, handleContentRestore as si, getEmDashCollection as sn, createUnrestrictedHttpAccess as sr, getComments as st, extractPlainText as t, handleContentGet as ti, EntryResult as tn, RouteMeta as tr, ReorderMenuItemsInput as tt, SEARCH_TOKENIZERS as u, handleContentUnpublish as ui, resolveEmDashPath as un, SandboxEmailSendCallback as ur, getPluginSettings as ut, Suggestion as v, FieldUIHints as vi, EntryFilter as vn, SandboxedPluginInstance as vr, getPreviewUrl as vt, PropDef as w, UserRepository as wi, sanitizeHref as wn, EmDashConfig as wr, parseContentId as wt, getWidgetComponents as x, PortableTextBlock$1 as xi, emdashLoader as xn, createSandboxRouteErrorEnvelope as xr, VerifyPreviewTokenOptions as xt, getWidgetArea as y, FileValue as yi, WhereRange as yn, SerializedRequest as yr, GeneratePreviewTokenOptions as yt, invalidateTermCache as z, ProseMirrorNode as zn, handleMediaList as zr, contentNamespaces as zt };
//# sourceMappingURL=index-HRJ8DhHY.d.mts.map