@thebes/cadmus 0.2.1 → 0.4.0

package/dist/index-BUrCSGVb.d.ts

@@ -1,616 +0,0 @@
-import { BaseSQLiteDatabase, SQLiteTableWithColumns, sqliteTable } from "drizzle-orm/sqlite-core";
-import { InferInsertModel, InferSelectModel, SQL } from "drizzle-orm";
-
-//#region src/cms/types.d.ts
-interface BaseFieldConfig {
-  /** column name override; defaults to the config key */
-  name?: string;
-  required?: boolean;
-  unique?: boolean;
-  defaultValue?: unknown;
-}
-interface TextFieldConfig extends BaseFieldConfig {
-  type: "text";
-  defaultValue?: string;
-}
-interface SelectFieldConfig<TOption extends string = string> extends BaseFieldConfig {
-  type: "select";
-  options: readonly TOption[];
-  defaultValue?: TOption;
-}
-interface NumberFieldConfig extends BaseFieldConfig {
-  type: "number";
-  /** marks this field as the table's auto-incrementing primary key */
-  autoIncrement?: boolean;
-  defaultValue?: number;
-}
-interface DateFieldConfig extends BaseFieldConfig {
-  type: "date";
-  /** mirrors drizzle's integer(..., { mode: "timestamp" | "timestamp_ms" }) */
-  mode?: "timestamp" | "timestamp_ms";
-  defaultValue?: "now" | Date;
-}
-interface RichTextFieldConfig extends BaseFieldConfig {
-  type: "richText";
-}
-/**
- * The TS type every JSON-mode column (`richText`/`array` fields,
- * `versionData`) is given via drizzle's `.$type<JsonValue>()` — see
- * codegen.ts's and schema-gen.ts's richText/array cases. Without it,
- * drizzle infers a JSON column as `unknown`, which TanStack Start's
- * server-function return-type validator rejects outright (`unknown`
- * doesn't structurally match its `Serializable` check the way a plain
- * object/array/primitive union does). Recursive on purpose — that's what
- * lets the validator recurse through it instead of bottoming out at
- * `unknown`.
- */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [key: string]: JsonValue;
-};
-interface CheckboxFieldConfig extends BaseFieldConfig {
-  type: "checkbox";
-  defaultValue?: boolean;
-}
-interface RelationshipFieldConfig extends BaseFieldConfig {
-  type: "relationship";
-  relationTo: string;
-  /**
-   * `false` (default): a plain integer column on this collection's own
-   * table storing the related row's id.
-   * `true`: no column on this table — represented by a generated join
-   * table instead (see codegen.ts's relationshipJoinTables).
-   */
-  hasMany?: boolean;
-}
-/**
- * `0` (default): a relationship field's column comes back as the bare
- * related-row id. `1`: `createLocalApi`'s `registry` param is used to
- * batch-resolve `hasMany: false` relationship fields into the related
- * row's full document — see localApi.ts's `resolveRelationships`. Depths
- * beyond 1 (resolving a relationship's own relationships) aren't
- * implemented; there's no nested-relationship fixture yet to validate
- * that design against.
- */
-type RelationshipDepth = 0 | 1;
-interface ArrayFieldConfig extends BaseFieldConfig {
-  type: "array";
-  /**
-   * Fields shown for every item, regardless of variant — must include
-   * `discriminator.key`'s own field (typically a `select`) if set.
-   */
-  fields: Record<string, FieldConfig>;
-  /**
-   * Lets one array field model a union of item shapes (e.g. page-builder
-   * blocks: image vs hero vs richText vs...) instead of one fixed field
-   * set for every item. `key` names a field already present in `fields`
-   * (rendered as the item's type switcher); `variants` maps each of that
-   * field's possible values to *additional* fields layered on top, shown
-   * only for items whose `key` field currently holds that value. Fields
-   * not listed under any variant (i.e. everything in `fields`) render
-   * unconditionally — that's the place for fields shared across every
-   * variant (e.g. a `caption` every block type has).
-   *
-   * Storage is unaffected either way — `array` is always one JSON column
-   * (see codegen.ts); this only changes what `CollectionEdit` renders.
-   */
-  discriminator?: {
-    key: string;
-    variants: Record<string, Record<string, FieldConfig>>;
-  };
-}
-interface UploadFieldConfig extends BaseFieldConfig {
-  type: "upload";
-  defaultValue?: string;
-}
-/**
- * A freeform JSON-blob column — the `json` field type from Section 3 (issue
- * #20-adjacent field-type gap, see DECISIONS.md). Storage-identical to
- * `richText`/`array` (one `.$type<JsonValue>()` text column, see
- * codegen.ts's `fieldToColumn`) but with no TipTap/array-item connotation —
- * use this for genuinely unstructured data (webhook audit payloads, CRM
- * activity metadata), not page-builder content.
- */
-interface JsonFieldConfig extends BaseFieldConfig {
-  type: "json";
-  defaultValue?: JsonValue;
-}
-/**
- * A fixed-shape, queryable sub-object — the `group` field type from Section
- * 3. Unlike `array` (JSON-blob storage, variable length), `group` flattens
- * to real prefixed columns at the Drizzle level (`<key>_<subKey>`, see
- * codegen.ts's `collectionToTable` and `flattenFields` below) so SQL-level
- * querying/sorting on a subfield (e.g. `shippingAddress.city`) still works.
- * `required`/`unique`/`defaultValue` on the group itself are meaningless —
- * set them on the individual nested `fields` instead; codegen ignores them
- * at the group level.
- */
-interface GroupFieldConfig extends BaseFieldConfig {
-  type: "group";
-  fields: Record<string, FieldConfig>;
-}
-type FieldConfig = TextFieldConfig | SelectFieldConfig | NumberFieldConfig | DateFieldConfig | RichTextFieldConfig | CheckboxFieldConfig | RelationshipFieldConfig | ArrayFieldConfig | UploadFieldConfig | JsonFieldConfig | GroupFieldConfig;
-/**
- * Expands every `group` field in `fields` into its flattened equivalents
- * (`<key>_<subKey>`, recursively — a group nested inside a group flattens
- * all the way down), and passes every other field through unchanged. This
- * is the single canonicalization step codegen, schema-gen, and the Local
- * API's field-shape validation (`validateRequiredFields`/
- * `rejectUnknownFields`) all run before touching `group` fields, so none of
- * them need their own group-aware branch — see localApi.ts's `flattenDoc`/
- * `nestDoc` for the matching document-level transform.
- *
- * Known limitation: a flattened key can collide if two different group
- * nestings produce the same combined name (e.g. a group `a_b` containing
- * field `c` collides with group `a` containing field `b_c`) — not guarded
- * against, since no current collection nests groups deeply enough to hit
- * it.
- */
-declare function flattenFields(fields: Record<string, FieldConfig>): Record<string, FieldConfig>;
-/**
- * The document-level counterpart to `flattenFields` — turns a `group`
- * field's nested object value (`{ shippingAddress: { city: "..." } }`) into
- * its flattened equivalent (`{ shippingAddress_city: "..." }`) for writing
- * to the DB, recursively. Fields not present in `doc` are simply omitted
- * from the result (lets `update()`'s partial inputs flatten correctly —
- * an absent group means every one of its flattened keys is absent too, not
- * `undefined`-valued). See `nestDoc` for the inverse, used on read.
- */
-declare function flattenDoc(fields: Record<string, FieldConfig>, doc: Record<string, unknown>): Record<string, unknown>;
-/**
- * The inverse of `flattenDoc` — re-nests a flat DB row's `<key>_<subKey>`
- * columns back into `{ key: { subKey: ... } }` for everything the Local
- * API returns to a caller, so a `group` field's document shape always
- * matches its config shape regardless of how it's actually stored.
- */
-declare function nestDoc(fields: Record<string, FieldConfig>, flatRow: Record<string, unknown>): Record<string, unknown>;
-/**
- * Per-operation access check, modeled on Payload's own `access` shape.
- * @returns whether the operation is allowed. Implementations decide their
- * own context shape (auth/session info isn't standardized by Cadmus) — see
- * {@link LocalApi}'s `TContext` generic, which every operation now requires
- * a value for.
- *
- * Enforced by `createLocalApi` since Section 2 — see
- * {@link CollectionConfig.access}.
- */
-type AccessFn<TContext = any> = (context: TContext) => boolean | Promise<boolean>;
-interface CollectionAccess {
-  create?: AccessFn;
-  read?: AccessFn;
-  update?: AccessFn;
-  delete?: AccessFn;
-  /**
-   * Gates `VersionedLocalApi.publish`/`unpublish` (see createVersionedLocalApi
-   * in localApi.ts). Separate from `update` — publishing is a distinct
-   * privilege from editing a draft, matching Payload's own model.
-   */
-  publish?: AccessFn;
-}
-/**
- * Lifecycle hooks, modeled on Payload's own hook points. Each is an
- * ordered array, run in sequence. Enforced by `createLocalApi` — see
- * {@link CollectionConfig.hooks}.
- */
-interface CollectionHooks<TDoc = Record<string, unknown>> {
-  beforeChange?: Array<(args: {
-    data: Partial<TDoc>;
-  }) => Partial<TDoc> | Promise<Partial<TDoc>>>;
-  /**
-   * `operation` distinguishes a freshly-inserted doc from an edited one —
-   * `publish()` (versioned collections) counts as `"update"`, since it
-   * writes to an already-existing row rather than creating one. Lets
-   * webhook config (see `cms/webhooks.ts`) filter which events it fires
-   * on without the hook itself tracking state.
-   */
-  afterChange?: Array<(args: {
-    doc: TDoc;
-    operation: "create" | "update";
-  }) => void | Promise<void>>;
-  beforeRead?: Array<(args: {
-    doc: TDoc;
-  }) => TDoc | Promise<TDoc>>;
-  afterRead?: Array<(args: {
-    doc: TDoc;
-  }) => TDoc | Promise<TDoc>>;
-  beforeDelete?: Array<(args: {
-    id: number;
-  }) => void | Promise<void>>;
-  afterDelete?: Array<(args: {
-    id: number;
-  }) => void | Promise<void>>;
-}
-interface CollectionConfig {
-  /** table name in D1; also the Local API's collection slug (later step) */
-  slug: string;
-  fields: Record<string, FieldConfig>;
-  /**
-   * Per-operation access control, enforced by `createLocalApi` (Section 2).
-   * Reserved per issue #16 step 7 ("reserve typed config keys now,
-   * implementation deferred to Section 2+") — that deferral is over: every
-   * `LocalApi` method now requires a `context` argument and runs the
-   * matching access function (`read` for `find`/`findByID`, `create` for
-   * `create`, etc.) before touching the database. No access function
-   * configured for an operation means that operation is unconditionally
-   * allowed, matching the pre-enforcement default.
-   */
-  access?: CollectionAccess;
-  /** Lifecycle hooks, enforced by `createLocalApi`. See {@link CollectionHooks}. */
-  hooks?: CollectionHooks;
-  /**
-   * Opts this collection into draft/version history. When `drafts` is
-   * true, codegen (see codegen.ts/schema-gen.ts) generates a companion
-   * `${slug}_versions` table and a nullable `published_version_id` pointer
-   * column on the main table, and `createVersionedLocalApi` (localApi.ts)
-   * becomes usable against it. Collections without this stay exactly as
-   * before — no versions table, no extra column, only `createLocalApi`.
-   */
-  versions?: {
-    drafts?: boolean; /** Reserved for future pruning of old versions; not enforced yet. */
-    maxPerDoc?: number;
-  };
-  /**
-   * Opts this collection into full-text search (issue #29). `fields` names
-   * which of this collection's own `text`/`richText`/`upload` fields are
-   * indexed — `defineCmsConfig`/`defineCollection` reject any other field
-   * type or an unknown key. When set, codegen (see codegen.ts's
-   * `collectionSearchTableSQL`) describes a companion `${slug}_fts` SQLite
-   * FTS5 virtual table, and `createLocalApi` both becomes able to run
-   * `.search()` and keeps that table in sync on every create/update/delete
-   * — see localApi.ts's `syncSearchIndex`. `richText` fields are flattened
-   * to plain text (TipTap JSON's `text` leaves, concatenated) before being
-   * indexed; nested `array`/block content is out of scope for this phase.
-   */
-  search?: {
-    fields: readonly string[];
-  };
-}
-/**
- * A Cadmea plugin — a synchronous transform over the whole CMS config,
- * modeled on Payload's `plugins: [(config) => config]` shape. A plugin may
- * add or modify collections, inject fields, or register lifecycle hooks.
- * `defineCmsConfig` runs plugins in array order, each receiving the output
- * of the previous one, *before* validation — so a plugin's output is held
- * to the same rules as a hand-written config.
- *
- * Synchronous in Section 2 by design: the resolved config is consumed by
- * schema codegen and runtime config loading, both of which are sync. An
- * async variant is a deliberate later extension, not an oversight.
- */
-type CadmeaPlugin = (config: CmsConfig) => CmsConfig;
-interface CmsConfig {
-  collections: CollectionConfig[];
-  /**
-   * Config transforms run in order by `defineCmsConfig` before validation.
-   * See {@link CadmeaPlugin}. Omit for a plain, plugin-free config.
-   */
-  plugins?: CadmeaPlugin[];
-}
-//#endregion
-//#region src/cms/codegen.d.ts
-declare function collectionToTable(config: CollectionConfig): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
-  name: string;
-  schema: undefined;
-  columns: {
-    [x: string]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: string;
-      tableName: string;
-      dataType: import("drizzle-orm").ColumnDataType;
-      columnType: string;
-      data: unknown;
-      driverParam: unknown;
-      notNull: false;
-      hasDefault: false;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: string[] | undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {}>;
-  };
-  dialect: "sqlite";
-}>;
-declare function collectionVersionsTable(config: CollectionConfig): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
-  name: `${string}_versions`;
-  schema: undefined;
-  columns: {
-    id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "id";
-      tableName: `${string}_versions`;
-      dataType: "number";
-      columnType: "SQLiteInteger";
-      data: number;
-      driverParam: number;
-      notNull: true;
-      hasDefault: true;
-      isPrimaryKey: true;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {}>;
-    parentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "parent_id";
-      tableName: `${string}_versions`;
-      dataType: "number";
-      columnType: "SQLiteInteger";
-      data: number;
-      driverParam: number;
-      notNull: true;
-      hasDefault: false;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {}>;
-    versionData: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "version_data";
-      tableName: `${string}_versions`;
-      dataType: "json";
-      columnType: "SQLiteTextJson";
-      data: JsonValue;
-      driverParam: string;
-      notNull: true;
-      hasDefault: false;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {
-      $type: JsonValue;
-    }>;
-    status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "status";
-      tableName: `${string}_versions`;
-      dataType: "string";
-      columnType: "SQLiteText";
-      data: "draft" | "published";
-      driverParam: string;
-      notNull: true;
-      hasDefault: false;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: ["draft", "published"];
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {
-      length: number | undefined;
-    }>;
-    createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-      name: "created_at";
-      tableName: `${string}_versions`;
-      dataType: "date";
-      columnType: "SQLiteTimestamp";
-      data: Date;
-      driverParam: number;
-      notNull: false;
-      hasDefault: true;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: true;
-      enumValues: undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {}>;
-  };
-  dialect: "sqlite";
-}>;
-declare function relationshipJoinTables(config: CollectionConfig): Record<string, ReturnType<typeof sqliteTable>>;
-declare function collectionSearchTableName(config: CollectionConfig): string;
-declare function collectionSearchTableSQL(config: CollectionConfig): string;
-declare function extractSearchText(config: CollectionConfig, doc: Record<string, unknown>): string[];
-declare function cmsConfigToSchema(config: CmsConfig): Record<string, ReturnType<typeof collectionToTable> | ReturnType<typeof collectionVersionsTable>>;
-//#endregion
-//#region src/cms/defineCollection.d.ts
-declare function defineCollection(config: CollectionConfig): CollectionConfig;
-declare function defineCmsConfig(config: CmsConfig): CmsConfig;
-//#endregion
-//#region src/cms/localApi.d.ts
-type AnyTable = SQLiteTableWithColumns<any>;
-/**
- * `TContext` is the per-request value passed to every method and forwarded
- * unchanged to the collection's `access` functions (see {@link CollectionAccess}).
- * Cadmus doesn't standardize its shape — Cadmea types it as `{ session }`,
- * other consumers may type it differently. `context` is a required first
- * argument on every method (not optional) so a call site can't forget it.
- */
-interface LocalApi<TTable extends AnyTable, TContext = unknown> {
-  /**
-   * `depth: 0` (default) returns relationship fields as bare ids; `depth: 1`
-   * batch-resolves `hasMany: false` relationship fields into the related
-   * row, gated by that collection's own `read` access fn — see
-   * `resolveRelationships` below. Requires `createLocalApi`'s `registry`
-   * param; throws CadmusCmsError if `depth: 1` is requested without one.
-   */
-  find(context: TContext, options?: {
-    where?: SQL;
-    depth?: RelationshipDepth; /** Row cap, applied after `where` — for paginated list views. */
-    limit?: number; /** Rows to skip, applied after `where` — pairs with `limit`. */
-    offset?: number; /** One or more `asc(table.col)`/`desc(table.col)` expressions. */
-    orderBy?: SQL | SQL[];
-  }): Promise<InferSelectModel<TTable>[]>;
-  findByID(context: TContext, id: number, options?: {
-    depth?: RelationshipDepth;
-  }): Promise<InferSelectModel<TTable>>;
-  /**
-   * Total row count for `where` (ignoring `limit`/`offset`) — pairs with
-   * `find` to compute page counts/next-page availability without fetching
-   * every row. Gated by the same `read` access check as `find`.
-   */
-  count(context: TContext, options?: {
-    where?: SQL;
-  }): Promise<number>;
-  /**
-   * Full-text search over this collection's `search.fields`-configured
-   * companion FTS5 table — see types.ts's `CollectionConfig.search` and
-   * codegen.ts's `collectionSearchTableSQL`. Gated by `read` access, same
-   * as `find`/`findByID`. Throws `CadmusCmsError` if the collection has no
-   * `search` config.
-   */
-  search(context: TContext, query: string, options?: {
-    limit?: number;
-  }): Promise<InferSelectModel<TTable>[]>;
-  create(context: TContext, input: InferInsertModel<TTable>): Promise<InferSelectModel<TTable>>;
-  update(context: TContext, id: number, input: Partial<InferInsertModel<TTable>>): Promise<InferSelectModel<TTable>>;
-  deleteByID(context: TContext, id: number): Promise<InferSelectModel<TTable>>;
-}
-/**
- * Lets `createLocalApi` resolve `depth: 1` relationship fields without
- * importing every other collection's Local API (which would be a circular
- * dependency the moment two collections relate to each other). The
- * registry is just the raw ingredients — a table and a config per
- * collection slug — built once by the app (e.g. from `cadmeaConfig.collections`)
- * and passed to every `createLocalApi` call that has relationship fields.
- *
- * `apis` is a second, optional registry on the same object, for a
- * different problem: a *hook* (not `createLocalApi` itself) on one
- * collection that needs to write to *another* collection's Local API —
- * e.g. a CRM upsert hook on a lead-capture collection that creates/updates
- * `contacts`/`activities` rows. `tables`/`configs` can't serve this, since
- * a hook needs a real `LocalApi` (with its own access/hooks/search wiring
- * already applied), not raw ingredients to rebuild one from.
- *
- * The chicken-and-egg problem this solves: building collection A's
- * `LocalApi` might need to reference collection B's `LocalApi` (for a
- * hook), but collection B's `LocalApi` doesn't exist yet at the point A's
- * is constructed — and vice versa if B also has a hook referencing A.
- * The fix is **late binding**: build one `CmsRegistry` object, pass the
- * *same reference* into every `createLocalApi` call (so every collection's
- * hooks close over the same mutable object), construct every `LocalApi`,
- * then fill in `registry.apis` afterwards:
- *
- * ```ts
- * const registry: CmsRegistry = { tables, configs, apis: {} };
- * const contactsApi = createLocalApi(db, contactsTable, contactsCollection, registry);
- * const inquiriesApi = createLocalApi(db, inquiriesTable, inquiriesCollection, registry);
- * // populate *after* every createLocalApi call returns — any hook that
- * // reads registry.apis lazily (inside its returned function body, not
- * // at hook-factory-call time) sees the fully-populated map, since hooks
- * // only ever run once real requests start landing.
- * Object.assign(registry.apis!, { contacts: contactsApi, inquiries: inquiriesApi });
- * ```
- *
- * See `getRegisteredApi` for the accessor a hook factory should use to
- * read from this map, rather than indexing `registry.apis` directly.
- */
-interface CmsRegistry {
-  tables: Record<string, AnyTable>;
-  configs: Record<string, CollectionConfig>;
-  apis?: Record<string, LocalApi<AnyTable, any>>;
-}
-/**
- * Reads collection `slug`'s `LocalApi` out of `registry.apis` — the
- * accessor hook factories should use (see `CmsRegistry`'s doc comment for
- * the late-binding pattern this assumes) instead of indexing
- * `registry.apis` directly, so every caller gets the same clear error if
- * the registry wasn't built/populated correctly. `TContext` is a type-only
- * parameter (the registry itself is stored with `never` to stay variance-
- * safe across collections with different context shapes) — callers assert
- * the context type they expect, the same way `resolveRelationships`'s own
- * registry lookups do.
- */
-declare function getRegisteredApi<TContext>(registry: CmsRegistry | undefined, slug: string): LocalApi<AnyTable, TContext>;
-/**
- * Non-throwing counterpart to `checkAccess` below, for UI code that wants
- * to hide/disable an action a context can't perform rather than let it
- * fail server-side after a click (see Phase 6 / issue #26's
- * `getPageCapabilities`). `checkAccess` calls through this same function
- * rather than duplicating the "no access fn = allowed" logic, so `can()`'s
- * answer and the real operation's enforcement can never disagree.
- */
-declare function can<TContext>(config: CollectionConfig, operation: keyof CollectionAccess, context: TContext): Promise<boolean>;
-declare function createLocalApi<TTable extends AnyTable, TContext = unknown>(db: BaseSQLiteDatabase<"async", unknown>, table: TTable, config: CollectionConfig, registry?: CmsRegistry): LocalApi<TTable, TContext>;
-/**
- * Extends {@link LocalApi} with draft/publish operations for a collection
- * that opted in via `CollectionConfig.versions.drafts` (see codegen.ts's
- * `collectionVersionsTable`). A separate interface (not a wider
- * `LocalApi`) so non-versioned collections' types don't grow these methods
- * — TypeScript can't conditionally widen `createLocalApi`'s return type
- * off a runtime config value, so this is `createVersionedLocalApi`'s own
- * factory rather than a branch inside `createLocalApi`.
- *
- * Scope, deliberately: a document is always created via the inherited
- * `create()` first (existing behavior, unaffected by versioning) — these
- * methods operate against an *existing* row. `saveDraft` never validates
- * required fields (an incomplete draft is valid); `publish` runs the same
- * full validation `create`/`update` do, since publishing is what makes a
- * version the public-facing document. Plain `find`/`findByID` are
- * unchanged by any of this — they always return the main table's current
- * row regardless of `publishedVersionId`; filtering reads to
- * published-only content is not this phase's concern.
- */
-interface VersionedLocalApi<TTable extends AnyTable, TVersionsTable extends AnyTable, TContext = unknown> extends LocalApi<TTable, TContext> {
-  findVersions(context: TContext, parentId: number): Promise<InferSelectModel<TVersionsTable>[]>;
-  /** Inserts a new version row holding `input` as a draft snapshot. */
-  saveDraft(context: TContext, id: number, input: Partial<InferInsertModel<TTable>>): Promise<InferSelectModel<TVersionsTable>>;
-  /** Copies a version's snapshot onto the main row and marks it published. */
-  publish(context: TContext, versionId: number): Promise<InferSelectModel<TTable>>;
-  /** Clears the main row's published pointer; the row's data is untouched. */
-  unpublish(context: TContext, id: number): Promise<InferSelectModel<TTable>>;
-}
-declare function createVersionedLocalApi<TTable extends AnyTable, TVersionsTable extends AnyTable, TContext = unknown>(db: BaseSQLiteDatabase<"async", unknown>, table: TTable, versionsTable: TVersionsTable, config: CollectionConfig, registry?: CmsRegistry): VersionedLocalApi<TTable, TVersionsTable, TContext>;
-//#endregion
-//#region src/cms/meta.d.ts
-interface CollectionMeta {
-  slug: string;
-  fields: CollectionConfig["fields"];
-  /** Whether `LocalApi.search()` is usable for this collection — see `CollectionConfig.search`. */
-  searchable: boolean;
-}
-declare function getCollectionsMeta(config: CmsConfig): CollectionMeta[];
-//#endregion
-//#region src/cms/schema-gen.d.ts
-declare function generateSchemaSource(config: CmsConfig): string;
-//#endregion
-//#region src/cms/webhooks.d.ts
-interface WebhookConfig {
-  /** Endpoint this webhook POSTs to on every matching event. */
-  url: string;
-  /** Restricts delivery to these operations. Default: both. */
-  events?: Array<"create" | "update">;
-  /**
-   * When set, every delivery carries an `X-Cadmus-Signature` header —
-   * HMAC-SHA256 (hex) over the raw JSON body — so the receiver can verify
-   * the payload actually came from this Cadmus instance.
-   */
-  secret?: string;
-}
-/** The shape enqueued by `createWebhookHook`, consumed by `deliverWebhookMessage`. */
-interface WebhookMessage {
-  url: string;
-  secret?: string;
-  event: "create" | "update";
-  doc: Record<string, unknown>;
-  /** ms since epoch, included in the signed/delivered payload. */
-  timestamp: number;
-}
-/**
- * Builds an `afterChange` hook that enqueues a `WebhookMessage` for every
- * matching write — append the result to a collection's
- * `hooks.afterChange` array. `queue` is whatever `Queue<WebhookMessage>`
- * binding the caller's Worker has configured for webhook dispatch (see
- * wrangler.jsonc's webhook queue producer binding).
- */
-declare function createWebhookHook(queue: Queue<WebhookMessage>, config: WebhookConfig): NonNullable<CollectionHooks["afterChange"]>[number];
-/**
- * Delivers a single `WebhookMessage` via `fetch()`. Throws
- * `CadmusQueueError` on any non-2xx response or network failure — meant
- * to be called from inside `processBatch`'s handler, where a thrown error
- * becomes a `message.retry()`.
- */
-declare function deliverWebhookMessage(message: WebhookMessage): Promise<void>;
-//#endregion
-export { CollectionAccess as A, RelationshipFieldConfig as B, relationshipJoinTables as C, CadmeaPlugin as D, BaseFieldConfig as E, GroupFieldConfig as F, flattenDoc as G, SelectFieldConfig as H, JsonFieldConfig as I, flattenFields as K, JsonValue as L, CollectionHooks as M, DateFieldConfig as N, CheckboxFieldConfig as O, FieldConfig as P, NumberFieldConfig as R, extractSearchText as S, ArrayFieldConfig as T, TextFieldConfig as U, RichTextFieldConfig as V, UploadFieldConfig as W, cmsConfigToSchema as _, generateSchemaSource as a, collectionToTable as b, CmsRegistry as c, can as d, createLocalApi as f, defineCollection as g, defineCmsConfig as h, deliverWebhookMessage as i, CollectionConfig as j, CmsConfig as k, LocalApi as l, getRegisteredApi as m, WebhookMessage as n, CollectionMeta as o, createVersionedLocalApi as p, nestDoc as q, createWebhookHook as r, getCollectionsMeta as s, WebhookConfig as t, VersionedLocalApi as u, collectionSearchTableName as v, AccessFn as w, collectionVersionsTable as x, collectionSearchTableSQL as y, RelationshipDepth as z };
-//# sourceMappingURL=index-BUrCSGVb.d.ts.map

package/dist/index-BUrCSGVb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BUrCSGVb.d.ts","names":[],"sources":["../src/cms/types.ts","../src/cms/codegen.ts","../src/cms/defineCollection.ts","../src/cms/localApi.ts","../src/cms/meta.ts","../src/cms/schema-gen.ts","../src/cms/webhooks.ts"],"mappings":"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"}