emdash 0.39.0 → 0.40.0

package/dist/client/index.d.mts

@@ -1,6 +1,856 @@
-import { r as ContentFieldFilters } from "../content-list-query-CbPdzsna.mjs";
-import { a as tokenInterceptor, i as devBypassInterceptor, n as createTransport, r as csrfInterceptor, t as Interceptor } from "../transport-BLHZZcD_.mjs";
+import { r as ContentFieldFilters } from "../content-list-query-Dra4Dalc.mjs";
+import { j as UpdateBlockTypeInput, k as CreateBlockTypeInput, w as BlockType } from "../types-D2fvWd1i.mjs";
+import "../types-B7Lmsh1E.mjs";
+import { a as tokenInterceptor, i as devBypassInterceptor, n as createTransport, r as csrfInterceptor, t as Interceptor } from "../transport-BIfH7_hx.mjs";
+import { Kysely } from "kysely";
+import { z } from "zod";
 
+//#region src/transfer/format/digest.d.ts
+/**
+ * SHA-256 hashing and the digests that identify packages, plans, receipts,
+ * and verified target state.
+ *
+ * Digest rules (formatVersion "1"):
+ * - `packageDigest = "sha256:" + hex(sha256(utf8(canonicalJson(manifest))))`
+ * - `planDigest = "sha256:" + hex(sha256(utf8(canonicalJson(plan))))` over the
+ *   complete {@link SiteImportPlan} including its `decisions`, `packageDigest`
+ *   and `target.siteId`, so a plan cannot be replayed against another package
+ *   or target.
+ * - `receiptDigest` covers the receipt with its `receiptDigest` property
+ *   removed.
+ * - A record's hash is the hex SHA-256 of its canonical JSON (the NDJSON line
+ *   without its newline).
+ * - A chunk's logical hash is
+ *   `hex(sha256(utf8(canonicalJson([[id, recordSha256], …]))))` over the
+ *   records of one package record chunk, in chunk order, each record in its
+ *   predicted target form (after declared transformations).
+ * - `logicalDigest = "sha256:" + hex(sha256(utf8(canonicalJson(chunks))))`
+ *   where `chunks` is `[[kind, seq, chunkLogicalSha256], …]` for every record
+ *   chunk in package order (kinds in `RECORD_KINDS` order, then `seq`).
+ *   `principal` chunks are excluded because principals are never written to
+ *   a target. The two-level shape lets verification run in bounded steps and
+ *   persist one hash per chunk instead of an in-progress hash state.
+ */
+type Sha256Digest = `sha256:${string}`;
+//#endregion
+//#region src/transfer/format/plan.d.ts
+/** Decisions a caller may submit; omitted values keep the plan defaults. */
+declare const siteImportDecisionsInputSchema: z.ZodObject<{
+  principalMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+  siteTitle: z.ZodOptional<z.ZodEnum<{
+    target: "target";
+    package: "package";
+  }>>;
+  siteTagline: z.ZodOptional<z.ZodEnum<{
+    target: "target";
+    package: "package";
+  }>>;
+}, z.core.$strict>;
+type SiteImportDecisionsInput = z.infer<typeof siteImportDecisionsInputSchema>;
+declare const siteImportPlanSchema: z.ZodObject<{
+  formatVersion: z.ZodLiteral<"1">;
+  packageDigest: z.ZodString;
+  origin: z.ZodObject<{
+    siteId: z.ZodString;
+    packageId: z.ZodString;
+    createdAt: z.ZodString;
+    createdByEmDashVersion: z.ZodString;
+  }, z.core.$strict>;
+  target: z.ZodObject<{
+    siteId: z.ZodString;
+    dialect: z.ZodEnum<{
+      sqlite: "sqlite";
+      postgres: "postgres";
+    }>;
+    emdashVersion: z.ZodString;
+  }, z.core.$strict>;
+  counts: z.ZodRecord<z.ZodEnum<{
+    byline: "byline";
+    seo: "seo";
+    collection: "collection";
+    setting: "setting";
+    widget: "widget";
+    term: "term";
+    menu: "menu";
+    relation: "relation";
+    media: "media";
+    principal: "principal";
+    block_type: "block_type";
+    block_type_version: "block_type_version";
+    field: "field";
+    taxonomy_def: "taxonomy_def";
+    byline_field: "byline_field";
+    media_folder: "media_folder";
+    byline_field_value: "byline_field_value";
+    byline_field_group_value: "byline_field_group_value";
+    revision: "revision";
+    entry: "entry";
+    content_term: "content_term";
+    content_byline: "content_byline";
+    content_reference: "content_reference";
+    menu_item: "menu_item";
+    widget_area: "widget_area";
+    section: "section";
+    redirect: "redirect";
+    comment: "comment";
+    comment_reaction: "comment_reaction";
+  }> & z.core.$partial, z.ZodNumber>;
+  bytes: z.ZodObject<{
+    records: z.ZodNumber;
+    media: z.ZodNumber;
+  }, z.core.$strict>;
+  principals: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    references: z.ZodNumber;
+    suggestedUserId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  settings: z.ZodObject<{
+    title: z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      target: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    tagline: z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      target: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+  }, z.core.$strict>;
+  decisions: z.ZodObject<{
+    principalMappings: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    siteTitle: z.ZodEnum<{
+      target: "target";
+      package: "package";
+    }>;
+    siteTagline: z.ZodEnum<{
+      target: "target";
+      package: "package";
+    }>;
+  }, z.core.$strict>;
+  transformations: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    code: z.ZodEnum<{
+      soft_orphan_dropped: "soft_orphan_dropped";
+      avatar_nulled: "avatar_nulled";
+      redirect_duplicate_dropped: "redirect_duplicate_dropped";
+      media_not_ready_dropped: "media_not_ready_dropped";
+      media_url_relativized: "media_url_relativized";
+      orphan_dropped: "orphan_dropped";
+      orphan_reference_nulled: "orphan_reference_nulled";
+      media_ref_unlinked: "media_ref_unlinked";
+      unknown_storage_key: "unknown_storage_key";
+    }>;
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    count: z.ZodNumber;
+  }, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    code: z.ZodLiteral<"principal_mapped">;
+    count: z.ZodNumber;
+  }, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"principal_unmapped">;
+    count: z.ZodNumber;
+  }, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"seeded_scaffold_removed">;
+    count: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strict>>;
+  }, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"redirect_loop_disabled">;
+    kind: z.ZodLiteral<"redirect">;
+    ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"search_unsupported">;
+    kind: z.ZodLiteral<"collection">;
+    ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"float4_rounded">;
+    count: z.ZodNumber;
+  }, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"locale_recased">;
+    locales: z.ZodArray<z.ZodObject<{
+      from: z.ZodString;
+      to: z.ZodString;
+    }, z.core.$strict>>;
+  }, z.core.$strict>], "code">]>>;
+  warnings: z.ZodArray<z.ZodObject<{
+    code: z.ZodEnum<{
+      media_row_missing: "media_row_missing";
+      media_provider_external: "media_provider_external";
+      soft_reference_dangling: "soft_reference_dangling";
+      redirect_loops_unchecked: "redirect_loops_unchecked";
+      issues_truncated: "issues_truncated";
+    }>;
+    message: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    detail: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+  }, z.core.$strict>>;
+  blockers: z.ZodArray<z.ZodObject<{
+    code: z.ZodEnum<{
+      package_invalid: "package_invalid";
+      unsupported_format: "unsupported_format";
+      unsupported_feature: "unsupported_feature";
+      limit_exceeded: "limit_exceeded";
+      file_missing: "file_missing";
+      file_mismatch: "file_mismatch";
+      record_invalid: "record_invalid";
+      record_count_mismatch: "record_count_mismatch";
+      record_order_invalid: "record_order_invalid";
+      duplicate_id: "duplicate_id";
+      dangling_reference: "dangling_reference";
+      reference_cycle: "reference_cycle";
+      media_ref_invalid: "media_ref_invalid";
+      media_blob_missing: "media_blob_missing";
+      media_blob_too_large: "media_blob_too_large";
+      target_not_empty: "target_not_empty";
+      locale_not_configured: "locale_not_configured";
+      field_type_unknown: "field_type_unknown";
+      principal_conflict: "principal_conflict";
+      integer_out_of_range: "integer_out_of_range";
+      value_constraint_violation: "value_constraint_violation";
+      unique_violation: "unique_violation";
+    }>;
+    message: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    detail: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+  }, z.core.$strict>>;
+  estimatedSteps: z.ZodNumber;
+}, z.core.$strict>;
+type SiteImportPlan = z.infer<typeof siteImportPlanSchema>;
+//#endregion
+//#region src/transfer/format/receipt.d.ts
+declare const siteImportReceiptSchema: z.ZodObject<{
+  operationId: z.ZodString;
+  packageDigest: z.ZodCustom<`sha256:${string}`, `sha256:${string}`>;
+  planDigest: z.ZodCustom<`sha256:${string}`, `sha256:${string}`>;
+  targetSiteId: z.ZodString;
+  originSiteId: z.ZodString;
+  formatVersion: z.ZodLiteral<"1">;
+  importerEmDashVersion: z.ZodString;
+  completedAt: z.ZodString;
+  logicalDigest: z.ZodCustom<`sha256:${string}`, `sha256:${string}`>;
+  counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  warnings: z.ZodArray<z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+  }, z.core.$strict>>;
+  verification: z.ZodLiteral<"verified">;
+  receiptDigest: z.ZodCustom<`sha256:${string}`, `sha256:${string}`>;
+}, z.core.$strict>;
+type SiteImportReceipt = z.infer<typeof siteImportReceiptSchema>;
+//#endregion
+//#region src/transfer/errors.d.ts
+/**
+ * JSON-safe, bounded detail attached to a transfer error. Never put record
+ * contents, credentials, or storage keys here: details reach API clients and
+ * operation rows.
+ */
+type TransferErrorDetail = Readonly<Record<string, string | number | boolean | null>>;
+//#endregion
+//#region src/transfer/ops/states.d.ts
+declare const TRANSFER_OPERATION_KINDS: readonly ["export", "import"];
+type TransferOperationKind = (typeof TRANSFER_OPERATION_KINDS)[number];
+declare const EXPORT_STATES: readonly ["pending", "running", "complete", "failed", "expired"];
+type ExportState = (typeof EXPORT_STATES)[number];
+declare const IMPORT_STATES: readonly ["uploading", "analyzing", "planned", "running", "verifying", "complete", "failed", "cancelled", "abandoned", "expired"];
+type ImportState = (typeof IMPORT_STATES)[number];
+type TransferOperationState = ExportState | ImportState;
+declare const exportCursorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  stage: z.ZodLiteral<"export_records">;
+  attempt: z.ZodNumber;
+  fence: z.ZodObject<{
+    writeEpoch: z.ZodNumber;
+    tables: z.ZodArray<z.ZodObject<{
+      table: z.ZodString;
+      count: z.ZodNumber;
+      maxChanged: z.ZodOptional<z.ZodString>;
+      maxId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  kind: z.ZodEnum<{
+    byline: "byline";
+    seo: "seo";
+    collection: "collection";
+    setting: "setting";
+    widget: "widget";
+    term: "term";
+    menu: "menu";
+    relation: "relation";
+    media: "media";
+    principal: "principal";
+    block_type: "block_type";
+    block_type_version: "block_type_version";
+    field: "field";
+    taxonomy_def: "taxonomy_def";
+    byline_field: "byline_field";
+    media_folder: "media_folder";
+    byline_field_value: "byline_field_value";
+    byline_field_group_value: "byline_field_group_value";
+    revision: "revision";
+    entry: "entry";
+    content_term: "content_term";
+    content_byline: "content_byline";
+    content_reference: "content_reference";
+    menu_item: "menu_item";
+    widget_area: "widget_area";
+    section: "section";
+    redirect: "redirect";
+    comment: "comment";
+    comment_reaction: "comment_reaction";
+  }>;
+  collection: z.ZodOptional<z.ZodString>;
+  after: z.ZodNullable<z.ZodObject<{
+    id: z.ZodString;
+    depth: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  nextSeq: z.ZodNumber;
+  summary: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"export_media">;
+  attempt: z.ZodNumber;
+  fence: z.ZodObject<{
+    writeEpoch: z.ZodNumber;
+    tables: z.ZodArray<z.ZodObject<{
+      table: z.ZodString;
+      count: z.ZodNumber;
+      maxChanged: z.ZodOptional<z.ZodString>;
+      maxId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  afterMediaId: z.ZodNullable<z.ZodString>;
+  summary: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"export_finalize">;
+  attempt: z.ZodNumber;
+  fence: z.ZodObject<{
+    writeEpoch: z.ZodNumber;
+    tables: z.ZodArray<z.ZodObject<{
+      table: z.ZodString;
+      count: z.ZodNumber;
+      maxChanged: z.ZodOptional<z.ZodString>;
+      maxId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  nextIndexSeq: z.ZodNumber;
+  afterPath: z.ZodNullable<z.ZodString>;
+  summary: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"export_validate">;
+  position: z.ZodNullable<z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>>;
+  validation: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>], "stage">;
+type ExportCursor = z.infer<typeof exportCursorSchema>;
+declare const analysisCursorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  stage: z.ZodLiteral<"analyze_structure">;
+  nextIndexSeq: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"analyze_records">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"analyze_references">;
+  check: z.ZodNumber;
+  after: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"analyze_target">;
+}, z.core.$strict>], "stage">;
+type AnalysisCursor = z.infer<typeof analysisCursorSchema>;
+declare const importCursorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  stage: z.ZodLiteral<"reserve">;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"clear_scaffold">;
+  step: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"schema">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"media">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"terms_bylines">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"content">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"relations">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"presentation">;
+  position: z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"rebuild">;
+  step: z.ZodEnum<{
+    search: "search";
+    taxonomies: "taxonomies";
+    options: "options";
+    media_usage: "media_usage";
+    caches: "caches";
+  }>;
+  after: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  stage: z.ZodLiteral<"verify">;
+  position: z.ZodNullable<z.ZodObject<{
+    kind: z.ZodEnum<{
+      byline: "byline";
+      seo: "seo";
+      collection: "collection";
+      setting: "setting";
+      widget: "widget";
+      term: "term";
+      menu: "menu";
+      relation: "relation";
+      media: "media";
+      principal: "principal";
+      block_type: "block_type";
+      block_type_version: "block_type_version";
+      field: "field";
+      taxonomy_def: "taxonomy_def";
+      byline_field: "byline_field";
+      media_folder: "media_folder";
+      byline_field_value: "byline_field_value";
+      byline_field_group_value: "byline_field_group_value";
+      revision: "revision";
+      entry: "entry";
+      content_term: "content_term";
+      content_byline: "content_byline";
+      content_reference: "content_reference";
+      menu_item: "menu_item";
+      widget_area: "widget_area";
+      section: "section";
+      redirect: "redirect";
+      comment: "comment";
+      comment_reaction: "comment_reaction";
+    }>;
+    seq: z.ZodNumber;
+    line: z.ZodNumber;
+  }, z.core.$strict>>;
+  mediaAfter: z.ZodNullable<z.ZodString>;
+  mismatches: z.ZodNumber;
+  verifier: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>], "stage">;
+type ImportCursor = z.infer<typeof importCursorSchema>;
+type TransferCursor = ExportCursor | AnalysisCursor | ImportCursor;
+/**
+ * Bounded progress summary shown by status endpoints. `done` of `total`
+ * counts stages (and, for an export, record kinds). `records` is the number
+ * of records an export has written so far; the byte counts cover package
+ * files once they are known.
+ */
+declare const transferProgressSchema: z.ZodObject<{
+  done: z.ZodNumber;
+  total: z.ZodNumber;
+  records: z.ZodOptional<z.ZodNumber>;
+  bytesDone: z.ZodOptional<z.ZodNumber>;
+  bytesTotal: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type TransferProgress = z.infer<typeof transferProgressSchema>;
+//#endregion
+//#region src/transfer/ops/operations.d.ts
+interface TransferOperation$1 {
+  id: string;
+  kind: TransferOperationKind;
+  state: TransferOperationState;
+  stage: string | null;
+  cursor: TransferCursor | null;
+  progress: TransferProgress | null;
+  options: unknown;
+  idempotencyKey: string | null;
+  packageDigest: Sha256Digest | null;
+  planDigest: Sha256Digest | null;
+  originSiteId: string | null;
+  /**
+   * 128-bit hex secret in the operation's staging prefix. Internal only:
+   * serialize operations for clients with {@link toPublicOperation}.
+   */
+  stagingSecret: string;
+  receipt: SiteImportReceipt | null;
+  errorCode: string | null;
+  errorDetail: TransferErrorDetail | null;
+  writeEpoch: number;
+  attemptCount: number;
+  leaseToken: string | null;
+  leaseExpiresAt: string | null;
+  runtimeGeneration: number;
+  cancelRequestedAt: string | null;
+  mutationStartedAt: string | null;
+  createdBy: string;
+  createdAt: string;
+  updatedAt: string;
+  completedAt: string | null;
+  expiresAt: string | null;
+  stagingCollectedAt: string | null;
+}
+/**
+ * An operation as it may be shown to API clients: without the staging secret
+ * and lease token.
+ */
+type PublicTransferOperation = Omit<TransferOperation$1, "stagingSecret" | "leaseToken">;
+//#endregion
 //#region src/client/portable-text.d.ts
 /**
  * Portable Text <-> Markdown conversion layer.
@@ -119,6 +969,8 @@ interface Field {
   widget?: string;
   options?: unknown;
   sortOrder?: number;
+  blockTypes?: BlockType[];
+  blockTypeFingerprint?: string;
 }
 /** Aggregate trust state for media usage reads */
 type MediaUsageCoverageStatus = "complete" | "never" | "running" | "partial" | "failed" | "stale" | "unknown";
@@ -156,10 +1008,15 @@ interface MediaUsageEntryDetail {
   deletedAt: string | null;
   sources: MediaUsageSourceDetail[];
 }
+/** A site setting that selects a media item */
+interface MediaUsageSiteSettingDetail {
+  setting: "logo" | "favicon" | "seo.defaultOgImage";
+}
 /** Entry-grouped media usage details */
 interface MediaUsageDetailsResponse {
   items: MediaUsageEntryDetail[];
   nextCursor?: string;
+  siteSettings: MediaUsageSiteSettingDetail[];
   coverage: MediaUsageCoverage;
 }
 /** Media item */
@@ -385,6 +1242,85 @@ interface Manifest {
     }>;
   }>;
 }
+/** User as listed by the admin users API */
+interface UserSummary {
+  id: string;
+  email: string;
+  name: string | null;
+  role: number;
+  disabled: boolean;
+}
+/** A site transfer operation (export or import) */
+type TransferOperation = PublicTransferOperation;
+/** Site transfer capabilities of an instance */
+interface TransferCapabilities {
+  formatVersions: string[];
+  features: string[];
+  optionalFeatures: string[];
+  limits: {
+    manifestBytes: number;
+    recordLineBytes: number;
+    chunkBytes: number;
+    chunkRecords: number;
+    totalRecords: number;
+    totalFiles: number;
+    indexChunks: number;
+    jsonDepth: number;
+    maxBlobBytes: number;
+  };
+  portableDomain: {
+    empty: boolean;
+    blockers: Array<Record<string, string>>;
+    seededScaffold: Array<Record<string, string>>;
+  };
+}
+/** Result of one bounded `advance` step */
+interface TransferAdvanceResult {
+  operation: TransferOperation;
+  /** Milliseconds until the next step should be requested, or null once the operation has ended. */
+  nextRequestInMs: number | null;
+}
+/** A package file the import has declared but not yet received */
+interface TransferPackageFile {
+  path: string;
+  bytes: number;
+  sha256: string;
+}
+interface TransferImportCreateResult {
+  operation: TransferOperation;
+  created: boolean;
+  missing: ListResult<TransferPackageFile>;
+}
+interface TransferFileUploadResult {
+  path: string;
+  bytes: number;
+  /** True when the file was already stored and the uploaded bytes matched it. */
+  alreadyVerified: boolean;
+  /** Declared files still to upload. */
+  remaining: number;
+}
+interface TransferImportAnalyzeResult {
+  operation: TransferOperation;
+  plan?: SiteImportPlan;
+  planDigest?: Sha256Digest;
+  /** Milliseconds until the next step should be requested, or null once analysis has ended. */
+  nextRequestInMs: number | null;
+}
+interface TransferImportStatus {
+  operation: TransferOperation;
+  files: {
+    declared: number;
+    verified: number;
+  };
+}
+/** A downloaded export file, streamed */
+interface TransferFileDownload {
+  body: ReadableStream<Uint8Array>;
+  /** Size from `Content-Length`, when sent */
+  bytes: number | null;
+  /** Hex SHA-256 from the `ETag`, when sent */
+  sha256: string | null;
+}
 declare class EmDashApiError extends Error {
   readonly status: number;
   readonly code: string;
@@ -404,6 +1340,11 @@ declare class EmDashClient {
   collections(): Promise<Collection[]>;
   /** Get a single collection with its fields */
   collection(slug: string): Promise<CollectionWithFields>;
+  blockTypes(): Promise<BlockType[]>;
+  blockType(slug: string): Promise<BlockType>;
+  createBlockType(input: CreateBlockTypeInput): Promise<BlockType>;
+  updateBlockType(slug: string, input: UpdateBlockTypeInput): Promise<BlockType>;
+  activateBlockTypeVersion(slug: string, version: number, expectedFingerprint: string): Promise<BlockType>;
   /** Create a collection */
   createCollection(input: {
     slug: string;
@@ -470,6 +1411,8 @@ declare class EmDashClient {
     status?: string;
     locale?: string;
     translationOf?: string;
+    migrateBlocks?: boolean;
+    replaceBlocks?: boolean;
   }): Promise<ContentItem>;
   /**
    * Update a content item. Pass `_rev` from a prior get() for optimistic
@@ -481,7 +1424,9 @@ declare class EmDashClient {
     slug?: string;
     status?: string;
     _rev?: string;
-    locale?: string; /** Write even though another editor holds this entry's edit lock. */
+    locale?: string;
+    migrateBlocks?: boolean;
+    replaceBlocks?: boolean; /** Write even though another editor holds this entry's edit lock. */
     overrideLock?: boolean;
   }): Promise<ContentItem>;
   /** Delete (soft) a content item */
@@ -618,15 +1563,116 @@ declare class EmDashClient {
   menus(): Promise<Menu[]>;
   /** Get a menu with its items */
   menu(name: string): Promise<MenuWithItems>;
+  /** List users (admin only) */
+  users(options?: {
+    search?: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListResult<UserSummary>>;
+  /** Formats, features, limits, and whether this site can receive an import */
+  transferCapabilities(): Promise<TransferCapabilities>;
+  /**
+   * Start a site export. With an idempotency key, repeating the call returns
+   * the export first created with that key.
+   */
+  transferExportCreate(options?: {
+    comments?: boolean;
+  }, request?: {
+    idempotencyKey?: string;
+  }): Promise<{
+    operation: TransferOperation;
+    created: boolean;
+  }>;
+  /** List exports, newest first */
+  transferExportList(options?: {
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListResult<TransferOperation>>;
+  transferExportGet(id: string): Promise<{
+    operation: TransferOperation;
+  }>;
+  /** Run one bounded export step */
+  transferExportAdvance(id: string): Promise<TransferAdvanceResult>;
+  /** The complete export's `manifest.json`, byte for byte */
+  transferExportManifest(id: string): Promise<Uint8Array>;
+  /**
+   * Stream one file of a complete export. The server ends the stream with an
+   * error if the stored bytes no longer match the export, so callers must
+   * still check the size and digest of what they receive.
+   */
+  transferExportFile(id: string, path: string): Promise<TransferFileDownload>;
+  /**
+   * Create an import from a package's `manifest.json` bytes. With an
+   * idempotency key, repeating the call with the same manifest returns the
+   * import first created with that key.
+   */
+  transferImportCreate(manifest: Uint8Array, request?: {
+    idempotencyKey?: string;
+  }): Promise<TransferImportCreateResult>;
+  /** List imports, newest first */
+  transferImportList(options?: {
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListResult<TransferOperation>>;
+  transferImportGet(id: string): Promise<TransferImportStatus>;
+  /** Declared package files not uploaded yet, in path order */
+  transferImportMissing(id: string, options?: {
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListResult<TransferPackageFile>>;
+  /**
+   * Upload one declared package file. `bytes` must be the file's exact size;
+   * a stream body is sent with that `Content-Length`.
+   */
+  transferImportUploadFile(id: string, path: string, body: Uint8Array | ReadableStream<Uint8Array>, bytes: number): Promise<TransferFileUploadResult>;
+  /**
+   * Run one bounded analysis step. Once the import is planned the result
+   * carries the plan; `decisions` are then applied, producing a new plan
+   * digest.
+   */
+  transferImportAnalyze(id: string, decisions?: SiteImportDecisionsInput): Promise<TransferImportAnalyzeResult>;
+  transferImportPlan(id: string): Promise<{
+    plan: SiteImportPlan;
+    planDigest: Sha256Digest;
+  }>;
+  /** Start a planned import. Both digests must match the reviewed package and plan. */
+  transferImportExecute(id: string, input: {
+    packageDigest: string;
+    planDigest: string;
+  }): Promise<{
+    operation: TransferOperation;
+  }>;
+  /** Run one bounded step of an executing import */
+  transferImportAdvance(id: string): Promise<TransferAdvanceResult>;
+  transferImportReceipt(id: string): Promise<{
+    receipt: SiteImportReceipt;
+  }>;
+  /**
+   * Cancel an import. An idle import is cancelled at once; a step in
+   * progress stops after its current batch, so the returned operation may
+   * still be executing with `cancelRequestedAt` set.
+   */
+  transferImportCancel(id: string): Promise<{
+    operation: TransferOperation;
+  }>;
+  /**
+   * Abandon a failed or cancelled import, lifting the site write fence it
+   * holds. Data the import already wrote stays in place.
+   */
+  transferImportAbandon(id: string): Promise<{
+    operation: TransferOperation;
+  }>;
   /** Make a typed JSON request to the API */
   private request;
   /** Make a raw request — caller handles response */
   private requestRaw;
+  /** Send a request with an arbitrary body; the caller handles the response */
+  private send;
   /** Assert a response is OK, throw typed error if not */
   private assertOk;
   /** Get cached field schemas for a collection, fetching if needed */
   private getFieldSchemas;
 }
 //#endregion
-export { ApiError, ClientResponse, Collection, CollectionWithFields, ContentItem, EmDashApiError, EmDashClient, EmDashClientError, EmDashClientOptions, Field, type Interceptor, ListResult, Manifest, MediaFolder, MediaFolderAssignment, MediaItem, MediaUsageActivationAdvanceInput, MediaUsageActivationAdvanceResponse, MediaUsageActivationStatus, MediaUsageCollectionDeletionItem, MediaUsageCollectionDeletionListResponse, MediaUsageCollectionDeletionPhase, MediaUsageCollectionDeletionState, MediaUsageCoverage, MediaUsageCoverageStatus, MediaUsageDetailsResponse, MediaUsageEntryDetail, MediaUsageOccurrenceDetail, MediaUsageProgress, MediaUsageProgressAdvanceResponse, MediaUsageRepairCollectionSummary, MediaUsageRepairInput, MediaUsageRepairResponse, MediaUsageRepairStatus, MediaUsageSourceDetail, MediaUsageSummary, MediaUsageWorkItem, MediaUsageWorkListOptions, MediaUsageWorkListResponse, MediaUsageWorkRetryInput, MediaUsageWorkRetryResponse, MediaUsageWorkState, Menu, MenuItem, MenuWithItems, type PortableTextBlock, SchemaExport, SearchResult, Taxonomy, Term, createTransport, csrfInterceptor, devBypassInterceptor, markdownToPortableText, portableTextToMarkdown, tokenInterceptor };
+export { ApiError, ClientResponse, Collection, CollectionWithFields, ContentItem, EmDashApiError, EmDashClient, EmDashClientError, EmDashClientOptions, Field, type Interceptor, ListResult, Manifest, MediaFolder, MediaFolderAssignment, MediaItem, MediaUsageActivationAdvanceInput, MediaUsageActivationAdvanceResponse, MediaUsageActivationStatus, MediaUsageCollectionDeletionItem, MediaUsageCollectionDeletionListResponse, MediaUsageCollectionDeletionPhase, MediaUsageCollectionDeletionState, MediaUsageCoverage, MediaUsageCoverageStatus, MediaUsageDetailsResponse, MediaUsageEntryDetail, MediaUsageOccurrenceDetail, MediaUsageProgress, MediaUsageProgressAdvanceResponse, MediaUsageRepairCollectionSummary, MediaUsageRepairInput, MediaUsageRepairResponse, MediaUsageRepairStatus, MediaUsageSiteSettingDetail, MediaUsageSourceDetail, MediaUsageSummary, MediaUsageWorkItem, MediaUsageWorkListOptions, MediaUsageWorkListResponse, MediaUsageWorkRetryInput, MediaUsageWorkRetryResponse, MediaUsageWorkState, Menu, MenuItem, MenuWithItems, type PortableTextBlock, SchemaExport, SearchResult, type Sha256Digest, type SiteImportDecisionsInput, type SiteImportPlan, type SiteImportReceipt, Taxonomy, Term, TransferAdvanceResult, TransferCapabilities, TransferFileDownload, TransferFileUploadResult, TransferImportAnalyzeResult, TransferImportCreateResult, TransferImportStatus, TransferOperation, TransferPackageFile, UserSummary, createTransport, csrfInterceptor, devBypassInterceptor, markdownToPortableText, portableTextToMarkdown, tokenInterceptor };
 //# sourceMappingURL=index.d.mts.map