emdash 0.40.1 → 0.42.0

package/dist/types-Cw-1it3n.d.mts

@@ -0,0 +1,287 @@
+import { r as ContentFieldFilters } from "./content-list-query-CnXfe1Nu.mjs";
+import { l as CustomFieldValue } from "./types-D7B20WFC.mjs";
+
+//#region src/database/repositories/types.d.ts
+interface CreateContentInput {
+  /** Explicit content ID for stable seed imports. Omit to generate a ULID. */
+  id?: string;
+  type: string;
+  slug?: string | null;
+  data: Record<string, unknown>;
+  status?: string;
+  authorId?: string;
+  primaryBylineId?: string | null;
+  locale?: string;
+  translationOf?: string;
+  /** Field columns selected atomically from `translationOf` during the insert. */
+  inheritFields?: string[];
+  publishedAt?: string | null;
+  /** Override created_at (ISO 8601). Used by importers to preserve original dates. */
+  createdAt?: string | null;
+}
+interface UpdateContentInput {
+  data?: Record<string, unknown>;
+  status?: string;
+  slug?: string | null;
+  publishedAt?: string | null;
+  scheduledAt?: string | null;
+  /** Entry owner (`ec_{collection}.author_id`). */
+  authorId?: string | null;
+  /** Revision author, separate from entry ownership. */
+  revisionAuthorId?: string | null;
+  primaryBylineId?: string | null;
+}
+/** SEO fields for content items */
+interface ContentSeo {
+  title: string | null;
+  description: string | null;
+  image: string | null;
+  canonical: string | null;
+  noIndex: boolean;
+}
+/** Input for updating SEO fields on content */
+interface ContentSeoInput {
+  title?: string | null;
+  description?: string | null;
+  image?: string | null;
+  canonical?: string | null;
+  noIndex?: boolean;
+}
+interface BylineSummary {
+  id: string;
+  slug: string;
+  displayName: string;
+  bio: string | null;
+  avatarMediaId: string | null;
+  /**
+   * The avatar media's storage key, folded in by a LEFT JOIN on the
+   * `media` table. Populated by the content-credit hydration path
+   * (`getContentBylines` / `getContentBylinesMany`, i.e. the
+   * `entry.data.bylines` populated by `getEmDashCollection` /
+   * `getEmDashEntry`) and by the single-row finders (`findById`,
+   * `findBySlug`, `findByUserId`, `findByUserIds`). `findMany` doesn't
+   * join media, so it leaves this null.
+   *
+   * Lets a page build a direct storage URL for an author avatar without a
+   * per-byline `MediaRepository.findById`, avoiding an N+1 when many distinct
+   * authors appear on one page.
+   *
+   * Optional so adding it is a non-breaking change for existing code that
+   * constructs a `BylineSummary` literal; the repositories always populate it
+   * (to `null` when there's no avatar or no media join).
+   */
+  avatarStorageKey?: string | null;
+  /** Avatar media alt text, from the same media join. Null when not joined. */
+  avatarAlt?: string | null;
+  /**
+   * Avatar media blurhash (LQIP placeholder, migration 024), folded in by the
+   * same media join as `avatarStorageKey`. Lets a renderer paint a blurred
+   * placeholder while the full avatar loads, with no extra media lookup.
+   * Null when the byline has no avatar, the media row has no blurhash, or the
+   * byline came from `findMany`, which doesn't join media.
+   */
+  avatarBlurhash?: string | null;
+  /**
+   * Avatar media dominant colour (LQIP placeholder, migration 024), from the
+   * same media join. Null under the same conditions as `avatarBlurhash`.
+   */
+  avatarDominantColor?: string | null;
+  websiteUrl: string | null;
+  userId: string | null;
+  isGuest: boolean;
+  createdAt: string;
+  updatedAt: string;
+  /**
+   * Locale this byline row is presented in. Added by migration 040.
+   * `(slug, locale)` is unique; a single slug can repeat across locales.
+   */
+  locale: string;
+  /**
+   * Shared across translations of the same byline. Added by migration 040.
+   * `_emdash_content_bylines.byline_id` and `ec_*.primary_byline_id` store
+   * this value, so a credit spans every locale variant of a byline.
+   * Nullable in storage for backwards compatibility; new rows always
+   * populate it.
+   */
+  translationGroup: string | null;
+  /**
+   * Custom field values registered via the byline-fields schema (migration
+   * 041, Discussion #1174). Optional in the TypeScript shape so existing
+   * object-literal consumers (test fixtures, plugin renderers) stay
+   * source-compatible; the runtime always returns `{}` when no fields are
+   * registered. Translatable values reflect this row's locale; non-
+   * translatable values are shared across every locale variant of the
+   * byline's `translation_group`.
+   */
+  customFields?: Record<string, CustomFieldValue>;
+}
+interface ContentBylineCredit {
+  byline: BylineSummary;
+  sortOrder: number;
+  roleLabel: string | null;
+  /** Whether this credit was explicitly assigned or inferred from authorId */
+  source?: "explicit" | "inferred";
+}
+/** A whitelisted timestamp column a content-list date range can filter on. */
+type ContentDateField = "createdAt" | "updatedAt" | "publishedAt";
+/**
+ * Inclusive date-range filter for a single whitelisted timestamp column.
+ * Bounds are compared lexicographically against the stored ISO 8601 strings,
+ * which is correct because every timestamp is written via `toISOString()`.
+ * Callers wanting an inclusive upper bound should pass an end-of-day value
+ * (e.g. `2024-12-31T23:59:59.999Z`); the repository does not widen `to`.
+ */
+interface ContentDateFilter {
+  field: ContentDateField;
+  from?: string;
+  to?: string;
+}
+/**
+ * Byline filter for a content list.
+ *
+ * `mode: "any"` matches entries credited to at least one of `bylineIds`;
+ * `mode: "none"` matches entries with no credit at all.
+ *
+ * `bylineIds` are `translation_group` values — what
+ * `_emdash_content_bylines.byline_id` stores since migration 040 — so a filter
+ * matches a byline across every locale variant.
+ *
+ * By default only explicit credits count. `includeInferred` widens the filter
+ * to the byline the list actually renders, which for an entry with no credits
+ * is the one linked to its `author_id` (see `hydrateBylinesMany`).
+ */
+interface ContentBylineFilter {
+  mode: "any" | "none";
+  /** Ignored when `mode` is `"none"`. An empty list matches nothing. */
+  bylineIds?: string[];
+  includeInferred?: boolean;
+  /**
+   * Locale a credit has to resolve at — the locale the list is scoped to.
+   * Applies to explicit credits as well as inferred ones, since a byline
+   * group credited to an entry renders only where it has a row at that
+   * locale. Defaults to each entry's own locale when the list spans locales.
+   */
+  locale?: string;
+}
+interface FindManyOptions {
+  where?: {
+    status?: string;
+    authorId?: string;
+    locale?: string; /** Case-insensitive substring to match against `searchColumns`. */
+    q?: string;
+    /**
+     * Columns the `q` substring filter is applied to (OR'd together).
+     * Resolved by the handler from the collection's display fields, slug,
+     * and any field marked searchable. Each name is validated as a SQL
+     * identifier.
+     */
+    searchColumns?: string[];
+    /**
+     * Serve `q` from the collection's FTS5 index (`_emdash_fts_<slug>`)
+     * instead of an unindexable substring LIKE. Set by the handler only
+     * when the collection has search enabled and the index exists
+     * (SQLite only). The repository combines a token-prefix MATCH with
+     * an index-served slug prefix so slug lookups keep working.
+     */
+    useFts?: boolean; /** Inclusive date range over a whitelisted timestamp column. */
+    dateFilter?: ContentDateFilter; /** Restrict to entries by their byline credits. */
+    bylineFilter?: ContentBylineFilter; /** AND-combined filters over custom fields explicitly marked as indexed. */
+    fieldFilters?: ContentFieldFilters;
+  };
+  orderBy?: {
+    field: string;
+    direction: "asc" | "desc";
+  };
+  /**
+   * Extra field slugs allowed as `orderBy` beyond the system columns — the
+   * collection's configured titleField/dateField. Resolved by the
+   * handler server-side so `orderBy` stays a closed set per request.
+   */
+  sortableExtras?: string[];
+  limit?: number;
+  cursor?: string;
+}
+interface FindManyResult<T> {
+  items: T[];
+  nextCursor?: string;
+  /**
+   * Total number of rows matching the where clause (ignoring pagination).
+   * Optional because not every caller needs it; repositories that compute
+   * it should set it so the UI can render a stable pagination denominator.
+   */
+  total?: number;
+}
+/**
+ * Thrown when a pagination cursor cannot be decoded.
+ *
+ * Repository callers should let this propagate; handler catch blocks
+ * map it to a structured `INVALID_CURSOR` error so client pagination
+ * bugs surface immediately rather than silently re-fetching the first
+ * page.
+ */
+declare class InvalidCursorError extends Error {
+  constructor(cursor: string);
+}
+interface ContentItem {
+  id: string;
+  type: string;
+  slug: string | null;
+  status: string;
+  data: Record<string, unknown>;
+  authorId: string | null;
+  primaryBylineId: string | null;
+  byline?: BylineSummary | null;
+  bylines?: ContentBylineCredit[];
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string | null;
+  scheduledAt: string | null;
+  liveRevisionId: string | null;
+  draftRevisionId: string | null;
+  version: number;
+  locale: string | null;
+  translationGroup: string | null;
+  /** SEO metadata — only populated for collections with `has_seo` enabled */
+  seo?: ContentSeo;
+  /**
+   * For collections that support `revisions`: when a draft revision exists,
+   * `data` reflects the unsaved draft and `liveData` carries the currently-
+   * published values. When no draft exists, `liveData` is undefined.
+   *
+   * Hydrated by `EmDashRuntime.hydrateDraftData()` — repositories themselves
+   * never set this field; it's purely a runtime-overlay concept that gives
+   * agents a clear picture of "draft vs. live" without re-fetching the
+   * revision history.
+   */
+  liveData?: Record<string, unknown>;
+  /**
+   * First page of each reference field's resolved selection, keyed by field
+   * slug. Only populated when the caller opts in via `handleContentGet`'s
+   * `referenceOptions` param (see content.ts) — hydration is never
+   * unconditional because it can leak draft ids/slugs to callers without
+   * `content:read_drafts`.
+   *
+   * Shape mirrors `EntryRef` from `api/handlers/relations.ts`, duplicated
+   * here (rather than imported) so the database layer doesn't depend on
+   * the api/handlers layer.
+   */
+  references?: Record<string, {
+    children: Array<{
+      id: string;
+      slug: string | null;
+      collection: string;
+      title: string | null;
+      locale: string | null;
+      translationGroup: string | null;
+      sortOrder?: number;
+    }>;
+    nextCursor?: string;
+  }>;
+}
+declare class EmDashValidationError extends Error {
+  details?: unknown | undefined;
+  constructor(message: string, details?: unknown | undefined);
+}
+//#endregion
+export { ContentSeo as a, EmDashValidationError as c, InvalidCursorError as d, UpdateContentInput as f, ContentItem as i, FindManyOptions as l, ContentBylineCredit as n, ContentSeoInput as o, ContentDateField as r, CreateContentInput as s, BylineSummary as t, FindManyResult as u };
+//# sourceMappingURL=types-Cw-1it3n.d.mts.map

package/dist/types-Cw-1it3n.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Cw-1it3n.d.mts","names":[],"sources":["../src/database/repositories/types.ts"],"mappings":";;;;UAciB,kBAAA;;EAEhB,EAAA;EACA,IAAA;EACA,IAAA;EACA,IAAA,EAAM,MAAA;EACN,MAAA;EACA,QAAA;EACA,eAAA;EACA,MAAA;EACA,aAAA;EAJA;EAMA,aAAA;EACA,WAAA;EAJA;EAMA,SAAA;AAAA;AAAA,UAGgB,kBAAA;EAChB,IAAA,GAAO,MAAA;EACP,MAAA;EACA,IAAA;EACA,WAAA;EACA,WAAA;;EAEA,QAAA;EANA;EAQA,gBAAA;EACA,eAAA;AAAA;;UAIgB,UAAA;EAChB,KAAA;EACA,WAAA;EACA,KAAA;EACA,SAAA;EACA,OAAA;AAAA;;UAIgB,eAAA;EAChB,KAAA;EACA,WAAA;EACA,KAAA;EACA,SAAA;EACA,OAAA;AAAA;AAAA,UAGgB,aAAA;EAChB,EAAA;EACA,IAAA;EACA,WAAA;EACA,GAAA;EACA,aAAA;EAZA;;;;;;;AAOD;;;;;;;;;;EAuBC,gBAAA;EAUA;EARA,SAAA;EAcA;;;;;;;EANA,cAAA;EAiCe;;;;EA5Bf,mBAAA;EACA,UAAA;EACA,MAAA;EACA,OAAA;EACA,SAAA;EACA,SAAA;EA4BA;;;;EAvBA,MAAA;EA8BW;;;;;AASZ;;EA/BC,gBAAA;EAgCuB;;;;;;;AAmBxB;;EAzCC,YAAA,GAAe,MAAA,SAAe,gBAAA;AAAA;AAAA,UAGd,mBAAA;EAChB,MAAA,EAAQ,aAAA;EACR,SAAA;EACA,SAAA;EA8CM;EA5CN,MAAA;AAAA;;KAIW,gBAAA;;;;;;;;UASK,iBAAA;EAChB,KAAA,EAAO,gBAAA;EACP,IAAA;EACA,EAAA;AAAA;;;;;;;;;;;;;;;UAiBgB,mBAAA;EAChB,IAAA;EAwD8B;EAtD9B,SAAA;EACA,eAAA;EAsDA;;;;;;EA/CA,MAAA;AAAA;AAAA,UAGgB,eAAA;EAChB,KAAA;IACC,MAAA;IACA,QAAA;IACA,MAAA,WA4EyB;IA1EzB,CAAA;IA0Ge;;;;;;IAnGf,aAAA;IAkIU;;;;;;;IA1HV,MAAA,YA+FD;IA7FC,UAAA,GAAa,iBAAA,EA8FR;IA5FL,YAAA,GAAe,mBAAA,EA8FhB;IA5FC,YAAA,GAAe,mBAAA;EAAA;EAEhB,OAAA;IACC,KAAA;IACA,SAAA;EAAA;EA6FD;;;;;EAtFA,cAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,UAGgB,cAAA;EAChB,KAAA,EAAO,CAAA;EACP,UAAA;EA8Ga;;;;;EAxGb,KAAA;AAAA;;;;;;;;;cA4BY,kBAAA,SAA2B,KAAA;cAC3B,MAAA;AAAA;AAAA,UAgCI,WAAA;EAChB,EAAA;EACA,IAAA;EACA,IAAA;EACA,MAAA;EACA,IAAA,EAAM,MAAA;EACN,QAAA;EACA,eAAA;EACA,MAAA,GAAS,aAAA;EACT,OAAA,GAAU,mBAAA;EACV,SAAA;EACA,SAAA;EACA,WAAA;EACA,WAAA;EACA,cAAA;EACA,eAAA;EACA,OAAA;EACA,MAAA;EACA,gBAAA;;EAEA,GAAA,GAAM,UAAA;;;;;;;;;;;EAWN,QAAA,GAAW,MAAA;;;;;;;;;;;;EAYX,UAAA,GAAa,MAAA;IAGX,QAAA,EAAU,KAAA;MACT,EAAA;MACA,IAAA;MACA,UAAA;MACA,KAAA;MACA,MAAA;MACA,gBAAA;MACA,SAAA;IAAA;IAED,UAAA;EAAA;AAAA;AAAA,cAKU,qBAAA,SAA8B,KAAA;EAGlC,OAAA;cADP,OAAA,UACO,OAAA;AAAA"}

package/dist/types-D7B20WFC.d.mts

@@ -0,0 +1,374 @@
+//#region src/schema/block-types.d.ts
+declare const BLOCK_FIELD_TYPES: readonly ["string", "text", "url", "number", "integer", "boolean", "datetime", "select", "multiSelect", "portableText", "image", "file", "repeater"];
+type BlockFieldType = (typeof BLOCK_FIELD_TYPES)[number];
+type BlockTypeSource = "user" | "seed";
+interface BlockFieldOptions {
+  darkVariant?: boolean;
+}
+interface BlockFieldDefinition {
+  slug: string;
+  label: string;
+  type: BlockFieldType;
+  required?: boolean;
+  defaultValue?: unknown;
+  validation?: Omit<FieldValidation, "required">;
+  options?: BlockFieldOptions;
+}
+interface BlockTypeVersion {
+  id: string;
+  blockTypeId: string;
+  version: number;
+  fields: BlockFieldDefinition[];
+  fingerprint: string;
+  active: boolean;
+  unsupportedTypes?: UnsupportedFieldType[];
+  createdAt: string;
+  updatedAt: string;
+}
+interface BlockType {
+  id: string;
+  slug: string;
+  label: string;
+  description?: string;
+  icon?: string;
+  category?: string;
+  currentVersion: number;
+  source: BlockTypeSource;
+  versions: BlockTypeVersion[];
+  createdAt: string;
+  updatedAt: string;
+}
+interface CreateBlockTypeInput {
+  slug: string;
+  label: string;
+  description?: string;
+  icon?: string;
+  category?: string;
+  source?: BlockTypeSource;
+  fields: BlockFieldDefinition[];
+}
+interface UpdateBlockTypeInput {
+  expectedFingerprint: string;
+  label?: string;
+  description?: string | null;
+  icon?: string | null;
+  category?: string | null;
+  fields?: BlockFieldDefinition[];
+  breaking?: boolean;
+}
+interface SeedBlockTypeVersionInput {
+  version: number;
+  fields: BlockFieldDefinition[];
+}
+interface ApplySeedBlockTypeInput {
+  slug: string;
+  label: string;
+  description?: string;
+  icon?: string;
+  category?: string;
+  currentVersion: number;
+  versions: SeedBlockTypeVersionInput[];
+}
+type BlockTypeDifferenceCompatibility = "compatible" | "breaking";
+interface BlockTypeDifference {
+  path: string;
+  change: string;
+  compatibility: BlockTypeDifferenceCompatibility;
+}
+interface BlockTypeCompatibility {
+  compatible: boolean;
+  differences: BlockTypeDifference[];
+}
+//#endregion
+//#region src/schema/types.d.ts
+/**
+ * Supported field types
+ */
+type FieldType = "string" | "text" | "url" | "number" | "integer" | "boolean" | "datetime" | "select" | "multiSelect" | "portableText" | "image" | "file" | "reference" | "json" | "slug" | "repeater" | "blocks";
+/**
+ * SQLite column types that map from field types
+ */
+type ColumnType = "TEXT" | "REAL" | "INTEGER" | "JSON";
+/**
+ * Map field types to their SQLite column types
+ */
+declare const FIELD_TYPE_TO_COLUMN: Record<FieldType, ColumnType>;
+/**
+ * Features a collection can support
+ */
+type CollectionSupport = "drafts" | "revisions" | "preview" | "scheduling" | "search" | "seo";
+/**
+ * Sources for how a collection was created
+ */
+type CollectionSource = `template:${string}` | `import:${string}` | "manual" | "discovered" | "seed";
+/**
+ * Validation rules for a field
+ */
+/** Sub-field definition for repeater fields */
+interface RepeaterSubField {
+  slug: string;
+  type: "string" | "text" | "url" | "number" | "integer" | "boolean" | "datetime" | "select" | "image";
+  label: string;
+  required?: boolean;
+  options?: string[];
+}
+interface FieldValidation {
+  required?: boolean;
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  options?: string[];
+  subFields?: RepeaterSubField[];
+  minItems?: number;
+  maxItems?: number;
+  allowedMimeTypes?: string[];
+  /** Reference fields: the relation's slug. */
+  relation?: string;
+  /**
+   * Reference fields: which end of the relation this collection sits on.
+   * `parent` picks children and controls their order; `child` picks parents
+   * and is unordered, since `sort_order` is scoped to a parent.
+   */
+  relationSide?: "parent" | "child";
+  /** Reference fields: the collection on the *other* end (derived from the
+   * relation and the side, denormalized here). */
+  targetCollection?: string;
+  /** Reference fields: allow selecting more than one entry (UI constraint). */
+  multiple?: boolean;
+  allowedTypes?: string[];
+  retiredTypes?: string[];
+}
+/**
+ * Widget options for field rendering
+ */
+interface FieldWidgetOptions {
+  rows?: number;
+  showPreview?: boolean;
+  darkVariant?: boolean;
+  collection?: string;
+  allowMultiple?: boolean;
+  [key: string]: unknown;
+}
+interface UnsupportedFieldType {
+  type: string;
+  path: string;
+}
+/** Collection-level admin presentation options. */
+interface CollectionAdminConfig {
+  /** Custom field slugs to show in the content list. */
+  listColumns?: string[];
+  /** Show a "new entry" quick action on the dashboard. Defaults to true. */
+  quickCreate?: boolean;
+}
+/**
+ * A collection definition
+ */
+interface Collection {
+  id: string;
+  slug: string;
+  label: string;
+  labelSingular?: string;
+  description?: string;
+  icon?: string;
+  admin?: CollectionAdminConfig;
+  supports: CollectionSupport[];
+  source?: CollectionSource;
+  /** Whether this collection has SEO metadata fields enabled */
+  hasSeo: boolean;
+  /** Field slug powering the admin list Title column. Defaults to the standard title display. */
+  titleField?: string;
+  /** Field slug powering the admin list Date column. Must be a `datetime` field. Defaults to last-updated. */
+  dateField?: string;
+  /** URL pattern with {slug} placeholder (e.g. "/{slug}", "/blog/{slug}") */
+  urlPattern?: string;
+  /** Whether published entries require a public slug. Defaults to true. */
+  routable?: boolean;
+  /**
+   * Omit this collection's auto-generated sidebar entry and dashboard quick
+   * action. The collection stays fully functional everywhere else (API, MCP,
+   * hooks, direct `/content/:collection` URLs), so a plugin that owns the
+   * collection can point editors at its own admin UI.
+   */
+  hidden: boolean;
+  /**
+   * Explicit position in the admin sidebar. Collections with a `sortOrder`
+   * come first, in ascending order; the rest keep the alphabetical-by-slug
+   * order and follow. `undefined` means "no explicit position".
+   */
+  sortOrder?: number;
+  /**
+   * Admin sidebar folder. Collections sharing a group render under one
+   * collapsible entry labelled with the group; `undefined` keeps the
+   * collection inline.
+   */
+  group?: string;
+  /** Whether comments are enabled for this collection */
+  commentsEnabled: boolean;
+  /** Moderation strategy: "all" | "first_time" | "none" */
+  commentsModeration: "all" | "first_time" | "none";
+  /** Auto-close comments after N days. 0 = never close. */
+  commentsClosedAfterDays: number;
+  /** Auto-approve comments from authenticated CMS users */
+  commentsAutoApproveUsers: boolean;
+  /** Whether opening an entry takes an edit lock. Defaults to true. */
+  editLocking: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * A field definition
+ */
+interface Field {
+  id: string;
+  collectionId: string;
+  slug: string;
+  label: string;
+  type: FieldType;
+  /** Raw stored type metadata that this runtime cannot safely interpret. */
+  unsupportedType?: UnsupportedFieldType;
+  blockTypes?: BlockType[];
+  blockTypeFingerprint?: string;
+  columnType: ColumnType;
+  required: boolean;
+  unique: boolean;
+  defaultValue?: unknown;
+  validation?: FieldValidation;
+  widget?: string;
+  options?: FieldWidgetOptions;
+  sortOrder: number;
+  searchable: boolean;
+  /** Whether this field has a physical index for structured list queries. */
+  indexed: boolean;
+  /** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
+  translatable: boolean;
+  createdAt: string;
+}
+/**
+ * Input for creating a collection
+ */
+interface CreateCollectionInput {
+  slug: string;
+  label: string;
+  labelSingular?: string;
+  description?: string;
+  icon?: string;
+  admin?: CollectionAdminConfig;
+  supports?: CollectionSupport[];
+  source?: CollectionSource;
+  urlPattern?: string;
+  routable?: boolean;
+  hasSeo?: boolean;
+  /** Omit the auto-generated sidebar entry and dashboard quick action (defaults to false) */
+  hidden?: boolean;
+  /** Explicit admin sidebar position (omit for the alphabetical fallback) */
+  sortOrder?: number | null;
+  /** Admin sidebar folder shared with other collections of the same group */
+  group?: string | null;
+  commentsEnabled?: boolean;
+  /** Take an edit lock when an entry is opened (defaults to true) */
+  editLocking?: boolean;
+}
+/**
+ * Input for updating a collection
+ */
+interface UpdateCollectionInput {
+  label?: string;
+  labelSingular?: string;
+  description?: string;
+  icon?: string;
+  admin?: CollectionAdminConfig;
+  supports?: CollectionSupport[];
+  urlPattern?: string | null;
+  routable?: boolean;
+  hasSeo?: boolean;
+  /** Omit the auto-generated sidebar entry and dashboard quick action */
+  hidden?: boolean;
+  /** Explicit admin sidebar position; `null` clears it back to alphabetical */
+  sortOrder?: number | null;
+  /** Admin sidebar folder; `null` moves the collection back inline */
+  group?: string | null;
+  commentsEnabled?: boolean;
+  commentsModeration?: "all" | "first_time" | "none";
+  commentsClosedAfterDays?: number;
+  commentsAutoApproveUsers?: boolean;
+  /** Take an edit lock when an entry is opened */
+  editLocking?: boolean;
+  /** Field slug for the Title column; `null`/`""` clears back to the default. */
+  titleField?: string | null;
+  /** Datetime field slug for the Date column; `null`/`""` clears back to the default. */
+  dateField?: string | null;
+}
+/**
+ * Input for creating a field
+ */
+interface CreateFieldInput {
+  slug: string;
+  label: string;
+  type: FieldType;
+  required?: boolean;
+  unique?: boolean;
+  defaultValue?: unknown;
+  validation?: FieldValidation | null;
+  widget?: string;
+  options?: FieldWidgetOptions;
+  sortOrder?: number;
+  /** Whether this field should be indexed for search */
+  searchable?: boolean;
+  /** Create a physical index for structured sorting. */
+  indexed?: boolean;
+  /** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
+  translatable?: boolean;
+}
+/**
+ * Input for updating a field
+ */
+interface UpdateFieldInput {
+  label?: string;
+  /**
+   * Change the field's type. Only storage-compatible text aliases (`string`,
+   * `text`, and `slug`) can be changed in place. Other changes require an
+   * explicit content migration. Omit to keep the current type.
+   */
+  type?: FieldType;
+  required?: boolean;
+  unique?: boolean;
+  defaultValue?: unknown;
+  validation?: FieldValidation | null;
+  widget?: string;
+  options?: FieldWidgetOptions;
+  sortOrder?: number;
+  /** Whether this field should be indexed for search */
+  searchable?: boolean;
+  /** Create or remove the physical index used by structured sorting. */
+  indexed?: boolean;
+  /** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
+  translatable?: boolean;
+}
+/**
+ * A collection with its fields
+ */
+interface CollectionWithFields extends Collection {
+  fields: Field[];
+}
+/**
+ * Reserved field slugs that cannot be used.
+ *
+ * Includes names reserved for runtime hydration (`terms`, `bylines`, `byline`)
+ * so user-defined fields never shadow the auto-hydrated values on entry.data.
+ */
+declare const RESERVED_FIELD_SLUGS: string[];
+/**
+ * Reserved collection slugs that cannot be used
+ */
+declare const RESERVED_COLLECTION_SLUGS: string[];
+/**
+ * Runtime value type for a byline custom field. The narrow union mirrors
+ * what the five v1 field types can produce: `string`/`text`/`url`/`select`
+ * → string, `boolean` → boolean, plus `null` for cleared values.
+ */
+type CustomFieldValue = string | boolean | null;
+//#endregion
+export { SeedBlockTypeVersionInput as A, BlockFieldType as C, BlockTypeSource as D, BlockTypeDifference as E, BlockTypeVersion as O, BlockFieldOptions as S, BlockTypeCompatibility as T, UnsupportedFieldType as _, CollectionWithFields as a, ApplySeedBlockTypeInput as b, CreateFieldInput as c, Field as d, FieldType as f, RESERVED_FIELD_SLUGS as g, RESERVED_COLLECTION_SLUGS as h, CollectionSupport as i, UpdateBlockTypeInput as j, CreateBlockTypeInput as k, CustomFieldValue as l, FieldWidgetOptions as m, CollectionAdminConfig as n, ColumnType as o, FieldValidation as p, CollectionSource as r, CreateCollectionInput as s, Collection as t, FIELD_TYPE_TO_COLUMN as u, UpdateCollectionInput as v, BlockType as w, BlockFieldDefinition as x, UpdateFieldInput as y };
+//# sourceMappingURL=types-D7B20WFC.d.mts.map

package/dist/types-D7B20WFC.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D7B20WFC.d.mts","names":[],"sources":["../src/schema/block-types.ts","../src/schema/types.ts"],"mappings":"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"}

package/dist/types-DGw8KMX_.mjs

@@ -0,0 +1,16 @@
+//#region src/storage/types.ts
+/**
+* Storage error with additional context
+*/
+var EmDashStorageError = class extends Error {
+	constructor(message, code, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "EmDashStorageError";
+	}
+};
+
+//#endregion
+export { EmDashStorageError as t };
+//# sourceMappingURL=types-DGw8KMX_.mjs.map