@manablox/db 0.2.0 → 0.4.0

package/dist/index-BLAkQMJT.d.ts

@@ -0,0 +1,877 @@
+import { T as webhooks, U as contents, W as publishedContents, _ as UserRow, a as ContentApprovalRow, b as index_d_exports, d as MenuItemRow, f as MenuRow, g as SpaceRow, h as RoleRow, i as AuditEntryRow, l as ContentVersionRow, m as PushSubscriptionRow, p as NotificationRow, r as AssetVariantRow, s as ContentRow, t as AssetRow, u as MembershipRow, v as WorkflowRow, w as webhookDeliveries, y as WorkflowRunRow } from "./index-DrNMGM9N.js";
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import { SQL, SQL as SQL$1 } from "drizzle-orm";
+import { PgColumn, PgColumn as PgColumn$1, PgTable } from "drizzle-orm/pg-core";
+import { ApprovalStatus, AuditAction, AuditActor, AuditActorKind, AuditChange, AuditSortField, AuditTargetKind, ContentStatus, ContentTypeDefinition, ContentTypeInput, ContentTypeRegistry, DatabaseConfig, FilterOperator, Loose, NotificationKind, NotificationPreferences, WorkflowCursor, WorkflowRunContext, WorkflowRunStatus, WorkflowSelection, WorkflowStep, WorkflowStepLog, WorkflowTrigger } from "@manablox/core";
+//#region src/client.d.ts
+type Database = PostgresJsDatabase<typeof index_d_exports>;
+/** What `db.transaction((tx) => …)` hands its callback. */
+type Transaction = Parameters<Parameters<Database['transaction']>[0]>[0];
+/**
+ * Anything a query can run on. Repository internals take this so the same helper serves
+ * a call inside a transaction and one outside it, without casting `tx` to `Database`.
+ */
+type Executor = Database | Transaction;
+type Sql = ReturnType<typeof postgres>;
+interface DatabaseHandle {
+  db: Database;
+  sql: Sql;
+  close: () => Promise<void>;
+}
+interface DatabaseOptions {
+  /** Called once per statement sent to Postgres. Used by tests to assert query counts. */
+  onQuery?: (query: string) => void;
+}
+declare function createDatabase(config: DatabaseConfig, options?: DatabaseOptions): DatabaseHandle;
+//#endregion
+//#region src/query.d.ts
+/**
+ * Both content tables share a column set, so one filter builder serves the draft and
+ * the published projection. Typing the parameter as the union (rather than `PgTable`)
+ * keeps real column references, which is what lets Drizzle bind arrays and UUIDs
+ * correctly instead of stringifying them into the SQL text.
+ */
+type ContentTable = typeof contents | typeof publishedContents;
+/**
+ * Note on `?: T | undefined` throughout the input types in this file: the workspace runs
+ * with `exactOptionalPropertyTypes`, under which a bare `?:` accepts an absent property
+ * but rejects an explicit `undefined`. Validators (Zod, and any Standard Schema) produce
+ * exactly that explicit `undefined` for optional fields, so input DTOs widen while the
+ * domain types they feed stay strict.
+ */
+interface FieldFilter {
+  /** Field machine name on the content type. */
+  name: string;
+  op: FilterOperator;
+  value?: unknown | undefined;
+}
+interface ContentFilter {
+  spaceId?: string | undefined;
+  /** Content type ids. */
+  typeIds?: string[] | undefined;
+  locale?: string | undefined;
+  status?: 'draft' | 'published' | 'archived' | undefined;
+  ids?: string[] | undefined;
+  parentId?: string | null | undefined;
+  /** Restrict to the subtree below this content id (inclusive of its descendants). */
+  under?: string | undefined;
+  slug?: string | undefined;
+  permalink?: string | undefined;
+  localizationId?: string | undefined;
+  /** Full-text query against `title` + field contributions. */
+  search?: string | undefined;
+  fields?: FieldFilter[] | undefined;
+}
+interface ContentSort {
+  by: 'position' | 'title' | 'createdAt' | 'updatedAt' | 'publishedAt' | 'slug';
+  direction: 'asc' | 'desc';
+}
+interface Pagination {
+  limit: number;
+  offset: number;
+}
+/**
+ * Translates a filter into SQL. Every field predicate is checked against the field
+ * type's declared `filters` list first: an unsupported operator is a 400, and every
+ * supported one has an index behind it.
+ */
+declare function buildContentWhere(table: ContentTable, filter: ContentFilter, registry: ContentTypeRegistry): SQL | undefined;
+declare function buildOrderBy(sorts: ContentSort[]): SQL;
+//#endregion
+//#region src/pagination.d.ts
+interface Paginated<T> {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+/**
+ * One page of a table plus the total, in one round trip: a window `count(*) over ()`
+ * rides along with the rows. A page past the end comes back empty and so carries no
+ * count; only then is the total asked for separately, so a caller paging by `total`
+ * still learns the true size.
+ */
+declare function paginate<TTable extends PgTable>(db: Executor, table: TTable, options: {
+  where?: SQL | undefined;
+  orderBy: SQL | PgColumn | (SQL | PgColumn)[];
+  pagination: Pagination;
+}): Promise<Paginated<TTable['$inferSelect']>>;
+//#endregion
+//#region src/repositories/asset.d.ts
+interface AssetWriteData {
+  id?: string | undefined;
+  spaceId: string;
+  driver: string;
+  key: string;
+  filename: string;
+  name: string;
+  mimeType: string;
+  size: number;
+  width?: number | null | undefined;
+  height?: number | null | undefined;
+  duration?: number | null | undefined;
+  checksum?: string | null | undefined;
+  alt?: string | null | undefined;
+  title?: string | null | undefined;
+  meta?: Record<string, unknown> | undefined;
+  actorId?: string | null | undefined;
+}
+interface AssetFilter {
+  spaceId: string;
+  /** Prefix match on the mime type, e.g. `image/`. */
+  mimeType?: string | undefined;
+  search?: string | undefined;
+}
+declare class AssetRepository {
+  private readonly db;
+  constructor(db: Database);
+  findById(id: string): Promise<AssetRow | null>;
+  /**
+   * `spaceId` is not an optimisation. On the public instance an asset id is the only
+   * thing a caller supplies, and without this predicate any id resolves — including one
+   * belonging to another tenant sharing the process.
+   */
+  findManyByIds(ids: string[], spaceId?: string | null): Promise<AssetRow[]>;
+  findByChecksum(spaceId: string, checksum: string): Promise<AssetRow | null>;
+  list(filter: AssetFilter, pagination: Pagination): Promise<Paginated<AssetRow>>;
+  create(data: AssetWriteData): Promise<AssetRow>;
+  update(id: string, data: Loose<Pick<AssetWriteData, 'name' | 'alt' | 'title' | 'meta'>>): Promise<AssetRow>;
+  delete(id: string): Promise<AssetRow | null>;
+  /** Timestamps an import carries over; `create()` can only stamp the moment of import. */
+  restoreTimestamps(id: string, createdAt: Date, updatedAt: Date): Promise<void>;
+  variants(assetIds: string[]): Promise<AssetVariantRow[]>;
+  findVariant(assetId: string, preset: string, format: string): Promise<AssetVariantRow | null>;
+  /** Drops every variant row; the caller removes the files. */
+  deleteVariants(assetId: string): Promise<void>;
+  addVariant(data: {
+    assetId: string;
+    preset: string;
+    format: string;
+    key: string;
+    width?: number | null;
+    height?: number | null;
+    size: number;
+  }): Promise<AssetVariantRow>;
+}
+//#endregion
+//#region src/repositories/asset-usage.d.ts
+/**
+ * The asset → document reachability index.
+ *
+ * `published` tracks the *published projection*, not the draft: a draft that adds an
+ * image does not make that image public, and a draft that removes one does not make it
+ * private until the change is published. Every method below preserves that distinction,
+ * which is why the column exists rather than the table simply holding published rows.
+ */
+declare class AssetUsageRepository {
+  private readonly db;
+  constructor(db: Database);
+  /** The subset of `assetIds` reachable from at least one published document. */
+  filterPublished(assetIds: string[]): Promise<Set<string>>;
+  forContent(contentId: string): Promise<Array<{
+    assetId: string;
+    published: boolean;
+  }>>;
+  /**
+   * Records what a *draft* references.
+   *
+   * Rows the draft dropped are removed only if they are not currently published —
+   * otherwise editing a draft would silently revoke access to an image the live page is
+   * still showing.
+   */
+  recordDraft(contentId: string, spaceId: string, assetIds: string[]): Promise<void>;
+  /**
+   * Records what the published projection references.
+   *
+   * Assets the new revision no longer uses lose their published flag but keep their row
+   * when the draft still references them, so the admin's "where is this used" view stays
+   * complete.
+   */
+  recordPublished(contentId: string, spaceId: string, assetIds: string[]): Promise<void>;
+  /** Unpublishing revokes every asset this document was keeping public. */
+  clearPublished(contentId: string): Promise<void>;
+  deleteForContent(contentId: string): Promise<void>;
+  count(): Promise<number>;
+  /**
+   * Every document with its draft and published field values, for the backfill.
+   *
+   * References are derived from field-type definitions rather than stored, so the
+   * backfill cannot be a SQL migration — it has to run inside the application.
+   */
+  backfillSource(): Promise<Array<{
+    id: string;
+    spaceId: string;
+    typeId: string;
+    draftFields: Record<string, unknown>;
+    publishedFields: Record<string, unknown> | null;
+  }>>;
+}
+//#endregion
+//#region src/repositories/audit.d.ts
+interface AuditAppendInput {
+  /** The space the action concerns; omit for an instance-wide action. */
+  spaceId?: string | null | undefined;
+  /** Who did it; the current actor (see `runAsActor`) when omitted. */
+  actor?: AuditActor | undefined;
+  action: AuditAction;
+  targetKind: AuditTargetKind;
+  targetId?: string | null | undefined;
+  targetLabel?: string | null | undefined;
+  changes?: AuditChange[] | undefined;
+  meta?: Record<string, unknown> | null | undefined;
+  at?: Date | undefined;
+}
+interface AuditFilter {
+  /** A space's entries; `null` for instance-wide entries only; absent for every entry. */
+  spaceId?: string | null | undefined;
+  actorKind?: AuditActorKind | undefined;
+  actorId?: string | undefined;
+  actions?: AuditAction[] | undefined;
+  targetKind?: AuditTargetKind | undefined;
+  targetId?: string | undefined;
+  from?: Date | undefined;
+  to?: Date | undefined;
+  /** Matched against the actor's label, the target's label and the action. */
+  search?: string | undefined;
+}
+interface AuditSort {
+  by: AuditSortField;
+  direction: 'asc' | 'desc';
+}
+/** The outcome of walking the chain: where it broke, if it did. */
+interface AuditVerification {
+  ok: boolean;
+  checked: number;
+  /** The first entry whose hash does not match, or whose `prevHash` is not its predecessor's. */
+  brokenAt: {
+    seq: number;
+    id: string;
+    reason: 'hash' | 'link';
+  } | null;
+}
+interface AuditRepositoryOptions {
+  /** Told when `record` could not write; the action itself is not undone. */
+  onError?: ((error: unknown, input: AuditAppendInput) => void) | undefined;
+  /**
+   * Told after every entry has been committed: the realtime feed listens here, because
+   * an audit entry is written for every change and only after it has happened. A
+   * listener that throws is reported to `onError`; the entry stays written.
+   */
+  onAppended?: ((row: AuditEntryRow) => void) | undefined;
+}
+/**
+ * Appends to and reads the audit log. There is no update and no delete: the table
+ * refuses both, so this class offers neither.
+ */
+declare class AuditRepository {
+  private readonly db;
+  private readonly options;
+  constructor(db: Database, options?: AuditRepositoryOptions);
+  /**
+   * Writes one entry, chained to the last. Writers are serialised on a transaction-level
+   * advisory lock, so two entries can never both claim the same predecessor; the lock
+   * is held for one read and one insert.
+   */
+  append(input: AuditAppendInput): Promise<AuditEntryRow>;
+  private write;
+  /**
+   * `append` that never throws. The write it describes has already happened; failing
+   * the request now would report an error for something that succeeded, so the failure
+   * is reported to `onError` (the host logs it) and the caller carries on.
+   */
+  record(input: AuditAppendInput): Promise<AuditEntryRow | null>;
+  findById(id: string): Promise<AuditEntryRow | null>;
+  list(filter: AuditFilter, sort?: AuditSort, pagination?: Pagination): Promise<Paginated<AuditEntryRow>>;
+  /** The entries about one thing, oldest first: a document's history. */
+  forTarget(targetKind: AuditTargetKind, targetId: string, limit?: number): Promise<AuditEntryRow[]>;
+  /**
+   * Recomputes every hash from the first entry on and checks each link to its
+   * predecessor. The chain is one across the instance, so this walks all of it, in
+   * batches; on a large log it takes a while and that is the point.
+   */
+  verify(batchSize?: number): Promise<AuditVerification>;
+  count(filter?: AuditFilter): Promise<number>;
+}
+//#endregion
+//#region src/repositories/content.d.ts
+interface ContentWriteData {
+  id?: string | undefined;
+  spaceId: string;
+  typeId: string;
+  locale: string;
+  localizationId?: string | undefined;
+  parentId?: string | null | undefined;
+  title: string;
+  slug: string;
+  fields: Record<string, unknown>;
+  searchText?: string | undefined;
+  position?: number | undefined;
+  status?: ContentStatus | undefined;
+  /** Whether the content type contributes its slug to descendants' permalinks. */
+  hasSlug: boolean;
+  actorId?: string | null | undefined;
+  /** Expected current version; a mismatch raises `content.version.conflict`. */
+  expectedVersion?: number | undefined;
+}
+interface TreeNode {
+  content: ContentRow;
+  depth: number;
+  children: TreeNode[];
+}
+declare class ContentRepository {
+  private readonly db;
+  private readonly registry;
+  constructor(db: Executor, registry: ContentTypeRegistry);
+  findById(id: string, published?: boolean): Promise<ContentRow | null>;
+  /**
+   * `spaceId` bounds a lookup by id to one tenant.
+   *
+   * The delivery API takes ids straight from the caller, so without it a public instance
+   * pinned to one space still answers for any other space's published documents.
+   */
+  findManyByIds(ids: string[], published?: boolean, spaceId?: string | null): Promise<ContentRow[]>;
+  /** Children of many parents in one query, for the tree loader. */
+  findChildrenOf(parentIds: string[], published?: boolean, spaceId?: string | null): Promise<ContentRow[]>;
+  findByPermalink(spaceId: string, locale: string, permalink: string, published?: boolean): Promise<ContentRow | null>;
+  /**
+   * The document a space nominates as its home, in one locale.
+   *
+   * `settings.homeContentId` names a single row, which belongs to one locale. Every
+   * translation of that document shares its `localizationId`, so the requested locale is
+   * resolved through that rather than by pinning one row per language.
+   */
+  findHome(spaceId: string, locale: string, published?: boolean): Promise<ContentRow | null>;
+  /**
+   * Every other row in a document's localization group — its translations.
+   */
+  /**
+   * One document per localization group, for checking that several groups exist in a
+   * space at once — a menu's entries, say. The locale returned is whichever sorts first;
+   * a caller that needs a particular one asks `localizationSiblings` for that group.
+   */
+  findByLocalizationIds(spaceId: string, localizationIds: string[]): Promise<ContentRow[]>;
+  localizationSiblings(spaceId: string, localizationId: string, excludeId?: string): Promise<ContentRow[]>;
+  /**
+   * Merges a few field values into rows without touching the rest of the document.
+   *
+   * Used to carry a non-localized field across a document's translations: a jsonb `||`
+   * so concurrent edits to *other* fields on those rows are not clobbered.
+   */
+  patchFields(ids: string[], patch: Record<string, unknown>): Promise<void>;
+  list(filter: ContentFilter, pagination: Pagination, sorts?: ContentSort[], published?: boolean): Promise<Paginated<ContentRow>>;
+  /**
+   * The whole tree below `rootId` in **one** query: a GiST-indexed `path <@ root`
+   * returns every descendant, and `nlevel()` gives the depth to rebuild the hierarchy.
+   */
+  tree(spaceId: string, locale: string, rootId?: string | null, maxDepth?: number, published?: boolean): Promise<TreeNode[]>;
+  /** Ancestors of a node, root first — read straight off the materialised path. */
+  ancestors(id: string, published?: boolean): Promise<ContentRow[]>;
+  create(data: ContentWriteData): Promise<ContentRow>;
+  update(id: string, data: ContentWriteData): Promise<ContentRow>;
+  /**
+   * Reparents a subtree with one statement. `subpath(path, nlevel(:oldPath))` is the part
+   * of each descendant's path *below* the moved node; prefixing it with the node's new
+   * path rebases the whole subtree.
+   */
+  /**
+   * Reparents and reorders a node in one transaction.
+   *
+   * Separate from `update` because a drag is a structural change, not an edit: it writes
+   * no field values, takes no version bump and records no snapshot, so an editor open on
+   * the document does not hit a version conflict because someone reordered the tree.
+   *
+   * `position` is the index among the destination's children, clamped to the ends.
+   * Siblings on both sides are renumbered densely afterwards, so positions never drift
+   * into ties that the tree's `position asc, title asc` ordering would resolve by name.
+   */
+  move(id: string, parentId: string | null, position: number): Promise<ContentRow>;
+  /**
+   * Writes `position = index` for a whole sibling list in one statement: the ids and
+   * their new positions travel as two arrays and are joined by `unnest`, so a drag in a
+   * forty-child section costs one round trip rather than forty. Rows already in place
+   * are left untouched, so their `updated_at` and version do not move either.
+   */
+  private renumber;
+  private moveSubtree;
+  /**
+   * Recomputes permalinks for a node and everything beneath it in one recursive CTE.
+   * Each level derives from *its own* parent's freshly computed value (`t.pl`), and
+   * `concat_ws` drops NULL segments so a type without a slug is transparent in the path.
+   */
+  private recomputePermalinks;
+  /** Deletes a node and its whole subtree, in both the draft and published tables. */
+  delete(id: string): Promise<number>;
+  /**
+   * Copies a draft into the delivery projection inside one transaction, so a reader
+   * never observes a partially published tree.
+   */
+  publish(id: string, actorId?: string | null): Promise<ContentRow>;
+  unpublish(id: string): Promise<void>;
+  versions(contentId: string, limit?: number): Promise<Array<{
+    version: number;
+    createdAt: Date;
+    createdBy: string | null;
+    label: string | null;
+  }>>;
+  /** The row exactly as it was at that version — `snapshot()` stores the whole row. */
+  versionSnapshot(contentId: string, version: number): Promise<ContentRow | null>;
+  /** Every stored version of these documents, oldest first, for a space export. */
+  history(contentIds: string[]): Promise<ContentVersionRow[]>;
+  /**
+   * Puts an imported document back the way its source had it: the version counter and
+   * timestamps `create()` had to invent, and the version history in place of the single
+   * snapshot `create()` wrote. The row's own columns are left alone otherwise.
+   */
+  restoreHistory(id: string, data: {
+    version: number;
+    createdAt: Date;
+    updatedAt: Date;
+    versions: Array<{
+      version: number;
+      label: string | null;
+      snapshot: Record<string, unknown>;
+      createdAt: Date;
+      createdBy: string | null;
+    }>;
+  }): Promise<void>;
+  private snapshot;
+  private findRow;
+  private lockRow;
+  private parentPath;
+  private parentPermalinkPath;
+  /** Guards against making a node its own ancestor, which would orphan the subtree. */
+  private assertNotOwnDescendant;
+}
+declare function buildTree(rows: Array<ContentRow & {
+  depth: number;
+}>, rootId: string | null): TreeNode[];
+//#endregion
+//#region src/repositories/content-approval.d.ts
+interface ApprovalRequestData {
+  spaceId: string;
+  contentId: string;
+  typeId: string;
+  requestedBy: string | null;
+  requestedByLabel: string;
+  requestNote?: string | null | undefined;
+  contentVersion?: number | null | undefined;
+}
+interface ApprovalDecisionData {
+  status: Exclude<ApprovalStatus, 'pending'>;
+  decidedBy: string | null;
+  decidedByLabel: string | null;
+  decisionNote?: string | null | undefined;
+}
+/** A pending request with the document it concerns, for the reviewers' queue. */
+interface PendingApproval extends ContentApprovalRow {
+  content: {
+    id: string;
+    title: string;
+    locale: string;
+    typeId: string;
+    updatedAt: Date;
+  };
+}
+/**
+ * The approval history of documents. Rows are appended when someone asks and closed
+ * when someone decides; the "one pending per document" rule is the service's, this
+ * only offers the reads it needs to keep it.
+ */
+declare class ContentApprovalRepository {
+  private readonly db;
+  constructor(db: Database);
+  findById(id: string): Promise<ContentApprovalRow | null>;
+  /** The open request on a document, if there is one. */
+  pendingFor(contentId: string): Promise<ContentApprovalRow | null>;
+  /** The most recent request on a document, whatever became of it. */
+  latestFor(contentId: string): Promise<ContentApprovalRow | null>;
+  historyFor(contentId: string, limit?: number): Promise<ContentApprovalRow[]>;
+  /**
+   * Every open request in a space, oldest first, with the document beside it. Narrowed
+   * to `typeIds` when the reader may only publish some types; `null` means every type.
+   */
+  pendingInSpace(spaceId: string, typeIds?: string[] | null): Promise<PendingApproval[]>;
+  request(data: ApprovalRequestData): Promise<ContentApprovalRow>;
+  decide(id: string, data: ApprovalDecisionData): Promise<ContentApprovalRow>;
+}
+//#endregion
+//#region src/repositories/content-type.d.ts
+/**
+ * Persistence for *runtime-defined* content types only. Code-defined types come from
+ * `manablox.config.ts` and are never written here — the registry merges both into one
+ * shape, and `source` tells the admin which are read-only.
+ */
+declare class ContentTypeRepository {
+  private readonly db;
+  constructor(db: Database);
+  all(): Promise<ContentTypeDefinition[]>;
+  findById(id: string): Promise<ContentTypeDefinition | null>;
+  create(input: ContentTypeInput): Promise<ContentTypeDefinition>;
+  update(id: string, input: ContentTypeInput): Promise<ContentTypeDefinition>;
+  delete(id: string): Promise<void>;
+}
+//#endregion
+//#region src/repositories/menu.d.ts
+interface MenuWriteData {
+  id?: string | undefined;
+  spaceId: string;
+  name: string;
+  machineName: string;
+  description?: string | null | undefined;
+}
+/**
+ * One entry as the admin hands over the whole menu: a content entry names a
+ * `localizationId`, a link entry a `url`; either may carry a label. `id` is kept when
+ * given, so an unchanged entry keeps its identity across saves.
+ */
+interface MenuItemInput {
+  id?: string | undefined;
+  localizationId?: string | null | undefined;
+  label?: string | null | undefined;
+  url?: string | null | undefined;
+  children?: MenuItemInput[] | undefined;
+}
+interface MenuItemNode {
+  item: MenuItemRow;
+  children: MenuItemNode[];
+}
+/** An entry with its document looked up for one locale; `content` is null for a link. */
+interface ResolvedMenuItem {
+  id: string;
+  label: string | null;
+  url: string | null;
+  localizationId: string | null;
+  content: ContentRow | null;
+  children: ResolvedMenuItem[];
+}
+declare class MenuRepository {
+  private readonly db;
+  constructor(db: Database);
+  listBySpace(spaceId: string): Promise<MenuRow[]>;
+  findById(id: string): Promise<MenuRow | null>;
+  findByMachineName(spaceId: string, machineName: string): Promise<MenuRow | null>;
+  create(data: MenuWriteData): Promise<MenuRow>;
+  update(id: string, data: Loose<Omit<MenuWriteData, 'spaceId'>>): Promise<MenuRow>;
+  delete(id: string): Promise<void>;
+  /** Every entry of a menu, flat, in tree order within each level. */
+  items(menuId: string): Promise<MenuItemRow[]>;
+  tree(menuId: string): Promise<MenuItemNode[]>;
+  /**
+   * Replaces the whole entry tree in one transaction.
+   *
+   * A menu is edited as one document and saved as one, so this is simpler and safer than
+   * a per-entry API whose partial failures would leave a half-reordered menu behind.
+   */
+  setItems(menuId: string, tree: MenuItemInput[]): Promise<MenuItemNode[]>;
+  /** Menus that carry the document, for the editor's "used in" hint. */
+  menusReferencing(spaceId: string, localizationId: string): Promise<MenuRow[]>;
+  /** Drops every entry pointing at a document, in every menu; sub-entries cascade. */
+  removeContent(localizationId: string): Promise<number>;
+  /**
+   * The tree with each content entry's document for one locale. A content entry whose
+   * document has no row in that locale — or, on the published table, no published one —
+   * comes back with `content: null`; the caller decides whether to show or drop it.
+   */
+  resolve(menu: MenuRow, locale: string, published?: boolean): Promise<ResolvedMenuItem[]>;
+}
+//#endregion
+//#region src/repositories/notification.d.ts
+interface NotificationInsert {
+  userId: string;
+  spaceId?: string | null | undefined;
+  kind: NotificationKind;
+  title: string;
+  body?: string | undefined;
+  url?: string | null | undefined;
+  targetKind?: string | null | undefined;
+  targetId?: string | null | undefined;
+  actorId?: string | null | undefined;
+  actorLabel?: string | null | undefined;
+  meta?: Record<string, unknown> | null | undefined;
+}
+interface NotificationFilter {
+  unreadOnly?: boolean | undefined;
+  kinds?: NotificationKind[] | undefined;
+  spaceId?: string | null | undefined;
+}
+/**
+ * One person's inbox. Every method is scoped to a `userId`, so a row id from another
+ * account is inert: there is no way to read or change what is not yours.
+ */
+declare class NotificationRepository {
+  private readonly db;
+  constructor(db: Database);
+  /** Inserts one row per recipient in one statement; an empty list writes nothing. */
+  insertMany(rows: NotificationInsert[]): Promise<NotificationRow[]>;
+  list(userId: string, filter?: NotificationFilter, pagination?: Pagination): Promise<Paginated<NotificationRow>>;
+  findById(userId: string, id: string): Promise<NotificationRow | null>;
+  countUnread(userId: string): Promise<number>;
+  /** Marks the named rows read; rows already read keep their original time. Returns how many changed. */
+  markRead(userId: string, ids: string[]): Promise<number>;
+  markUnread(userId: string, ids: string[]): Promise<number>;
+  markAllRead(userId: string): Promise<number>;
+  delete(userId: string, ids: string[]): Promise<number>;
+  deleteRead(userId: string): Promise<number>;
+}
+//#endregion
+//#region src/repositories/role.d.ts
+interface RoleWriteData {
+  /** Kept when given, so an import can restore a role under the id its memberships name. */
+  id?: string | undefined;
+  name: string;
+  machineName: string;
+  description?: string | null;
+  permissions: string[];
+}
+declare class RoleRepository {
+  private readonly db;
+  constructor(db: Database);
+  listBySpace(spaceId: string): Promise<RoleRow[]>;
+  findById(id: string): Promise<RoleRow | null>;
+  findByMachineName(spaceId: string, machineName: string): Promise<RoleRow | null>;
+  create(spaceId: string, data: RoleWriteData): Promise<RoleRow>;
+  update(id: string, data: Partial<RoleWriteData>): Promise<RoleRow>;
+  delete(id: string): Promise<void>;
+  /** How many members of the role's space hold it, by name. */
+  countMembers(spaceId: string, machineName: string): Promise<number>;
+  /**
+   * Drops every grant narrowed to a content type from every role, once the type is
+   * gone. Grants are a JSON array, so this is one statement across the roles that carry
+   * such a grant rather than a read-modify-write per role.
+   */
+  pruneContentType(typeId: string): Promise<void>;
+}
+//#endregion
+//#region src/repositories/space.d.ts
+interface SpaceWriteData {
+  id?: string | undefined;
+  name: string;
+  machineName: string;
+  description?: string | null | undefined;
+  url: string;
+  defaultLocale?: string | undefined;
+  locales?: string[] | undefined;
+  settings?: Record<string, unknown> | undefined;
+}
+declare class SpaceRepository {
+  private readonly db;
+  constructor(db: Database);
+  all(): Promise<SpaceRow[]>;
+  findManyByIds(ids: string[]): Promise<SpaceRow[]>;
+  findById(id: string): Promise<SpaceRow | null>;
+  findByMachineName(machineName: string): Promise<SpaceRow | null>;
+  create(data: SpaceWriteData): Promise<SpaceRow>;
+  update(id: string, data: Loose<SpaceWriteData>): Promise<SpaceRow>;
+  delete(id: string): Promise<void>;
+}
+//#endregion
+//#region src/repositories/user.d.ts
+/** The name of a role in a space: one of the built-in five, or a row in `roles`. */
+type SpaceRole = string;
+/** What it takes to create an account that can sign in with a password. */
+interface UserCreateData {
+  name: string;
+  email: string;
+  role: string;
+  /** Already hashed; the repository never sees a plaintext password. */
+  passwordHash: string;
+}
+interface UserUpdateData {
+  name?: string;
+  email?: string;
+}
+declare class UserRepository {
+  private readonly db;
+  constructor(db: Database);
+  findById(id: string): Promise<UserRow | null>;
+  findManyByIds(ids: string[]): Promise<UserRow[]>;
+  /** Every account holding an instance role, for a fan-out to the superadmins. */
+  findByRole(role: string): Promise<UserRow[]>;
+  findByEmail(email: string): Promise<UserRow | null>;
+  list(pagination: Pagination, search?: string): Promise<Paginated<UserRow>>;
+  /**
+   * Users who are not members of a space, matching a search, newest first: the
+   * add-member picker's candidates, decided in SQL rather than by loading a page of
+   * users and filtering it here.
+   */
+  candidates(spaceId: string, search: string | undefined, limit: number): Promise<UserRow[]>;
+  count(): Promise<number>;
+  /**
+   * Inserts the user and its password credential together, so a failure on the second
+   * row cannot leave an account nobody can sign in to. The account row is shaped the way
+   * better-auth writes it on sign-up, so a sign-in later finds it as its own.
+   */
+  create(data: UserCreateData): Promise<UserRow>;
+  update(id: string, data: UserUpdateData): Promise<UserRow>;
+  delete(id: string): Promise<void>;
+  setBanned(id: string, banned: boolean, reason: string | null): Promise<UserRow>;
+  /**
+   * Replaces the password credential, creating it for an account that only ever signed
+   * in through another provider.
+   */
+  setPasswordHash(userId: string, passwordHash: string): Promise<void>;
+  /** Signs the user out everywhere. */
+  revokeSessions(userId: string): Promise<void>;
+  countByRole(role: string): Promise<number>;
+  setNotificationPreferences(id: string, preferences: NotificationPreferences): Promise<UserRow>;
+  /** The stored hash of the password credential, or `null` for an account without one. */
+  passwordHash(userId: string): Promise<string | null>;
+  setRole(id: string, role: string): Promise<UserRow>;
+  /**
+   * Authoritative role plus space memberships in one query.
+   *
+   * Read on every authenticated request rather than trusting the role embedded in the
+   * session: better-auth caches the session payload (five minutes by default), so a
+   * promotion or demotion would otherwise not take effect until that cache expired.
+   *
+   * A membership naming a custom role joins that role's grants; one naming a built-in
+   * role has none here, and the auth package answers those from its own table.
+   */
+  principal(userId: string): Promise<{
+    role: string;
+    banned: boolean;
+    spaces: Record<string, SpaceRole>;
+    permissions: Record<string, string[]>;
+  } | null>;
+  memberships(userId: string): Promise<MembershipRow[]>;
+  /** The user's memberships with the space each one is in, for a per-user view. */
+  membershipsWithSpaces(userId: string): Promise<Array<MembershipRow & {
+    space: SpaceRow;
+  }>>;
+  membersOf(spaceId: string): Promise<Array<MembershipRow & {
+    user: UserRow;
+  }>>;
+  roleIn(userId: string, spaceId: string): Promise<SpaceRole | null>;
+  grant(userId: string, spaceId: string, role: SpaceRole): Promise<void>;
+  revoke(userId: string, spaceId: string): Promise<void>;
+}
+//#endregion
+//#region src/repositories/webhook.d.ts
+type WebhookRow = typeof webhooks.$inferSelect;
+type WebhookDeliveryRow = typeof webhookDeliveries.$inferSelect;
+interface WebhookWriteData {
+  id?: string | undefined;
+  spaceId: string;
+  name: string;
+  url: string;
+  secret?: string | null | undefined;
+  events: string[];
+  enabled?: boolean | undefined;
+}
+interface WebhookDeliveryData {
+  webhookId: string;
+  event: string;
+  payload: Record<string, unknown>;
+  status: number | null;
+  error: string | null;
+}
+/** The webhooks of a space and the log of what was sent to them. */
+declare class WebhookRepository {
+  private readonly db;
+  constructor(db: Database);
+  findById(id: string): Promise<WebhookRow | null>;
+  listBySpace(spaceId: string): Promise<WebhookRow[]>;
+  create(data: WebhookWriteData): Promise<WebhookRow>;
+  /** The switched-on webhooks of a space, for fanning an event out. */
+  findEnabled(spaceId: string): Promise<WebhookRow[]>;
+  recordDelivery(data: WebhookDeliveryData): Promise<WebhookDeliveryRow>;
+  deliveries(webhookId: string, limit?: number): Promise<WebhookDeliveryRow[]>;
+}
+//#endregion
+//#region src/repositories/workflow.d.ts
+interface WorkflowWriteData {
+  id?: string | undefined;
+  spaceId: string;
+  name: string;
+  description?: string | null | undefined;
+  enabled?: boolean | undefined;
+  trigger: WorkflowTrigger;
+  steps: WorkflowStep[];
+}
+interface WorkflowRunCreateData {
+  workflowId: string;
+  spaceId: string;
+  trigger: string;
+  context: WorkflowRunContext;
+}
+/** How many runs a workflow keeps; older ones are pruned as new ones are written. */
+declare const RUNS_KEPT_PER_WORKFLOW = 200;
+declare class WorkflowRepository {
+  private readonly db;
+  constructor(db: Database);
+  listBySpace(spaceId: string): Promise<WorkflowRow[]>;
+  /** Every enabled workflow of a space, for the dispatcher; every enabled one at all for the scheduler. */
+  listEnabled(spaceId?: string): Promise<WorkflowRow[]>;
+  findById(id: string): Promise<WorkflowRow | null>;
+  create(data: WorkflowWriteData): Promise<WorkflowRow>;
+  update(id: string, data: Loose<Omit<WorkflowWriteData, 'spaceId'>>): Promise<WorkflowRow>;
+  delete(id: string): Promise<void>;
+  /**
+   * Claims a scheduled workflow for one minute. Returns false when another process got
+   * there first — the update matches nothing once `lastScheduledAt` is already `minute`.
+   */
+  claimSchedule(id: string, minute: Date): Promise<boolean>;
+  touchRun(id: string, at: Date): Promise<void>;
+  createRun(data: WorkflowRunCreateData): Promise<WorkflowRunRow>;
+  findRun(id: string): Promise<WorkflowRunRow | null>;
+  listRuns(workflowId: string, limit?: number): Promise<WorkflowRunRow[]>;
+  /**
+   * Moves a run from `queued` or `waiting` to `running`, or reports that it is not
+   * there to be moved. The status check in the predicate is what keeps two workers off
+   * the same run.
+   */
+  claimRun(id: string): Promise<WorkflowRunRow | null>;
+  /** Runs paused by a delay step whose time has come. */
+  dueRuns(now: Date, limit?: number): Promise<WorkflowRunRow[]>;
+  saveRunProgress(id: string, data: {
+    status: WorkflowRunStatus;
+    cursor: WorkflowCursor;
+    log: WorkflowStepLog[];
+    error?: string | null | undefined;
+    resumeAt?: Date | null | undefined;
+    finished?: boolean | undefined;
+  }): Promise<void>;
+  private pruneRuns;
+  /** The documents a scheduled workflow's selection names, newest change first. */
+  selectDocuments(spaceId: string, selection: WorkflowSelection, limit?: number): Promise<ContentRow[]>;
+  subscriptionsFor(userIds: string[]): Promise<PushSubscriptionRow[]>;
+  subscriptionsOf(userId: string): Promise<PushSubscriptionRow[]>;
+  /** Upserts on the endpoint: a browser re-subscribing keeps one row, not two. */
+  subscribe(data: {
+    userId: string;
+    endpoint: string;
+    keys: {
+      p256dh: string;
+      auth: string;
+    };
+    userAgent: string | null;
+  }): Promise<PushSubscriptionRow>;
+  unsubscribe(userId: string, endpoint: string): Promise<void>;
+  /** A push service answered 404/410: the browser is gone, and so is the row. */
+  dropSubscription(id: string): Promise<void>;
+  markSubscriptionUsed(id: string): Promise<void>;
+}
+//#endregion
+//#region src/repositories/index.d.ts
+interface Repositories {
+  content: ContentRepository;
+  contentTypes: ContentTypeRepository;
+  spaces: SpaceRepository;
+  assets: AssetRepository;
+  assetUsages: AssetUsageRepository;
+  users: UserRepository;
+  menus: MenuRepository;
+  roles: RoleRepository;
+  workflows: WorkflowRepository;
+  webhooks: WebhookRepository;
+  audit: AuditRepository;
+  notifications: NotificationRepository;
+  approvals: ContentApprovalRepository;
+}
+interface RepositoriesOptions {
+  audit?: AuditRepositoryOptions | undefined;
+}
+declare function createRepositories(db: Database, registry: ContentTypeRegistry, options?: RepositoriesOptions): Repositories;
+//#endregion
+export { Pagination as $, ContentApprovalRepository as A, AuditRepositoryOptions as B, MenuItemNode as C, ContentTypeRepository as D, ResolvedMenuItem as E, TreeNode as F, AssetRepository as G, AuditVerification as H, buildTree as I, paginate as J, AssetWriteData as K, AuditAppendInput as L, ContentRepository as M, ContentWriteData as N, ApprovalDecisionData as O, SQL$1 as P, FieldFilter as Q, AuditFilter as R, MenuItemInput as S, MenuWriteData as T, AssetUsageRepository as U, AuditSort as V, AssetFilter as W, ContentSort as X, ContentFilter as Y, ContentTable as Z, SpaceRepository as _, WorkflowRepository as a, DatabaseOptions as at, NotificationInsert as b, WebhookDeliveryData as c, Transaction as ct, WebhookRow as d, PgColumn$1 as et, WebhookWriteData as f, UserUpdateData as g, UserRepository as h, RUNS_KEPT_PER_WORKFLOW as i, DatabaseHandle as it, PendingApproval as j, ApprovalRequestData as k, WebhookDeliveryRow as l, createDatabase as lt, UserCreateData as m, RepositoriesOptions as n, buildOrderBy as nt, WorkflowRunCreateData as o, Executor as ot, SpaceRole as p, Paginated as q, createRepositories as r, Database as rt, WorkflowWriteData as s, Sql as st, Repositories as t, buildContentWhere as tt, WebhookRepository as u, SpaceWriteData as v, MenuRepository as w, NotificationRepository as x, NotificationFilter as y, AuditRepository as z };