@manablox/db 0.2.0 → 0.3.0

package/dist/index-Cyf_N5K3.d.ts

@@ -0,0 +1,658 @@
+import { R as contents, S as webhooks, _ as index_d_exports, a as ContentRow, c as MembershipRow, d as PushSubscriptionRow, f as RoleRow, g as WorkflowRunRow, h as WorkflowRow, l as MenuItemRow, m as UserRow, p as SpaceRow, r as AssetVariantRow, t as AssetRow, u as MenuRow, x as webhookDeliveries, z as publishedContents } from "./index-rZ24t-Ln.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 { ContentStatus, ContentTypeDefinition, ContentTypeInput, ContentTypeRegistry, DatabaseConfig, FilterOperator, Loose, 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>;
+  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/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>;
+  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-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/role.d.ts
+interface RoleWriteData {
+  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[]>;
+  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>;
+  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 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>;
+  /** 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;
+}
+declare function createRepositories(db: Database, registry: ContentTypeRegistry): Repositories;
+//#endregion
+export { AssetRepository as A, buildContentWhere as B, ContentRepository as C, buildTree as D, TreeNode as E, ContentSort as F, Executor as G, Database as H, ContentTable as I, createDatabase as J, Sql as K, FieldFilter as L, Paginated as M, paginate as N, AssetUsageRepository as O, ContentFilter as P, Pagination as R, ContentTypeRepository as S, SQL$1 as T, DatabaseHandle as U, buildOrderBy as V, DatabaseOptions as W, MenuItemInput as _, WorkflowRunCreateData as a, MenuWriteData as b, WebhookDeliveryRow as c, SpaceRole as d, UserCreateData as f, SpaceWriteData as g, SpaceRepository as h, WorkflowRepository as i, AssetWriteData as j, AssetFilter as k, WebhookRepository as l, UserUpdateData as m, createRepositories as n, WorkflowWriteData as o, UserRepository as p, Transaction as q, RUNS_KEPT_PER_WORKFLOW as r, WebhookDeliveryData as s, Repositories as t, WebhookRow as u, MenuItemNode as v, ContentWriteData as w, ResolvedMenuItem as x, MenuRepository as y, PgColumn$1 as z };