@embedpdf/engine-core 3.0.0-next.0

package/dist/wire.d.cts

@@ -0,0 +1,1546 @@
+import { $ as CaretDraftSchema, $i as LayerScopes, $t as CircleDraftSchema, A as FileAttachmentWireDraftSchema, Aa as EmbeddedFileItem, Ac as PdfSize, Ai as AnnotationCreateResult, Ar as FormFieldDeleteResult, Bc as PdfPageActions, Bo as PageRenderOptions, Cc as InkList, Ci as ToggleFieldWidget, Co as AnnotationAppearancesQuery, Cr as SearchQuery, D as FileAttachmentDTOSchema, Dc as PdfQuad, Di as FormWidgetRef, Dn as HighlightPatchSchema, Dr as SearchSnippet, Dt as LinePatchSchema, Ec as PdfPoint, Ei as FormFieldRef, En as HighlightDraftSchema, Er as SearchSliceBudget, Et as LineDraftSchema, F as StampDTOSchema, Fc as PdfActionTree, Fn as RedactionApplyScope, Fo as PageNetworkRenderFormat, Fr as FormWidgetLinkResult, G as TextDTOSchema, Gi as CacheDelta, Gn as PageRotateResult, Gr as FormFieldPatch, Hr as FormFieldValue, Hs as DocCapability, I as StampWireDraftSchema, Ii as AppearanceOutcome, Ir as FormEffect, Jn as PageMoveResult, Jo as PageTextSnapshot, Jt as SquarePatchSchema, K as TextDraftSchema, Ki as MutationMeta, Kn as PageRotateInput, Kt as SquareDTOSchema, L as StampWirePatchSchema, Ln as PageFlattenInput, Lt as PolygonDTOSchema, Mc as DocumentActionsSnapshot, Mi as AnnotationMoveResult, Mn as MetadataUpdateResult, Mo as PageImageOptions, Mr as FormImportResult, Mt as PolylineDraftSchema, Ni as AnnotationUpdateResult, Nr as FormRepairResult, Nt as PolylinePatchSchema, O as FileAttachmentIconSchema, Oa as AttachmentFileInfo, Oc as PdfRect, P as ResourceRefSchema, Pc as PdfActionNode, Pn as RedactionApplyResult, Pr as FormSetValueResult, Q as CaretDTOSchema, Qi as LayerScopePlane, Qr as FormFieldOptionInput, Qs as RevisionToken, Qt as CircleDTOSchema, Rc as PdfAnnotationActions, Rt as PolygonDraftSchema, Sc as CalloutLine, So as AnnotationAppearanceRenderOptions, Tc as LinePoints, Ti as FormValueEntry, Tn as HighlightDTOSchema, To as PageState, Tr as SearchSlice, Tt as LineDTOSchema, Ui as AnnotationListMutationMeta, Un as PageDeleteResult, Vc as DocumentMetadata, Vo as PageRenderQuery, Vr as FormDataFormat, W as NoteIconSchema, Wi as RefetchReason, Wn as PageDeleteInput, Xi as DocumentManifest, Xn as PageMoveInput, Yn as PageStructureCache, Ys as PdfBits, Zi as ManifestPage, Zr as FormFieldDraft, Zs as AnnotationRef, _ as UnsupportedPatchSchema, _t as LinkDraftSchema, a as AnnotationDTOSchema, ac as BlendMode, ao as SerializedEngineError, at as FreeTextDraftSchema, bc as StrikeoutIntent, bn as UnderlineDraftSchema, bt as PdfLinkTargetSchema, cn as StrikeoutDraftSchema, cs as PageLayout, da as AttachmentsCache, dc as LineEnding, dt as InkDraftSchema, en as CirclePatchSchema, eo as AnnotationStableId, et as CaretPatchSchema, f as KIND_BY_SUBTYPE, fc as LineEndings, ft as InkPatchSchema, g as UnsupportedDraftSchema, gi as FormFieldOption, go as AnnotationAppearanceImageOptions, gt as LinkDTOSchema, h as UnsupportedDTOSchema, hi as FormFieldFlags, hn as SquigglyPatchSchema, ii as FormSnapshot, it as FreeTextDTOSchema, j as WireAttachmentFileSchema, ja as EmbeddedFileRef, ji as AnnotationDeleteResult, jr as FormFieldUpdateResult, jt as PolylineDTOSchema, k as FileAttachmentPatchSchema, kc as PdfRotation, kr as FormFieldCreateResult, la as AttachmentCreateResult, lc as FreeTextIntent, ln as StrikeoutPatchSchema, mc as PdfRectDifferences, mn as SquigglyDraftSchema, mo as CachePins, n as AnnotationListSnapshotAllPages, nc as AnnotationBorderStyle, ni as WidgetPlacement, oc as CaretIntent, oi as WidgetAppearanceSchema, os as PageListSnapshot, ot as FreeTextPatchSchema, pi as FormFieldDTO, pn as SquigglyDTOSchema, po as PdfSaveMode, q as TextPatchSchema, qo as PageGeometrySnapshot, qt as SquareDraftSchema, r as ANNOTATION_KINDS, rc as AnnotationFlags, ri as FormKind, s as AnnotationDraftSchema, sc as Color, sn as StrikeoutDTOSchema, ss as PageBoxes, t as AnnotationListPageSnapshot, u as AnnotationPatchSchema, ua as AttachmentDeleteResult, uc as InkIntent, us as MetadataPatch, ut as InkDTOSchema, vo as AnnotationAppearanceManifest, vt as LinkPatchSchema, wr as SearchRequest, xc as TextAlignment, xn as UnderlinePatchSchema, xr as SearchMatch, xt as PdfLinkTargetWritableSchema, yc as StandardFont, yn as UnderlineDTOSchema, yt as PdfDestinationSchema, zc as PdfFieldActions, zn as PageFlattenResult, zr as FormEffectsResult, zt as PolygonPatchSchema } from "./AnnotationListSnapshot-W0RCsyDE.cjs";
+import { c as DocumentSecurityState, f as PdfPermissionInfo } from "./DocumentSecurityService-Df79fgpe.cjs";
+import { z } from "zod";
+//#region src/geometry/schemas.d.ts
+declare const PdfPointSchema: z.ZodType<PdfPoint>;
+declare const LinePointsSchema: z.ZodType<LinePoints>;
+/** `/CL` callout leader line — two points (straight) or three (knee-jointed). */
+declare const CalloutLineSchema: z.ZodType<CalloutLine>;
+/** `/InkList` — an array of strokes, each an array of points. */
+declare const InkListSchema: z.ZodType<InkList>;
+declare const PdfRectSchema: z.ZodType<PdfRect>;
+declare const PdfSizeSchema: z.ZodType<PdfSize>;
+declare const PdfQuadSchema: z.ZodType<PdfQuad>;
+declare const PdfRotationSchema: z.ZodType<PdfRotation>;
+//#endregion
+//#region src/wire/schemas.d.ts
+declare const DocumentMetadataSchema: z.ZodType<DocumentMetadata>;
+/**
+ * Three-state metadata patch. Mirrors annotation patch semantics:
+ * `undefined` leaves a field, `null` clears it, a value sets it. `custom`
+ * is a per-key three-state map (string set / null clear / absent leave).
+ */
+declare const MetadataPatchSchema: z.ZodType<MetadataPatch>;
+declare const OpenDocumentResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+}, {
+  id: string;
+}>;
+type OpenDocumentResponse = z.infer<typeof OpenDocumentResponseSchema>;
+/**
+ * Wire shape of `GET /v1/docs/:docId/head`. Mirrors the server-side
+ * `DocumentHead` interface; the schema is the source of truth so
+ * older SDKs talking to newer servers degrade gracefully (extra
+ * fields are accepted and ignored).
+ *
+ * `docVersion` is the single monotonic integer per doc; it bumps on
+ * ANY mutation that could change the manifest's content (page list,
+ * per-page content, per-page annotations, per-page weak-flag), which
+ * makes `/manifest@docVersion=N` fully content-addressed and cache-friendly.
+ * Phase 4 hard-codes it to `1`; Phase 5's mutation handler is what
+ * actually bumps it.
+ */
+declare const DocumentHeadSchema: z.ZodObject<{
+  id: z.ZodString;
+  baseSha: z.ZodString;
+  storageSizeBytes: z.ZodNumber;
+  docVersion: z.ZodNumber;
+  state: z.ZodEnum<["pending", "ready", "failed", "deleting"]>;
+  encryption: z.ZodObject<{
+    state: z.ZodEnum<["unknown", "none", "encrypted", "unsupported"]>;
+    requiresPassword: z.ZodNullable<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    state: "none" | "unknown" | "encrypted" | "unsupported";
+    requiresPassword: boolean | null;
+  }, {
+    state: "none" | "unknown" | "encrypted" | "unsupported";
+    requiresPassword: boolean | null;
+  }>;
+  permissions: z.ZodObject<{
+    known: z.ZodBoolean;
+    bits: z.ZodNullable<z.ZodNumber>;
+    allAllowed: z.ZodNullable<z.ZodBoolean>;
+    openedAs: z.ZodNullable<z.ZodEnum<["none", "user", "owner"]>>;
+    securityHandlerRevision: z.ZodNullable<z.ZodNumber>;
+    canUpgradeToOwner: z.ZodBoolean;
+  }, "strip", z.ZodTypeAny, {
+    known: boolean;
+    bits: number | null;
+    allAllowed: boolean | null;
+    openedAs: "none" | "user" | "owner" | null;
+    securityHandlerRevision: number | null;
+    canUpgradeToOwner: boolean;
+  }, {
+    known: boolean;
+    bits: number | null;
+    allAllowed: boolean | null;
+    openedAs: "none" | "user" | "owner" | null;
+    securityHandlerRevision: number | null;
+    canUpgradeToOwner: boolean;
+  }>;
+  access: z.ZodObject<{
+    required: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodEnum<["password", "cdn", "permissions-unknown"]>, "many">;
+    endpoint: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    required: boolean;
+    reasons: ("password" | "cdn" | "permissions-unknown")[];
+    endpoint?: string | undefined;
+  }, {
+    required: boolean;
+    reasons: ("password" | "cdn" | "permissions-unknown")[];
+    endpoint?: string | undefined;
+  }>;
+}, "strip", z.ZodTypeAny, {
+  docVersion: number;
+  id: string;
+  baseSha: string;
+  storageSizeBytes: number;
+  state: "pending" | "ready" | "failed" | "deleting";
+  encryption: {
+    state: "none" | "unknown" | "encrypted" | "unsupported";
+    requiresPassword: boolean | null;
+  };
+  permissions: {
+    known: boolean;
+    bits: number | null;
+    allAllowed: boolean | null;
+    openedAs: "none" | "user" | "owner" | null;
+    securityHandlerRevision: number | null;
+    canUpgradeToOwner: boolean;
+  };
+  access: {
+    required: boolean;
+    reasons: ("password" | "cdn" | "permissions-unknown")[];
+    endpoint?: string | undefined;
+  };
+}, {
+  docVersion: number;
+  id: string;
+  baseSha: string;
+  storageSizeBytes: number;
+  state: "pending" | "ready" | "failed" | "deleting";
+  encryption: {
+    state: "none" | "unknown" | "encrypted" | "unsupported";
+    requiresPassword: boolean | null;
+  };
+  permissions: {
+    known: boolean;
+    bits: number | null;
+    allAllowed: boolean | null;
+    openedAs: "none" | "user" | "owner" | null;
+    securityHandlerRevision: number | null;
+    canUpgradeToOwner: boolean;
+  };
+  access: {
+    required: boolean;
+    reasons: ("password" | "cdn" | "permissions-unknown")[];
+    endpoint?: string | undefined;
+  };
+}>;
+type DocumentHead = z.infer<typeof DocumentHeadSchema>;
+declare const AccessRequestSchema: z.ZodObject<{
+  docId: z.ZodString;
+  layerName: z.ZodOptional<z.ZodString>;
+  password: z.ZodOptional<z.ZodString>;
+  passwordGrant: z.ZodOptional<z.ZodString>;
+  mode: z.ZodOptional<z.ZodEnum<["any", "owner"]>>;
+}, "strip", z.ZodTypeAny, {
+  docId: string;
+  mode?: "owner" | "any" | undefined;
+  password?: string | undefined;
+  layerName?: string | undefined;
+  passwordGrant?: string | undefined;
+}, {
+  docId: string;
+  mode?: "owner" | "any" | undefined;
+  password?: string | undefined;
+  layerName?: string | undefined;
+  passwordGrant?: string | undefined;
+}>;
+type AccessRequest = z.infer<typeof AccessRequestSchema>;
+declare const DocumentSecurityStateSchema: z.ZodType<DocumentSecurityState>;
+declare const AccessResponseSchema: z.ZodObject<{
+  security: z.ZodType<DocumentSecurityState, z.ZodTypeDef, DocumentSecurityState>;
+  cdn: z.ZodObject<{
+    adapter: z.ZodEnum<["none", "cloudfront", "cloud-cdn", "bunny", "azure-fd", "custom-hmac"]>;
+    expiresAt: z.ZodNumber;
+    cache: z.ZodObject<{
+      scope: z.ZodEnum<["browser-private", "edge-shared"]>;
+      immutableVersionedReads: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+      scope: "browser-private" | "edge-shared";
+      immutableVersionedReads: boolean;
+    }, {
+      scope: "browser-private" | "edge-shared";
+      immutableVersionedReads: boolean;
+    }>;
+    baseUrlOverrides: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    authHeader: z.ZodNullable<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      name: string;
+    }, {
+      value: string;
+      name: string;
+    }>>;
+    signedQueryParams: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    signedCookies: z.ZodNullable<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      value: z.ZodString;
+      domain: z.ZodOptional<z.ZodString>;
+      path: z.ZodOptional<z.ZodString>;
+      expires: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      name: string;
+      path?: string | undefined;
+      domain?: string | undefined;
+      expires?: number | undefined;
+    }, {
+      value: string;
+      name: string;
+      path?: string | undefined;
+      domain?: string | undefined;
+      expires?: number | undefined;
+    }>, "many">>;
+    signedPathPolicies: z.ZodNullable<z.ZodArray<z.ZodObject<{
+      pathPrefix: z.ZodString;
+      queryParams: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+      pathPrefix: string;
+      queryParams: Record<string, string>;
+    }, {
+      pathPrefix: string;
+      queryParams: Record<string, string>;
+    }>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    adapter: "none" | "cloudfront" | "cloud-cdn" | "bunny" | "azure-fd" | "custom-hmac";
+    expiresAt: number;
+    cache: {
+      scope: "browser-private" | "edge-shared";
+      immutableVersionedReads: boolean;
+    };
+    baseUrlOverrides: Record<string, string> | null;
+    authHeader: {
+      value: string;
+      name: string;
+    } | null;
+    signedQueryParams: Record<string, string> | null;
+    signedCookies: {
+      value: string;
+      name: string;
+      path?: string | undefined;
+      domain?: string | undefined;
+      expires?: number | undefined;
+    }[] | null;
+    signedPathPolicies: {
+      pathPrefix: string;
+      queryParams: Record<string, string>;
+    }[] | null;
+  }, {
+    adapter: "none" | "cloudfront" | "cloud-cdn" | "bunny" | "azure-fd" | "custom-hmac";
+    expiresAt: number;
+    cache: {
+      scope: "browser-private" | "edge-shared";
+      immutableVersionedReads: boolean;
+    };
+    baseUrlOverrides: Record<string, string> | null;
+    authHeader: {
+      value: string;
+      name: string;
+    } | null;
+    signedQueryParams: Record<string, string> | null;
+    signedCookies: {
+      value: string;
+      name: string;
+      path?: string | undefined;
+      domain?: string | undefined;
+      expires?: number | undefined;
+    }[] | null;
+    signedPathPolicies: {
+      pathPrefix: string;
+      queryParams: Record<string, string>;
+    }[] | null;
+  }>;
+  passwordGrant: z.ZodNullable<z.ZodString>;
+  pdfPermissions: z.ZodNullable<z.ZodType<PdfPermissionInfo, z.ZodTypeDef, PdfPermissionInfo>>;
+  scope: z.ZodArray<z.ZodString, "many">;
+  /**
+   * Concrete capability set granted to this caller after expanding
+   * `pdf.permissions` and applying resolver implication rules. Client
+   * UI should drive feature visibility off this, not off raw `scope`.
+   * Always present in /access responses (server populates from
+   * `expandRawScope`). Sorted alphabetically for stable change
+   * detection.
+   */
+  effectiveScope: z.ZodArray<z.ZodString, "many">;
+  identity: z.ZodObject<{
+    user_id: z.ZodOptional<z.ZodString>;
+    group_id: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    display_name: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    user_id?: string | undefined;
+    group_id?: string | undefined;
+    groups?: string[] | undefined;
+    display_name?: string | undefined;
+  }, {
+    user_id?: string | undefined;
+    group_id?: string | undefined;
+    groups?: string[] | undefined;
+    display_name?: string | undefined;
+  }>;
+  originPasswordPolicy: z.ZodObject<{
+    mode: z.ZodEnum<["not-needed", "client-retry", "server-session"]>;
+  }, "strip", z.ZodTypeAny, {
+    mode: "not-needed" | "client-retry" | "server-session";
+  }, {
+    mode: "not-needed" | "client-retry" | "server-session";
+  }>;
+  expiresAt: z.ZodNumber;
+  /**
+   * The deployment's render lattice — the canonical parameter points the
+   * server treats as durable, CDN-shared artifacts. Lives HERE and never in
+   * the manifest: manifests are version-pinned immutable objects; the
+   * lattice is mutable deployment policy. The SDK exposes it (and a pure
+   * `snap` helper) but NEVER conforms requests implicitly — the same render
+   * call must not return different pixels on local vs cloud. When
+   * `enforced` is true the server rejects off-lattice render tokens with
+   * 400; when false, off-lattice renders are computed but not persisted.
+   * Absent on older servers → treat as unenforced/unknown.
+   */
+  renderPolicy: z.ZodOptional<z.ZodObject<{
+    /**
+     * Full-page renders quantize on `viewport.width` — the bounded
+     * quantity is OUTPUT PIXELS, never zoom (PDF page space is
+     * effectively unbounded, so a scale lattice bounds artifact count
+     * but not size).
+     */
+    fullPage: z.ZodObject<{
+      widths: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+      widths: number[];
+    }, {
+      widths: number[];
+    }>;
+    /**
+     * RESERVED for deep-zoom tile support: scale-based pyramid ×
+     * fixed tile size, constant per-job cost. Absent until the tiling
+     * plugin ships.
+     */
+    tiles: z.ZodOptional<z.ZodObject<{
+      tileSizes: z.ZodArray<z.ZodNumber, "many">;
+      scales: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+      tileSizes: number[];
+      scales: number[];
+    }, {
+      tileSizes: number[];
+      scales: number[];
+    }>>;
+    /**
+     * Annotation-appearance lattice — SCALE-based (appearances are sized
+     * by `rect × scale` and must track the page's effective render scale
+     * for crisp composites).
+     */
+    appearances: z.ZodOptional<z.ZodObject<{
+      scales: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+      scales: number[];
+    }, {
+      scales: number[];
+    }>>;
+    /** Worker-side output budget for degenerate page geometry. */
+    maxRenderPixels: z.ZodOptional<z.ZodNumber>;
+    formats: z.ZodArray<z.ZodEnum<["webp", "png"]>, "many">;
+    background: z.ZodEnum<["white"]>;
+    enforced: z.ZodBoolean;
+  }, "strip", z.ZodTypeAny, {
+    background: "white";
+    fullPage: {
+      widths: number[];
+    };
+    formats: ("webp" | "png")[];
+    enforced: boolean;
+    tiles?: {
+      tileSizes: number[];
+      scales: number[];
+    } | undefined;
+    appearances?: {
+      scales: number[];
+    } | undefined;
+    maxRenderPixels?: number | undefined;
+  }, {
+    background: "white";
+    fullPage: {
+      widths: number[];
+    };
+    formats: ("webp" | "png")[];
+    enforced: boolean;
+    tiles?: {
+      tileSizes: number[];
+      scales: number[];
+    } | undefined;
+    appearances?: {
+      scales: number[];
+    } | undefined;
+    maxRenderPixels?: number | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  cdn: {
+    adapter: "none" | "cloudfront" | "cloud-cdn" | "bunny" | "azure-fd" | "custom-hmac";
+    expiresAt: number;
+    cache: {
+      scope: "browser-private" | "edge-shared";
+      immutableVersionedReads: boolean;
+    };
+    baseUrlOverrides: Record<string, string> | null;
+    authHeader: {
+      value: string;
+      name: string;
+    } | null;
+    signedQueryParams: Record<string, string> | null;
+    signedCookies: {
+      value: string;
+      name: string;
+      path?: string | undefined;
+      domain?: string | undefined;
+      expires?: number | undefined;
+    }[] | null;
+    signedPathPolicies: {
+      pathPrefix: string;
+      queryParams: Record<string, string>;
+    }[] | null;
+  };
+  passwordGrant: string | null;
+  security: DocumentSecurityState;
+  expiresAt: number;
+  scope: string[];
+  pdfPermissions: PdfPermissionInfo | null;
+  effectiveScope: string[];
+  identity: {
+    user_id?: string | undefined;
+    group_id?: string | undefined;
+    groups?: string[] | undefined;
+    display_name?: string | undefined;
+  };
+  originPasswordPolicy: {
+    mode: "not-needed" | "client-retry" | "server-session";
+  };
+  renderPolicy?: {
+    background: "white";
+    fullPage: {
+      widths: number[];
+    };
+    formats: ("webp" | "png")[];
+    enforced: boolean;
+    tiles?: {
+      tileSizes: number[];
+      scales: number[];
+    } | undefined;
+    appearances?: {
+      scales: number[];
+    } | undefined;
+    maxRenderPixels?: number | undefined;
+  } | undefined;
+}, {
+  cdn: {
+    adapter: "none" | "cloudfront" | "cloud-cdn" | "bunny" | "azure-fd" | "custom-hmac";
+    expiresAt: number;
+    cache: {
+      scope: "browser-private" | "edge-shared";
+      immutableVersionedReads: boolean;
+    };
+    baseUrlOverrides: Record<string, string> | null;
+    authHeader: {
+      value: string;
+      name: string;
+    } | null;
+    signedQueryParams: Record<string, string> | null;
+    signedCookies: {
+      value: string;
+      name: string;
+      path?: string | undefined;
+      domain?: string | undefined;
+      expires?: number | undefined;
+    }[] | null;
+    signedPathPolicies: {
+      pathPrefix: string;
+      queryParams: Record<string, string>;
+    }[] | null;
+  };
+  passwordGrant: string | null;
+  security: DocumentSecurityState;
+  expiresAt: number;
+  scope: string[];
+  pdfPermissions: PdfPermissionInfo | null;
+  effectiveScope: string[];
+  identity: {
+    user_id?: string | undefined;
+    group_id?: string | undefined;
+    groups?: string[] | undefined;
+    display_name?: string | undefined;
+  };
+  originPasswordPolicy: {
+    mode: "not-needed" | "client-retry" | "server-session";
+  };
+  renderPolicy?: {
+    background: "white";
+    fullPage: {
+      widths: number[];
+    };
+    formats: ("webp" | "png")[];
+    enforced: boolean;
+    tiles?: {
+      tileSizes: number[];
+      scales: number[];
+    } | undefined;
+    appearances?: {
+      scales: number[];
+    } | undefined;
+    maxRenderPixels?: number | undefined;
+  } | undefined;
+}>;
+type AccessResponse = z.infer<typeof AccessResponseSchema>;
+type RenderPolicy = NonNullable<AccessResponse['renderPolicy']>;
+declare const PdfSaveModeSchema: z.ZodType<PdfSaveMode>;
+declare const EngineErrorPayloadSchema: z.ZodType<SerializedEngineError>;
+declare const PageStateSchema: z.ZodType<PageState>;
+declare const CachePinsSchema: z.ZodType<CachePins>;
+declare const LayerScopesSchema: z.ZodType<LayerScopes>;
+/**
+ * Per-page envelope inside `DocumentManifest`. Carries the full
+ * `PageState` plus the cache-busting integers the SDK embeds in
+ * leaf URLs (`/pages/:pon/text@contentVersion=N`, `/pages/:pon/annotations@annotationVersion=N`).
+ *
+ * `contentVersion` bumps when the page's content stream changes
+ * (text, page reorder doesn't, the pon is durable). `annotationVersion`
+ * bumps when /Annots gains/loses entries or when a tracked annotation
+ * mutates. `hasWeakAnnotations` is hoisted from `PageState` so the
+ * SDK can decide whether to display a "stale-on-reorder" badge
+ * without re-fetching the page.
+ *
+ * Phase 4 hard-codes all three to (1, 1, false); Phase 5's
+ * `layer_pages` table drives the real values.
+ */
+declare const ManifestPageSchema: z.ZodType<ManifestPage>;
+/**
+ * Wire shape of `GET /v1/docs/:docId/manifest@docVersion=N`. Content-addressed
+ * by `docVersion`; safe to cache with `Cache-Control: public,
+ * max-age=31536000, immutable`.
+ */
+declare const DocumentManifestSchema: z.ZodType<DocumentManifest>;
+declare const AnnotationListPageSnapshotSchema: z.ZodType<AnnotationListPageSnapshot>;
+declare const AnnotationListSnapshotAllPagesSchema: z.ZodType<AnnotationListSnapshotAllPages>;
+/**
+ * Wire shape of `GET /v1/docs/:docId/pages/:pon/text@contentVersion=N` and the
+ * `pages.text` worker result. Carries the same `pageState` envelope
+ * every page-scoped read returns, plus the full plain-text extraction
+ * in display order and PDFium's char-count (which may exceed
+ * `text.length / 1` when astral-plane characters are present).
+ */
+declare const PageTextSnapshotSchema: z.ZodType<PageTextSnapshot>;
+declare const PageGeometrySnapshotSchema: z.ZodType<PageGeometrySnapshot>;
+/**
+ * Search wire shapes: the request body of the layer search route and the
+ * `search.query` worker/route result. The server re-validates the query
+ * semantics (`validateSearchQuery`: regex dialect + flag combos) after
+ * parse — the schema only checks structure.
+ */
+declare const SearchQuerySchema: z.ZodType<SearchQuery>;
+declare const SearchModeSchema: z.ZodEnum<["rects", "full"]>;
+declare const SearchRequestSchema: z.ZodType<SearchRequest>;
+declare const SearchSnippetSchema: z.ZodType<SearchSnippet>;
+declare const SearchMatchSchema: z.ZodType<SearchMatch>;
+declare const SearchSliceSchema: z.ZodType<SearchSlice>;
+declare const PageNetworkRenderFormatSchema: z.ZodType<PageNetworkRenderFormat>;
+/** Query/token schema for the annotation-free render family (`page-render`). */
+declare const PageRenderQuerySchema: z.ZodType<PageRenderQuery, z.ZodTypeDef, PageRenderQuery>;
+/** Query/token schema for the annotated render family (`page-render-annotated`). */
+declare const PageRenderAnnotatedQuerySchema: z.ZodType<PageRenderQuery, z.ZodTypeDef, PageRenderQuery>;
+/**
+ * Query/token schema for the batch annotation-appearance render endpoint.
+ * Mirrors `PageRenderQuerySchema` but without page target/viewport/background
+ * or `includeAnnotations` (appearances are always annotation-derived), and
+ * keyed by `annotationVersion` only — appearance bitmaps do not depend on
+ * page base content, so `contentVersion` is not part of the cache key. The
+ * endpoint renders the Normal appearance only.
+ */
+declare const AnnotationAppearancesQuerySchema: z.ZodType<AnnotationAppearancesQuery>;
+/**
+ * The JSON manifest part of the appearance `multipart/form-data` response.
+ * Wire-stable; the cloud client validates the parsed `manifest` part against
+ * this before reconstructing image handles from the binary parts.
+ */
+declare const AnnotationAppearanceManifestSchema: z.ZodType<AnnotationAppearanceManifest>;
+/**
+ * Reasons a mutation tells the client its old snapshot is stale. Wire-stable;
+ * extend with care (forward-compat clients accept only known values).
+ */
+declare const RefetchReasonSchema: z.ZodType<RefetchReason>;
+declare const CacheDeltaSchema: z.ZodType<CacheDelta>;
+declare const MutationMetaSchema: z.ZodType<MutationMeta>;
+/**
+ * Per-page side-effect envelope every annotation mutation returns. Mirrors
+ * `AnnotationListMutationMeta`. The `shouldRefetch` field is `null` when the
+ * client's existing index-based references remain valid; non-null only when
+ * the engine knows for sure the snapshot is stale.
+ */
+declare const AnnotationListMutationMetaSchema: z.ZodType<AnnotationListMutationMeta>;
+declare const AnnotationCreateResultSchema: z.ZodType<AnnotationCreateResult>;
+/** The engine's `/AP` verdict riding every update result (see engine-core
+ *  `annotation/appearance.ts`). `changed` drives client raster invalidation. */
+declare const AppearanceOutcomeSchema: z.ZodType<AppearanceOutcome>;
+declare const AnnotationUpdateResultSchema: z.ZodType<AnnotationUpdateResult>;
+/**
+ * `deleted` is nullable: a weak annotation (no /NM, no indirect object
+ * number) has no durable id to report after removal. Cloud server and local
+ * worker both emit `null` in that case so callers don't have to special-case
+ * a sentinel.
+ */
+declare const AnnotationDeleteResultSchema: z.ZodType<AnnotationDeleteResult>;
+/**
+ * Batch annotation move (contiguous-block, symmetric with `pages.move`).
+ * `moved` is in caller order; each `moved[i]` lives at index `toIndex + i`
+ * after the move. ONE structural envelope per batch.
+ */
+declare const AnnotationMoveResultSchema: z.ZodType<AnnotationMoveResult>;
+declare const FormSetValueResultSchema: z.ZodType<FormSetValueResult>;
+declare const FormEffectSchema: z.ZodType<FormEffect>;
+declare const FormEffectsResultSchema: z.ZodType<FormEffectsResult>;
+declare const FormImportResultSchema: z.ZodType<FormImportResult>;
+declare const FormFieldCreateResultSchema: z.ZodType<FormFieldCreateResult>;
+declare const FormFieldUpdateResultSchema: z.ZodType<FormFieldUpdateResult>;
+declare const FormFieldDeleteResultSchema: z.ZodType<FormFieldDeleteResult>;
+declare const FormWidgetLinkResultSchema: z.ZodType<FormWidgetLinkResult>;
+declare const FormRepairResultSchema: z.ZodType<FormRepairResult>;
+declare const PageBoxesSchema: z.ZodType<PageBoxes>;
+/**
+ * Pure geometry for one page (`pages.list()` element). No annotation
+ * liveness — that lives on annotation reads and the manifest.
+ */
+declare const PageLayoutSchema: z.ZodType<PageLayout>;
+declare const PageFlattenResultSchema: z.ZodType<PageFlattenResult>;
+declare const PageFlattenInputSchema: z.ZodType<PageFlattenInput>;
+declare const RedactionApplyScopeSchema: z.ZodType<RedactionApplyScope>;
+declare const RedactionApplyResultSchema: z.ZodType<RedactionApplyResult>;
+/**
+ * Snapshot of every page in display order. Pages are addressed by
+ * `pageObjectNumber` everywhere except the per-element `index`, which is
+ * display order and intentionally not an identity. Carries geometry only.
+ */
+declare const PageListSnapshotSchema: z.ZodType<PageListSnapshot>;
+/**
+ * Page reorder input. Pages are always addressed by `pageObjectNumber`;
+ * `destIndex` is the insertion point in the post-removal index space.
+ */
+declare const PageMoveInputSchema: z.ZodType<PageMoveInput>;
+/**
+ * Coherence pins shared by every page-STRUCTURE result (move/rotate/delete) —
+ * see `PageStructureCache`. Nullable at each use site (local engines).
+ */
+declare const PageStructureCacheSchema: z.ZodType<PageStructureCache>;
+/**
+ * Page reorder result. No revision is bumped (no doc-level revision exists,
+ * and per-page revisions intentionally survive a page reorder). The full
+ * post-move order is returned so callers can swap their snapshot directly.
+ */
+declare const PageMoveResultSchema: z.ZodType<PageMoveResult>;
+/**
+ * Page rotate input. ABSOLUTE rotation (idempotent — see `PageRotateInput`),
+ * one value applied to every listed page.
+ */
+declare const PageRotateInputSchema: z.ZodType<PageRotateInput>;
+/**
+ * Page rotate result. Rotation is presentation metadata over normalized
+ * content: nothing per-page invalidates; the new `layout` carries the
+ * rotation values (see `PageRotateResult`).
+ */
+declare const PageRotateResultSchema: z.ZodType<PageRotateResult>;
+/** Page delete input. Deleting every page is rejected server/worker-side. */
+declare const PageDeleteInputSchema: z.ZodType<PageDeleteInput>;
+/**
+ * Page delete result. Deleted PONs are retired (never recycled); surviving
+ * pages keep identity + revisions (see `PageDeleteResult`).
+ */
+declare const PageDeleteResultSchema: z.ZodType<PageDeleteResult>;
+/**
+ * Metadata write result. The Info dict is rewritten in place, so the
+ * result returns the re-read `metadata` plus cloud coherence pins. No
+ * `layoutVersion` is touched — a metadata edit bumps only `docVersion`
+ * and `metadataVersion`. `cache` is `null` for local engines.
+ */
+declare const AttachmentsCacheSchema: z.ZodType<AttachmentsCache>;
+declare const AttachmentCreateResultSchema: z.ZodType<AttachmentCreateResult>;
+declare const AttachmentDeleteResultSchema: z.ZodType<AttachmentDeleteResult>;
+declare const MetadataUpdateResultSchema: z.ZodType<MetadataUpdateResult>;
+declare const WeakAnnotationSessionResponseSchema: z.ZodObject<{
+  sessionId: z.ZodString;
+  expiresAt: z.ZodNumber;
+  heartbeatIntervalMs: z.ZodNumber;
+  pageObjectNumbers: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+  expiresAt: number;
+  sessionId: string;
+  heartbeatIntervalMs: number;
+  pageObjectNumbers: number[];
+}, {
+  expiresAt: number;
+  sessionId: string;
+  heartbeatIntervalMs: number;
+  pageObjectNumbers: number[];
+}>;
+type WeakAnnotationSessionResponse = z.infer<typeof WeakAnnotationSessionResponseSchema>;
+declare const WeakAnnotationSessionPagesRequestSchema: z.ZodObject<{
+  pageObjectNumbers: z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>;
+}, "strip", z.ZodTypeAny, {
+  pageObjectNumbers: number[];
+}, {
+  pageObjectNumbers: number[];
+}>;
+type WeakAnnotationSessionPagesRequest = z.infer<typeof WeakAnnotationSessionPagesRequestSchema>;
+//#endregion
+//#region src/dto/PdfAction.schema.d.ts
+declare const PdfActionTypeSchema: z.ZodEnum<["unknown", "goto", "goto-remote", "goto-embedded", "launch", "thread", "uri", "sound", "movie", "hide", "named", "submit-form", "reset-form", "import-data", "javascript", "set-ocg-state", "rendition", "transition", "goto-3d-view"]>;
+declare const PdfActionNodeSchema: z.ZodType<PdfActionNode>;
+declare const PdfActionTreeSchema: z.ZodType<PdfActionTree>;
+declare const PdfFieldActionsSchema: z.ZodType<PdfFieldActions>;
+declare const PdfPageActionsSchema: z.ZodType<PdfPageActions>;
+declare const PdfAnnotationActionsSchema: z.ZodType<PdfAnnotationActions>;
+declare const DocumentActionsSnapshotSchema: z.ZodType<DocumentActionsSnapshot>;
+//#endregion
+//#region src/forms/schema.d.ts
+declare const FormFieldRefSchema: z.ZodType<FormFieldRef>;
+declare const FormWidgetRefSchema: z.ZodType<FormWidgetRef>;
+declare const FormFieldFlagsSchema: z.ZodType<FormFieldFlags>;
+declare const ToggleFieldWidgetSchema: z.ZodType<ToggleFieldWidget>;
+declare const FormFieldOptionSchema: z.ZodType<FormFieldOption>;
+declare const FormValueEntrySchema: z.ZodType<FormValueEntry>;
+declare const FormFieldDTOSchema: z.ZodType<FormFieldDTO>;
+declare const FormKindSchema: z.ZodType<FormKind>;
+declare const FormSnapshotSchema: z.ZodType<FormSnapshot>;
+declare const FormFieldValueSchema: z.ZodType<FormFieldValue>;
+declare const FormDataFormatSchema: z.ZodType<FormDataFormat>;
+declare const WidgetPlacementSchema: z.ZodType<WidgetPlacement>;
+declare const FormFieldOptionInputSchema: z.ZodType<FormFieldOptionInput>;
+declare const FormFieldDraftSchema: z.ZodType<FormFieldDraft>;
+declare const FormFieldPatchSchema: z.ZodType<FormFieldPatch>;
+//#endregion
+//#region src/wire/token.d.ts
+type TokenScalar = string | number | boolean;
+type TokenInput = Record<string, TokenScalar | undefined>;
+type TokenQuery = Record<string, string>;
+interface TokenSchema {
+  /**
+   * Allowed field names. Field names are dotted paths of camelCase segments
+   * (e.g. `viewport.kind`, `target.rect.left`). `=` is reserved as the
+   * key/value delimiter and `,` as the pair separator, so neither may appear
+   * in field names. `.` is the path separator that lets dotted keys round-
+   * trip generically through `flatten`/`unflatten`.
+   *
+   * The token form is intentionally isomorphic to a query string: swap `,`
+   * for `&` and you have a query string with identical keys and values.
+   * Both `=` and `,` are RFC 3986 sub-delims, allowed unencoded in path
+   * segments, so the token never needs URL-encoding for its grammar.
+   */
+  fields: readonly string[];
+  maxLength?: number;
+}
+declare function encodeToken(schema: TokenSchema, input: TokenInput): string;
+declare function decodeToken(schema: TokenSchema, raw: string): TokenQuery;
+//#endregion
+//#region src/wire/tokens.d.ts
+interface DownloadToken {
+  docVersion: number;
+  mode: PdfSaveMode;
+}
+declare const encodeDocToken: (docVersion: number) => string;
+declare const decodeDocToken: (raw: string) => number;
+declare const encodeContentToken: (contentVersion: number) => string;
+declare const decodeContentToken: (raw: string) => number;
+declare const encodeLayoutToken: (layoutVersion: number) => string;
+declare const decodeLayoutToken: (raw: string) => number;
+declare const encodeMetadataToken: (metadataVersion: number) => string;
+declare const decodeMetadataToken: (raw: string) => number;
+declare const encodeAnnotationToken: (annotationVersion: number) => string;
+declare const decodeAnnotationToken: (raw: string) => number;
+declare const encodeActionsToken: (actionsVersion: number) => string;
+declare const decodeActionsToken: (raw: string) => number;
+declare const encodeAttachmentsToken: (attachmentsVersion: number) => string;
+declare const decodeAttachmentsToken: (raw: string) => number;
+declare const encodeDownloadToken: (input: DownloadToken) => string;
+declare const decodeDownloadToken: (raw: string) => DownloadToken;
+/**
+ * Encode a render token from a flat wire-shape input. The input is the
+ * output of `flatten(...)` over an SDK `PageImageOptions`-shaped object plus
+ * cache versions. Semantic invariants (viewport-kind XOR fields, per-family
+ * pin grammar — annotatedness itself is PATH-expressed, never a token key —
+ * target rect coherence) live in the per-family render query schemas —
+ * running them here would duplicate the spec.
+ */
+declare const encodeRenderToken: (input: TokenInput) => string;
+/**
+ * Decode a render token to a flat `Record<string, string>` of allowed
+ * fields. Use `unflatten(...)` + `PageImageOptionsWireSchema.parse(...)` to
+ * recover the nested SDK shape with full coercion + validation.
+ */
+declare const decodeRenderToken: (raw: string) => TokenQuery;
+/**
+ * Encode an annotation-appearance render token from a flat wire-shape input
+ * (the `flatten(...)` of an `AnnotationAppearanceImageOptions`-shaped object
+ * plus cache versions). Semantic validation lives in
+ * `AnnotationAppearancesQuerySchema`.
+ */
+declare const encodeAnnotationAppearancesRenderToken: (input: TokenInput) => string;
+/** Decode an annotation-appearance render token to a flat field map. */
+declare const decodeAnnotationAppearancesRenderToken: (raw: string) => TokenQuery;
+/**
+ * The decoded state of a versioned search URL — the WHOLE cache key.
+ * `epoch` is `searchContentEpoch(manifest)`; `skip` is the number of
+ * scan-order pages already consumed (0 = first slice). The server mints
+ * continuation tokens (same epoch, advanced skip); the client decodes
+ * them only to verify a resumed cursor still belongs to its query.
+ */
+interface SearchToken {
+  epoch: string;
+  query: SearchQuery;
+  startPage?: number;
+  skip: number;
+  budget?: SearchSliceBudget;
+}
+declare const encodeSearchToken: (input: SearchToken) => string;
+declare const decodeSearchToken: (raw: string) => SearchToken;
+declare function encodeTokenText(text: string): string;
+declare function decodeTokenText(encoded: string): string;
+//#endregion
+//#region src/wire/paths.d.ts
+declare const DEFAULT_LAYER_NAME = "default";
+declare const wirePaths: {
+  /** POST: grant document access/caching credentials for the current bearer. */
+  readonly access: "/v1/access";
+  /**
+   * GET: open the document referenced by the doc-scoped JWT and
+   * return its `DocumentHead`. The server materialises the base
+   * PDF into its file cache and binds it to a worker the first
+   * time this is hit.
+   */
+  readonly docHead: (docId: string) => string;
+  /**
+   * GET: layer-scoped head. The cloud SDK always uses a layer namespace;
+   * tokens without `layer_name` bind to `DEFAULT_LAYER_NAME`.
+   */
+  readonly layerHead: (docId: string, layerName: string) => string;
+  /**
+   * GET: full document manifest at a specific `docVersion`. Content-
+   * addressed: the URL bytes are immutable for the lifetime of the
+   * version, so CDNs may cache `public, max-age=31536000, immutable`.
+   * A request whose `docVersion` mismatches the current version
+   * returns 404 — the SDK refetches `/head` to learn the new
+   * version, then re-requests the manifest at the new URL.
+   */
+  readonly docManifest: (docId: string, docVersion: number) => string;
+  /**
+   * GET: full layer manifest at a specific layer document version.
+   * Never-mutated layers may fall through to the immutable base view;
+   * once a layer row exists, `layers.doc_version` and `layer_pages`
+   * drive the response.
+   */
+  readonly layerManifest: (docId: string, layerName: string, docVersion: number) => string;
+  /**
+   * GET: page-geometry list for the whole layer at a specific
+   * `layoutVersion`. Content-addressed; CDN may cache forever. The
+   * `layoutVersion` lives in the manifest (doc-level pointer) and bumps
+   * only on structural page ops. Stale-version requests 404 and the SDK's
+   * transparent retry walks `/head` -> `/manifest@docVersion=N` to learn
+   * the new `layoutVersion`.
+   */
+  readonly layerLayout: (docId: string, layerName: string, layoutVersion: number) => string;
+  /**
+   * Immutable BASE page-geometry list (plane-scope model): the shared-URL
+   * variant a layout-inheriting layer resolves at — every visitor's page
+   * list is ONE CDN object served from the base worker session.
+   */
+  readonly docLayout: (docId: string, layoutVersion: number) => string;
+  readonly layerLayoutCurrent: (docId: string, layerName: string) => string;
+  /**
+   * GET: full document metadata for the layer at a specific
+   * `metadataVersion`. Content-addressed; CDN may cache forever. The
+   * `metadataVersion` lives in the manifest (doc-level pointer) and bumps
+   * only on metadata writes. Stale-version requests 404 and the SDK's
+   * transparent retry walks `/head` -> `/manifest@docVersion=N` to learn
+   * the new `metadataVersion`.
+   */
+  readonly layerMetadata: (docId: string, layerName: string, metadataVersion: number) => string;
+  readonly layerMetadataCurrent: (docId: string, layerName: string) => string;
+  /** Immutable BASE metadata (plane-scope model): the shared-URL variant a
+   *  metadata-inheriting layer resolves at. */
+  readonly docMetadata: (docId: string, metadataVersion: number) => string;
+  /** Immutable catalog-owned actions, independently pinned in the manifest. */
+  readonly layerActions: (docId: string, layerName: string, actionsVersion: number) => string;
+  /** Immutable BASE catalog actions (plane-scope model): the shared-URL
+   *  variant an actions-inheriting layer resolves at. */
+  readonly docActions: (docId: string, actionsVersion: number) => string;
+  /** POST: rewrite the document Info dict for the layer (metadata edit). */
+  readonly layerMetadataUpdate: (docId: string, layerName: string) => string;
+  /**
+   * Immutable BASE /EmbeddedFiles listing: the shared-URL variant an
+   * attachments-undiverged layer resolves at — every visitor's sidebar list
+   * is ONE CDN object served from the base worker session.
+   */
+  readonly docAttachments: (docId: string, attachmentsVersion: number) => string;
+  /** Immutable BASE decoded bytes of one embedded file (twin of
+   *  `layerAttachmentFile` — same capability tier split). */
+  readonly docAttachmentFile: (docId: string, key: string, attachmentsVersion: number) => string;
+  /** Immutable /EmbeddedFiles listing, pinned by `attachmentsVersion`. */
+  readonly layerAttachments: (docId: string, layerName: string, attachmentsVersion: number) => string;
+  /** POST: create a document-level embedded file (multipart mutation envelope). */
+  readonly layerAttachmentsCollection: (docId: string, layerName: string) => string;
+  /** DELETE: remove a document-level embedded file by name-tree key. */
+  readonly layerAttachmentItem: (docId: string, layerName: string, key: string) => string;
+  /**
+   * Immutable decoded bytes of one document-level embedded file. Lives
+   * under its own `attachment-files` prefix — a stronger capability tier
+   * than the metadata listing, so a CDN credential for one can never
+   * authorize the other (the search-rects/search-full rule).
+   */
+  readonly layerAttachmentFile: (docId: string, layerName: string, key: string, attachmentsVersion: number) => string;
+  /** Immutable decoded bytes of a FileAttachment annotation's embedded file. */
+  readonly layerAnnotationFile: (docId: string, layerName: string, pageObjectNumber: number, annotKey: string, attachmentsVersion: number) => string;
+  /**
+   * Immutable BASE bytes of a FileAttachment annotation's embedded file
+   * (plane-scope model). Depends on the `annotations` plane (the annotation
+   * exists in this view) AND the `attachments` plane (the pin); the origin
+   * guard requires both inherited.
+   */
+  readonly docAnnotationFile: (docId: string, pageObjectNumber: number, annotKey: string, attachmentsVersion: number) => string;
+  /**
+   * GET: full plain-text extraction for a single page at a specific
+   * `contentVersion`. Content-addressed; CDN may cache forever.
+   * Stale-version requests return 404 and the SDK's transparent
+   * retry walks `/head` → `/manifest@docVersion=N` to learn the new
+   * `contentVersion`.
+   */
+  readonly docPageText: (docId: string, pageObjectNumber: number, contentVersion: number) => string;
+  readonly layerPageText: (docId: string, layerName: string, pageObjectNumber: number, contentVersion: number) => string;
+  readonly layerPageTextCurrent: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  readonly docPageGeometry: (docId: string, pageObjectNumber: number, contentVersion: number) => string;
+  readonly docPageGeometryCurrent: (docId: string, pageObjectNumber: number) => string;
+  readonly docPageRender: (docId: string, pageObjectNumber: number, token: TokenInput) => string;
+  readonly docPageRenderCurrent: (docId: string, pageObjectNumber: number) => string;
+  /**
+   * Immutable BASE annotated render (plane-scope model). Its OWN path family,
+   * not a token flag under `/render/pages/`: an annotated render depends on
+   * `content + annotations`, an annotation-free one on `content` alone, and
+   * edge grants are prefix-scoped — the prefix law says a path's prefix must
+   * identify its full plane-dependency set. Annotatedness is therefore
+   * PATH-ONLY (the token/path law): the wire token has no
+   * `includeAnnotations` key at all; the annotated family's token carries
+   * `annotationVersion`, the free family's cannot.
+   */
+  readonly docPageRenderAnnotated: (docId: string, pageObjectNumber: number, token: TokenInput) => string;
+  readonly layerPageGeometry: (docId: string, layerName: string, pageObjectNumber: number, contentVersion: number) => string;
+  readonly layerPageGeometryCurrent: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  readonly layerPageRender: (docId: string, layerName: string, pageObjectNumber: number, token: TokenInput) => string;
+  readonly layerPageRenderCurrent: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  /** Layer twin of `docPageRenderAnnotated` — the grammar is uniform:
+   *  annotatedness is path-only at BOTH tiers. */
+  readonly layerPageRenderAnnotated: (docId: string, layerName: string, pageObjectNumber: number, token: TokenInput) => string;
+  readonly layerPageRenderAnnotatedCurrent: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  /**
+   * Immutable BASE annotation list for a single page (plane-scope model):
+   * the shared-URL variant an annotations-inheriting layer resolves at — a
+   * base's own annotations (weak-identity ones included) are simply visible
+   * through every pristine layer, so 1,000 visitors' sidebars are ONE CDN
+   * object served from the base worker session.
+   */
+  readonly docPageAnnotations: (docId: string, pageObjectNumber: number, annotationVersion: number) => string;
+  /** Immutable BASE appearance batch (twin of
+   *  `layerPageAnnotationAppearances` — same `annotations` plane gate). */
+  readonly docPageAnnotationAppearances: (docId: string, pageObjectNumber: number, token: TokenInput) => string;
+  /**
+   * GET: full annotation list for a single page at a specific
+   * `annotationVersion`. Same cache-control rules and 404-retry
+   * semantics as `docPageText`. The `items` suffix is the
+   * collection name — see file-level docstring.
+   */
+  readonly layerPageAnnotations: (docId: string, layerName: string, pageObjectNumber: number, annotationVersion: number) => string;
+  readonly layerPageAnnotationsCurrent: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  /**
+   * GET: batch-rendered annotation appearance bitmaps for a single page as a
+   * `multipart/form-data` body. Sibling collection of `items` under the same
+   * `annotations/pages/{N}/` resource, so it shares the `annotations-read`
+   * gate (`doc.annotate.read`) and CDN coverage — reading an annotation lets
+   * you see its rendered appearance, the same boundary Adobe uses.
+   *
+   * Content-addressed via the appearance render token (`annotationVersion`
+   * plus render options like scale/format); CDN may cache forever. Appearance
+   * pixels depend only on the annotation `/AP` stream, so `contentVersion` is
+   * deliberately NOT part of the key.
+   */
+  readonly layerPageAnnotationAppearances: (docId: string, layerName: string, pageObjectNumber: number, token: TokenInput) => string;
+  readonly layerPageAnnotationAppearancesCurrent: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  readonly layerPageAnnotationsCreate: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  readonly layerAnnotationByKey: (docId: string, layerName: string, pageObjectNumber: number, key: string) => string;
+  readonly layerPageAnnotationsMove: (docId: string, layerName: string, pageObjectNumber: number) => string;
+  /**
+   * GET: the reconciled form snapshot (field tree + widget joins) for the
+   * layer's CURRENT state. Forms are document-scoped (one AcroForm per
+   * document), so there is no per-page collection and — unlike annotations —
+   * no content-addressed `@version` variant: the snapshot is always served
+   * `no-store`. Mutation results carry the per-page `cacheDelta` that keeps
+   * annotation/render caches coherent when widget appearances change.
+   */
+  readonly layerForm: (docId: string, layerName: string) => string;
+  /** POST: create a field (optionally with styled widget placements). */
+  readonly layerFormFields: (docId: string, layerName: string) => string;
+  /**
+   * Field member: GET (single field) / PATCH (updateField) / DELETE
+   * (deleteField + widget cascade). `fieldKey` is an encoded `FormFieldRef`
+   * (`encodeFieldRefKey`): `obj:12` or `fqn:billing.name`.
+   */
+  readonly layerFormFieldByKey: (docId: string, layerName: string, fieldKey: string) => string;
+  /** POST: replace the field's value (`{ value: FormFieldValue }`). */
+  readonly layerFormFieldValue: (docId: string, layerName: string, fieldKey: string) => string;
+  /** POST: reset the field to /DV (or clear). Empty body. */
+  readonly layerFormFieldReset: (docId: string, layerName: string, fieldKey: string) => string;
+  /** POST: adopt an inert widget annotation (`{ widget, onState? }`). */
+  readonly layerFormFieldWidgets: (docId: string, layerName: string, fieldKey: string) => string;
+  /**
+   * POST: release a widget back to the inert annotation plane
+   * (`{ widget }`). An action POST rather than a member DELETE because a
+   * widget ref is a (page, annotation) pair — carrying it in the body keeps
+   * one codec instead of inventing a second composite key syntax.
+   */
+  readonly layerFormFieldWidgetsDetach: (docId: string, layerName: string, fieldKey: string) => string;
+  /**
+   * GET: serialized form data (`?format=fdf|xfdf`, default `xfdf`).
+   * POST: import an FDF/XFDF payload (raw bytes body; format sniffed
+   * server-side unless `?format=` pins it).
+   */
+  readonly layerFormData: (docId: string, layerName: string, format?: "fdf" | "xfdf") => string;
+  /** POST: durable reconciliation (`{ bakeAppearances? }`). */
+  readonly layerFormRepair: (docId: string, layerName: string) => string;
+  readonly layerFormEffects: (docId: string, layerName: string) => string;
+  /**
+   * GET: one budgeted search slice, versioned form. The token
+   * (`encodeSearchToken`) IS the cache key: content epoch + query +
+   * position. Immutable; CDN may cache forever. Mode is the path — rects
+   * and full are separate resources so permission tiers never share
+   * cache entries (`'rects'` needs `doc.text.search`; `'full'` also
+   * needs `doc.text.copy`).
+   */
+  readonly layerSearchRects: (docId: string, layerName: string, token: string) => string;
+  readonly layerSearchFull: (docId: string, layerName: string, token: string) => string;
+  /**
+   * GET: unversioned form — same fields as flat query params (`q` as
+   * plain text), served from the CURRENT content, always `no-store`.
+   * The debug/simple-client variant; the SDK uses the versioned form.
+   */
+  readonly layerSearchRectsCurrent: (docId: string, layerName: string) => string;
+  readonly layerSearchFullCurrent: (docId: string, layerName: string) => string;
+  readonly layerPagesMove: (docId: string, layerName: string) => string;
+  readonly layerPagesRotate: (docId: string, layerName: string) => string;
+  readonly layerPagesDelete: (docId: string, layerName: string) => string;
+  readonly layerPagesFlatten: (docId: string, layerName: string) => string;
+  readonly layerRedactionsApply: (docId: string, layerName: string) => string;
+  readonly layerEvents: (docId: string, layerName: string) => string;
+  readonly layerDownload: (docId: string, layerName: string) => string;
+  readonly layerDownloadVersioned: (docId: string, layerName: string, token: DownloadToken) => string;
+  /**
+   * Weak-annotation-sessions: pluralized in v2 so the collection
+   * lives at `/weak-annotation-sessions` and members at
+   * `/weak-annotation-sessions/{sessionId}` — REST-conventional.
+   */
+  readonly layerWeakAnnotationSession: (docId: string, layerName: string) => string;
+  readonly layerWeakAnnotationSessionHeartbeat: (docId: string, layerName: string, sessionId: string) => string;
+  readonly layerWeakAnnotationSessionPages: (docId: string, layerName: string, sessionId: string) => string;
+  readonly layerWeakAnnotationSessionRelease: (docId: string, layerName: string, sessionId: string) => string;
+  /**
+   * POST: pre-warm the doc cache + worker open before any user
+   * request lands. Body is `{ docId }`. Doc-scoped token required.
+   */
+  readonly docWarm: "/v1/warm";
+};
+//#endregion
+//#region src/wire/resources.d.ts
+/**
+ * Canonical id for every read resource the server exposes.
+ *
+ * Adding a new resource:
+ *   1. Add the id to this union
+ *   2. Add a `DOC_RESOURCES` entry
+ *   3. Update the route handler to call `requireResource(req, docId, '<id>', pdfBits)`
+ *   4. CDN signer automatically considers it
+ */
+type DocResourceId = 'head' | 'manifest' | 'page-render' | 'page-render-annotated' | 'page-text' | 'page-geometry' | 'page-annotations' | 'layout' | 'metadata' | 'actions' | 'attachments' | 'attachment-files' | 'layer-manifest' | 'layer-layout' | 'layer-metadata' | 'layer-actions' | 'layer-page-render' | 'layer-page-render-annotated' | 'layer-page-text' | 'layer-page-geometry' | 'layer-search-rects' | 'layer-search-full' | 'annotations-read' | 'layer-attachments' | 'layer-attachment-files' | 'download-current' | 'download-versioned';
+/**
+ * 'origin' — unversioned URL, response can change over time. CDN must
+ * not cache (the bytes are not immutable). Routed straight to origin
+ * with the JWT bearer.
+ *
+ * 'versioned-read' — URL is content-addressed via `@<token>`. Response
+ * is immutable for the lifetime of the version. Safe to cache forever
+ * at the CDN edge.
+ */
+type RouteKind = 'origin' | 'versioned-read';
+/**
+ * Capability requirement attached to a resource. Three shapes:
+ *   - `single` — one capability gates the resource
+ *   - `any`    — any one of N capabilities gates the resource
+ *               (used by /text and /geometry which accept either the
+ *                copy/select scope OR the future search scope)
+ *   - `all`    — every one of N capabilities is required
+ *               (used by /search/full: a snippet IS extracted text, so
+ *                the search scope alone is not enough — the copy denial
+ *                must hold here too)
+ */
+type CapabilityRequirement = {
+  kind: 'single';
+  capability: DocCapability;
+} | {
+  kind: 'any';
+  capabilities: ReadonlyArray<DocCapability>;
+} | {
+  kind: 'all';
+  capabilities: ReadonlyArray<DocCapability>;
+};
+interface DocResourceDescriptor {
+  /** Stable id used by route guards and the CDN signer. */
+  id: DocResourceId;
+  /**
+   * Display pattern with `{docId}` / `{layerName}` placeholders for
+   * docs + telemetry. Use {@link DocResourceDescriptor.resolvePathPattern}
+   * to get a concrete pattern with values filled in.
+   */
+  pathPattern: string;
+  /**
+   * Concrete CDN path pattern with `*` wildcards. Used by adapters
+   * that do explicit pattern matching at the edge (CloudFront via
+   * Resource globs). For path prefixes with no layer component,
+   * `layerName` is ignored.
+   */
+  resolvePathPattern(docId: string, layerName?: string): string;
+  /**
+   * Display prefix with `{docId}` / `{layerName}` placeholders. The
+   * literal path-prefix the CDN signs for this resource — by design,
+   * each resource type has its OWN distinct prefix, so a token
+   * signed at this prefix authorizes only this resource type at the
+   * edge (works on prefix-matching CDNs like Bunny / Cloud CDN /
+   * Azure FD with no extra cleverness).
+   */
+  pathPrefix: string;
+  /**
+   * Concrete path prefix the CDN signer uses. The literal string
+   * `pathPattern` would have *before* the first `*` wildcard — but
+   * stored explicitly here rather than derived so future pattern
+   * syntax changes can't accidentally break CDN security.
+   *
+   * For resources with no layer component, `layerName` is ignored.
+   */
+  resolvePathPrefix(docId: string, layerName?: string): string;
+  /** What capability (or set) is needed to access this resource. */
+  requirement: CapabilityRequirement;
+  /** Versioned-immutable vs. unversioned-mutable. */
+  routeKind: RouteKind;
+  /**
+   * Can the CDN sign coverage for this resource? Mutable/unversioned
+   * resources (head, current download) are always false even though
+   * they're routed via origin.
+   */
+  cdnCacheable: boolean;
+}
+/**
+ * URL layout (paths v2): each resource type lives at a distinct path
+ * prefix so prefix-matching CDNs (Bunny, Cloud CDN, Azure FD) can
+ * enforce per-resource scope at the edge. See wire/paths.ts for the
+ * full shape and rationale.
+ */
+declare const DOC_RESOURCES: Readonly<Record<DocResourceId, DocResourceDescriptor>>;
+/**
+ * True iff the scope grants access to the named resource.
+ *
+ * Looks up the resource descriptor, then dispatches to
+ * `checkCapability` or `checkAnyCapability` based on the requirement
+ * shape. Used by both server route guards and the CDN signer.
+ */
+declare function checkResourceAccess(resourceId: DocResourceId, rawScope: ReadonlyArray<string>, pdfBits: PdfBits): boolean;
+//#endregion
+//#region src/wire/cdn/coverage.d.ts
+/**
+ * One CDN-coverage entry: the resource id plus both projections of its
+ * URL — the wildcard `pathPattern` (for pattern-matching CDN signers
+ * like CloudFront) and the literal `pathPrefix` (for prefix-matching
+ * CDN signers like Bunny / Cloud CDN / Azure FD / custom HMAC).
+ *
+ * Each entry corresponds to one cacheable resource the caller's
+ * scope grants access to. Both projections are pre-resolved with the
+ * concrete `docId` / `layerName` filled in.
+ */
+interface CdnCoverageEntry {
+  readonly resourceId: DocResourceId;
+  /** Resolved CDN path pattern with `*` wildcards (for glob signers). */
+  readonly pathPattern: string;
+  /** Resolved literal path prefix (for prefix-match signers). */
+  readonly pathPrefix: string;
+}
+declare function cdnCoverageForScope(rawScope: ReadonlyArray<string>, pdfBits: PdfBits, context: {
+  docId: string;
+  layerName?: string;
+  /**
+   * Plane scopes of the caller's pinned layer. A doc-level shared
+   * resource's prefix is covered iff every plane it depends on is
+   * inherited (`'base'`). Omitted = no layer in play (tenant tokens) —
+   * everything the capability scope allows is granted.
+   */
+  scopes?: LayerScopes;
+}): ReadonlyArray<CdnCoverageEntry>;
+//#endregion
+//#region src/wire/cdn/applyCdnAccess.d.ts
+/**
+ * Subset of `CdnAccessInfo` this function needs. The full type lives
+ * in `engine/DocumentSecurityService.ts` (it's part of the access
+ * response); we mirror just the fields we read so this module is
+ * decoupled from the security service surface.
+ */
+interface CdnAccessInfoForApply {
+  readonly adapter: string;
+  readonly baseUrlOverrides: Partial<Record<string, string>> | null;
+  readonly authHeader: {
+    readonly name: string;
+    readonly value: string;
+  } | null;
+  readonly signedQueryParams: Record<string, string> | null;
+  readonly signedCookies: ReadonlyArray<{
+    readonly name: string;
+    readonly value: string;
+    readonly domain?: string;
+    readonly path?: string;
+    readonly expires?: number;
+  }> | null;
+  readonly signedPathPolicies: ReadonlyArray<{
+    readonly pathPrefix: string;
+    readonly queryParams: Record<string, string>;
+  }> | null;
+}
+interface ApplyCdnAccessInput {
+  /** Path portion of the request (must begin with `/`). */
+  readonly path: string;
+  /** API server origin the SDK would normally hit, e.g. `https://api.example.com`. */
+  readonly originUrl: string;
+  /** Doc id used to resolve resource path prefixes. */
+  readonly docId: string;
+  /** Layer name for layer-scoped resources (defaults to `'default'`). */
+  readonly layerName?: string;
+  /** Access block from /v1/access. When null, every call goes to origin. */
+  readonly cdn: CdnAccessInfoForApply | null;
+}
+interface ApplyCdnAccessResult {
+  /** Final URL the SDK should fetch. */
+  readonly url: string;
+  /** Resource the path was identified as, or null if it's not a DOC_RESOURCES route. */
+  readonly resourceId: DocResourceId | null;
+  /** True iff the request was routed to the CDN; false means origin fallthrough. */
+  readonly routedToCdn: boolean;
+  /** The signedPathPolicies entry that matched, if any. */
+  readonly matchedPolicy: {
+    readonly pathPrefix: string;
+    readonly queryParams: Record<string, string>;
+  } | null;
+  /** Single global header to attach (custom-hmac header mode only). */
+  readonly authHeader: {
+    readonly name: string;
+    readonly value: string;
+  } | null;
+  /** Cookies the SDK should set on the CDN origin before this request. */
+  readonly cookies: CdnAccessInfoForApply['signedCookies'];
+  /**
+   * Human-readable explanation when `routedToCdn` is false. Empty
+   * string when the request did route to CDN.
+   */
+  readonly fallbackReason: string;
+}
+declare function applyCdnAccess(input: ApplyCdnAccessInput): ApplyCdnAccessResult;
+/**
+ * Walk DOC_RESOURCES and pick the entry whose resolved `pathPrefix`
+ * is a (longest) prefix of `path`. Returns null when no resource
+ * matches — admin routes, /access, /warm fall into this bucket.
+ *
+ * Each cacheable resource has a DISTINCT prefix (paths v2 invariant),
+ * so longest-match is deterministic.
+ */
+declare function resolveResourceIdForPath(path: string, docId: string, layerName: string): DocResourceId | null;
+//#endregion
+//#region src/wire/tokenSchemas.d.ts
+declare const DocTokenSchema: {
+  readonly fields: readonly ["docVersion"];
+};
+declare const ContentTokenSchema: {
+  readonly fields: readonly ["contentVersion"];
+};
+declare const LayoutTokenSchema: {
+  readonly fields: readonly ["layoutVersion"];
+};
+declare const MetadataTokenSchema: {
+  readonly fields: readonly ["metadataVersion"];
+};
+declare const AnnotationTokenSchema: {
+  readonly fields: readonly ["annotationVersion"];
+};
+declare const ActionsTokenSchema: {
+  readonly fields: readonly ["actionsVersion"];
+};
+/**
+ * Allowed flat keys for the render token, expressed as dotted paths that
+ * mirror the SDK `PageImageOptions` shape 1:1. The token codec is fully
+ * generic over this list — adding a new render option means adding its
+ * dotted path here and a matching branch in `PageImageOptionsWireSchema`.
+ * No encoder/decoder code changes.
+ *
+ * `includeAnnotations` is deliberately NOT a token field: annotatedness
+ * changes the artifact's plane-dependency
+ * set, so it is expressed by the path FAMILY (`…/render/pages/` vs
+ * `…/render/annotated/pages/`), never inside the token. `annotationVersion`
+ * belongs to the annotated family's tokens only — each family's query
+ * schema enforces its own pin grammar.
+ */
+declare const RenderTokenSchema: {
+  readonly fields: readonly ["annotationVersion", "background", "contentVersion", "format", "quality", "rotation", "target.kind", "target.rect.bottom", "target.rect.left", "target.rect.right", "target.rect.top", "viewport.kind", "viewport.scale", "viewport.width"];
+  readonly maxLength: 512;
+};
+/**
+ * Token for the versioned search endpoints (`/search/{rects,full}/data@…`).
+ * One token carries the whole cache key: the content epoch, the query
+ * (text/pattern rides base64-variant-encoded in `q` — the token value
+ * charset excludes free text), and the resume position. Canonical by
+ * construction: the codec sorts fields and the encoder omits every
+ * default, so equal searches produce byte-equal tokens — the property CDN
+ * cache hits live on. Mode is NOT a field; it is the endpoint (separate
+ * permission tiers must never share cache entries).
+ */
+declare const SearchTokenSchema: {
+  readonly fields: readonly ["epoch", "matchCase", "matchDiacritics", "maxMatches", "maxPages", "q", "regex", "skip", "startPage", "wholeWord"];
+  readonly maxLength: 2048;
+};
+/**
+ * Token for the batch annotation-appearance render endpoint. Narrower than
+ * the page render token: appearance bitmaps are sized per annotation `/Rect`
+ * so there is no target/viewport — only a uniform `scale` and page
+ * `rotation`. Keyed by `annotationVersion` only (appearances do not depend on
+ * page base content). The cloud endpoint renders the Normal appearance only,
+ * so `modes` is intentionally absent here (it is a worker/local-only option).
+ */
+declare const AnnotationAppearancesRenderTokenSchema: {
+  readonly fields: readonly ["annotationVersion", "format", "quality", "rotation", "scale"];
+  readonly maxLength: 256;
+};
+//#endregion
+//#region src/wire/flatten.d.ts
+/**
+ * Generic recursive flattener for nested option objects into dotted-key flat
+ * maps, and its inverse. The wire format (token + query) is a flat key/value
+ * shape, but SDK option types (e.g. `PageImageOptions`) are nested with
+ * discriminated unions. Keeping these conversions generic means new options
+ * never require bespoke encoder/decoder code — they're just shape changes to
+ * the schema.
+ *
+ * Rules:
+ *   - Nested object keys are joined with `.` (e.g. `viewport.kind`,
+ *     `target.rect.left`).
+ *   - `undefined` and `null` are dropped.
+ *   - Arrays are not supported (the wire format has no list grammar yet).
+ *   - Scalar leaves must be `string | number | boolean`.
+ *   - Round-trip: `unflatten(flatten(x))` equals `x` modulo dropped
+ *     `undefined`/`null` and array leaves.
+ *
+ * The path separator `.` is reserved in field names by the token codec, which
+ * lets us distinguish wire-level structure from value content (values may
+ * still contain `.` for decimals — values are not split on `.`).
+ */
+type WireScalar = string | number | boolean;
+type WireFlat = Record<string, WireScalar>;
+declare function flatten(value: unknown, prefix?: string): WireFlat;
+/**
+ * Inverse of `flatten`. Takes a flat string-or-scalar map and reconstructs a
+ * nested object using `.` as the path separator. Values are passed through
+ * unchanged — downstream schema validation (e.g. Zod with `.coerce`) is
+ * responsible for type coercion from `string` to numbers/booleans when the
+ * input came from a token or query string.
+ *
+ * Throws on conflicting paths (e.g. having both `viewport` and
+ * `viewport.kind` in the same input).
+ */
+declare function unflatten(flat: Record<string, unknown>): Record<string, unknown>;
+//#endregion
+//#region src/wire/renderOptionsCodec.d.ts
+interface RenderVersions {
+  contentVersion: number;
+  annotationVersion?: number;
+}
+/**
+ * Project image render options plus cache versions into the flat wire shape
+ * the render token encoder consumes. The output is a generic dotted-key map
+ * (`viewport.kind`, `target.rect.left`, …) — the schema and codec never need
+ * to know about specific option fields. Adding a new render option means
+ * extending `PageImageOptions`, the render query schemas, and
+ * `RenderTokenSchema.fields`; this function does not change.
+ *
+ * Token/path rule: tokens carry VERSION PINS and RENDER
+ * PARAMETERS; anything that changes the artifact's plane-dependency set is
+ * PATH-expressed. Annotatedness changes the planes (`content` vs
+ * `content + annotations`), so the wire map never carries
+ * `includeAnnotations` — the caller picks the path FAMILY
+ * (`…/render/pages/` vs `…/render/annotated/pages/`) and passes
+ * `annotationVersion` iff it chose the annotated one. Contradictory states
+ * are unrepresentable; each family's query schema enforces its own pin
+ * grammar structurally.
+ *
+ * Semantic validation (viewport-kind invariants, per-family pin presence,
+ * rect coherence) lives in `PageRenderQuerySchema` /
+ * `PageRenderAnnotatedQuerySchema` and runs when the resulting URL is
+ * decoded server-side. Round-tripping (flatten → encode → decode →
+ * unflatten → schema parse) recovers the original SDK options.
+ */
+declare function renderImageOptionsToWire(options: PageImageOptions, versions: RenderVersions): WireFlat;
+/**
+ * Convenience: build the full encoded render token in one call. Equivalent
+ * to `encodeRenderToken(renderImageOptionsToWire(options, versions))`.
+ */
+declare function renderImageOptionsToToken(options: PageImageOptions, versions: RenderVersions): string;
+/**
+ * Re-attach `includeAnnotations` onto the worker-side `PageRenderOptions`
+ * shape. Pure shape transform; consumed by the server route after
+ * `PageRenderQuerySchema` has produced the SDK-shaped options.
+ */
+declare function pageRenderOptionsFromImageOptions(options: PageImageOptions, includeAnnotations: boolean): PageRenderOptions;
+/**
+ * Cache version for the appearance render token. Appearances depend only on
+ * the annotation `/AP` stream, so `annotationVersion` is the sole key —
+ * deliberately NOT `contentVersion`.
+ */
+interface AnnotationRenderVersion {
+  annotationVersion: number;
+}
+/**
+ * Project annotation-appearance image options plus the annotation version
+ * into the flat wire shape the appearance render token encoder consumes.
+ * Mirrors {@link renderImageOptionsToWire}.
+ */
+declare function annotationAppearancesImageOptionsToWire(options: AnnotationAppearanceImageOptions, versions: AnnotationRenderVersion): WireFlat;
+/** Convenience: build the full encoded appearance render token in one call. */
+declare function annotationAppearancesImageOptionsToToken(options: AnnotationAppearanceImageOptions, versions: AnnotationRenderVersion): string;
+/**
+ * Strip image-encoding fields, leaving the worker-side
+ * `AnnotationAppearanceRenderOptions`. Pure shape transform consumed by the
+ * server route after `AnnotationAppearancesQuerySchema` produces the
+ * SDK-shaped options.
+ */
+declare function annotationRenderOptionsFromImageOptions(options: AnnotationAppearanceImageOptions): AnnotationAppearanceRenderOptions;
+//#endregion
+//#region src/annotation/base.schema.d.ts
+/** @deprecated Use `PdfPointSchema` from `../geometry/schemas`. */
+declare const PointSchema: z.ZodType<PdfPoint, z.ZodTypeDef, PdfPoint>;
+/** @deprecated Use `PdfRectSchema` from `../geometry/schemas`. */
+declare const RectSchema: z.ZodType<PdfRect, z.ZodTypeDef, PdfRect>;
+declare const ColorSchema: z.ZodType<Color>;
+declare const AnnotationBorderStyleSchema: z.ZodType<AnnotationBorderStyle>;
+declare const PdfRectDifferencesSchema: z.ZodType<PdfRectDifferences>;
+declare const LineEndingSchema: z.ZodType<LineEnding>;
+declare const LineEndingsSchema: z.ZodType<LineEndings>;
+declare const StandardFontSchema: z.ZodType<StandardFont>;
+declare const TextAlignmentSchema: z.ZodType<TextAlignment>;
+declare const FreeTextIntentSchema: z.ZodType<FreeTextIntent>;
+declare const CaretIntentSchema: z.ZodType<CaretIntent>;
+declare const StrikeoutIntentSchema: z.ZodType<StrikeoutIntent>;
+declare const InkIntentSchema: z.ZodType<InkIntent>;
+declare const BlendModeSchema: z.ZodType<BlendMode>;
+declare const AnnotationFlagsSchema: z.ZodType<AnnotationFlags>;
+/**
+ * Partial flag set authorable on a Draft or Patch — every key optional so
+ * callers set only the bits they care about. The engine merges these onto
+ * the annotation's current `/F` bitset.
+ */
+declare const AnnotationFlagsPartialSchema: z.ZodType<Partial<AnnotationFlags>>;
+declare const AnnotationStableIdSchema: z.ZodType<AnnotationStableId>;
+declare const RevisionTokenSchema: z.ZodType<RevisionToken>;
+declare const AnnotationRefSchema: z.ZodType<AnnotationRef>;
+/**
+ * Shared object literal for every per-subtype DTO schema. Each kind's
+ * `dto.schema.ts` extends this with its own `subtype` literal and
+ * subtype-specific fields. Note that we do NOT include `subtype` here —
+ * each kind sets its own literal so `z.discriminatedUnion('subtype', ...)`
+ * works at the catalog level.
+ */
+declare const AnnotationBaseShape: {
+  readonly ref: z.ZodType<AnnotationRef, z.ZodTypeDef, AnnotationRef>;
+  readonly pageObjectNumber: z.ZodNumber;
+  readonly index: z.ZodNumber;
+  readonly identityQuality: z.ZodEnum<["durable", "weak"]>;
+  readonly nm: z.ZodNullable<z.ZodString>;
+  readonly flags: z.ZodType<AnnotationFlags, z.ZodTypeDef, AnnotationFlags>;
+  readonly rect: z.ZodType<PdfRect, z.ZodTypeDef, PdfRect>;
+  readonly contents: z.ZodNullable<z.ZodString>;
+  readonly author: z.ZodNullable<z.ZodString>;
+  readonly created: z.ZodNullable<z.ZodString>;
+  readonly modified: z.ZodNullable<z.ZodString>;
+  readonly blendMode: z.ZodType<BlendMode, z.ZodTypeDef, BlendMode>;
+  readonly inReplyTo: z.ZodNullable<z.ZodType<AnnotationRef, z.ZodTypeDef, AnnotationRef>>;
+  readonly replyType: z.ZodNullable<z.ZodEnum<["reply", "group"]>>;
+  readonly userId: z.ZodOptional<z.ZodString>;
+  readonly groupId: z.ZodOptional<z.ZodString>;
+  readonly createdBy: z.ZodOptional<z.ZodString>;
+  readonly updatedBy: z.ZodOptional<z.ZodString>;
+  readonly actions: z.ZodOptional<z.ZodType<PdfAnnotationActions, z.ZodTypeDef, PdfAnnotationActions>>;
+};
+/**
+ * Annotation-wide fields shared by every Draft. Per-kind draft schemas
+ * spread this alongside their family-specific shape.
+ *
+ * Authorial identity (/T, /EMBD_Metadata UserID/GroupID) is set by the
+ * server from the caller's JWT identity — see the AnnotationDraftBase
+ * docstring.
+ */
+declare const AnnotationDraftBaseShape: {
+  readonly contents: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  readonly blendMode: z.ZodOptional<z.ZodType<BlendMode, z.ZodTypeDef, BlendMode>>;
+  readonly nm: z.ZodOptional<z.ZodString>;
+  readonly flags: z.ZodOptional<z.ZodType<Partial<AnnotationFlags>, z.ZodTypeDef, Partial<AnnotationFlags>>>;
+  readonly inReplyTo: z.ZodOptional<z.ZodType<AnnotationRef, z.ZodTypeDef, AnnotationRef>>;
+  readonly replyType: z.ZodOptional<z.ZodEnum<["reply", "group"]>>;
+};
+/**
+ * Annotation-wide fields shared by every Patch. `nm` is monotonic per
+ * annotation; clients target an existing annotation via AnnotationRef
+ * instead of renaming.
+ *
+ * `groupId` is the only identity-shaped field on a patch — it
+ * represents organizational ownership, and reassignment runs through
+ * `checkSetGroup`. See AnnotationPatchBase for the full immutability
+ * rules.
+ */
+declare const AnnotationPatchBaseShape: {
+  readonly contents: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  readonly blendMode: z.ZodOptional<z.ZodType<BlendMode, z.ZodTypeDef, BlendMode>>;
+  readonly groupId: z.ZodOptional<z.ZodString>;
+  readonly flags: z.ZodOptional<z.ZodType<Partial<AnnotationFlags>, z.ZodTypeDef, Partial<AnnotationFlags>>>;
+  readonly inReplyTo: z.ZodOptional<z.ZodNullable<z.ZodType<AnnotationRef, z.ZodTypeDef, AnnotationRef>>>;
+  readonly replyType: z.ZodOptional<z.ZodEnum<["reply", "group"]>>;
+};
+//#endregion
+//#region src/dto/Attachment.schema.d.ts
+/**
+ * Wire schemas for the attachment read vocabulary (see `Attachment.ts`).
+ * The write-side `AttachmentFileSource` carries inline bytes and never
+ * appears on the wire — its post-normalization form is the kind-owned
+ * `WireAttachmentFile` (see `annotation/kinds/file-attachment/schema.ts`).
+ */
+declare const AttachmentFileInfoSchema: z.ZodType<AttachmentFileInfo>;
+declare const EmbeddedFileRefSchema: z.ZodType<EmbeddedFileRef>;
+declare const EmbeddedFileItemSchema: z.ZodType<EmbeddedFileItem>;
+//#endregion
+export { ANNOTATION_KINDS, type AccessRequest, AccessRequestSchema, type AccessResponse, AccessResponseSchema, ActionsTokenSchema, AnnotationAppearanceManifestSchema, AnnotationAppearancesQuerySchema, AnnotationAppearancesRenderTokenSchema, AnnotationBaseShape, AnnotationBorderStyleSchema, AnnotationCreateResultSchema, AnnotationDTOSchema, AnnotationDeleteResultSchema, AnnotationDraftBaseShape, AnnotationDraftSchema, AnnotationFlagsPartialSchema, AnnotationFlagsSchema, AnnotationListMutationMetaSchema, AnnotationListPageSnapshotSchema, AnnotationListSnapshotAllPagesSchema, AnnotationMoveResultSchema, AnnotationPatchBaseShape, AnnotationPatchSchema, AnnotationRefSchema, type AnnotationRenderVersion, AnnotationStableIdSchema, AnnotationTokenSchema, AnnotationUpdateResultSchema, AppearanceOutcomeSchema, type ApplyCdnAccessInput, type ApplyCdnAccessResult, AttachmentCreateResultSchema, AttachmentDeleteResultSchema, AttachmentFileInfoSchema, AttachmentsCacheSchema, BlendModeSchema, type CacheDelta, CacheDeltaSchema, CachePinsSchema, CalloutLineSchema, type CapabilityRequirement, CaretDTOSchema, CaretDraftSchema, CaretIntentSchema, CaretPatchSchema, type CdnAccessInfoForApply, type CdnCoverageEntry, CircleDTOSchema, CircleDraftSchema, CirclePatchSchema, ColorSchema, ContentTokenSchema, DEFAULT_LAYER_NAME, DOC_RESOURCES, type DocResourceDescriptor, type DocResourceId, DocTokenSchema, DocumentActionsSnapshotSchema, type DocumentHead, DocumentHeadSchema, type DocumentManifest, DocumentManifestSchema, DocumentMetadataSchema, DocumentSecurityStateSchema, type DownloadToken, EmbeddedFileItemSchema, EmbeddedFileRefSchema, EngineErrorPayloadSchema, FileAttachmentDTOSchema, FileAttachmentIconSchema, FileAttachmentPatchSchema, FileAttachmentWireDraftSchema, FormDataFormatSchema, FormEffectSchema, FormEffectsResultSchema, FormFieldCreateResultSchema, FormFieldDTOSchema, FormFieldDeleteResultSchema, FormFieldDraftSchema, FormFieldFlagsSchema, FormFieldOptionInputSchema, FormFieldOptionSchema, FormFieldPatchSchema, FormFieldRefSchema, FormFieldUpdateResultSchema, FormFieldValueSchema, FormImportResultSchema, FormKindSchema, FormRepairResultSchema, FormSetValueResultSchema, FormSnapshotSchema, FormValueEntrySchema, FormWidgetLinkResultSchema, FormWidgetRefSchema, FreeTextDTOSchema, FreeTextDraftSchema, FreeTextIntentSchema, FreeTextPatchSchema, HighlightDTOSchema, HighlightDraftSchema, HighlightPatchSchema, InkDTOSchema, InkDraftSchema, InkIntentSchema, InkListSchema, InkPatchSchema, KIND_BY_SUBTYPE, type LayerScopePlane, type LayerScopes, LayerScopesSchema, LayoutTokenSchema, LineDTOSchema, LineDraftSchema, LineEndingSchema, LineEndingsSchema, LinePatchSchema, LinePointsSchema, LinkDTOSchema, LinkDraftSchema, LinkPatchSchema, type ManifestPage, ManifestPageSchema, MetadataPatchSchema, MetadataTokenSchema, MetadataUpdateResultSchema, type MutationMeta, MutationMetaSchema, NoteIconSchema, type OpenDocumentResponse, OpenDocumentResponseSchema, PageBoxesSchema, PageDeleteInputSchema, PageDeleteResultSchema, PageFlattenInputSchema, PageFlattenResultSchema, PageGeometrySnapshotSchema, PageLayoutSchema, PageListSnapshotSchema, PageMoveInputSchema, PageMoveResultSchema, PageNetworkRenderFormatSchema, PageRenderAnnotatedQuerySchema, PageRenderQuerySchema, PageRotateInputSchema, PageRotateResultSchema, PageStateSchema, PageStructureCacheSchema, PageTextSnapshotSchema, PdfActionNodeSchema, PdfActionTreeSchema, PdfActionTypeSchema, PdfAnnotationActionsSchema, PdfDestinationSchema, PdfFieldActionsSchema, PdfLinkTargetSchema, PdfLinkTargetWritableSchema, PdfPageActionsSchema, PdfPointSchema, PdfQuadSchema, PdfRectDifferencesSchema, PdfRectSchema, PdfRotationSchema, PdfSaveModeSchema, PdfSizeSchema, PointSchema, PolygonDTOSchema, PolygonDraftSchema, PolygonPatchSchema, PolylineDTOSchema, PolylineDraftSchema, PolylinePatchSchema, RectSchema, RedactionApplyResultSchema, RedactionApplyScopeSchema, RefetchReasonSchema, type RenderPolicy, RenderTokenSchema, type RenderVersions, ResourceRefSchema, RevisionTokenSchema, type RouteKind, SearchMatchSchema, SearchModeSchema, SearchQuerySchema, SearchRequestSchema, SearchSliceSchema, SearchSnippetSchema, type SearchToken, SearchTokenSchema, SquareDTOSchema, SquareDraftSchema, SquarePatchSchema, SquigglyDTOSchema, SquigglyDraftSchema, SquigglyPatchSchema, StampDTOSchema, StampWireDraftSchema, StampWirePatchSchema, StandardFontSchema, StrikeoutDTOSchema, StrikeoutDraftSchema, StrikeoutIntentSchema, StrikeoutPatchSchema, TextAlignmentSchema, TextDTOSchema, TextDraftSchema, TextPatchSchema, ToggleFieldWidgetSchema, type TokenInput, type TokenQuery, type TokenScalar, type TokenSchema, UnderlineDTOSchema, UnderlineDraftSchema, UnderlinePatchSchema, UnsupportedDTOSchema, UnsupportedDraftSchema, UnsupportedPatchSchema, type WeakAnnotationSessionPagesRequest, WeakAnnotationSessionPagesRequestSchema, type WeakAnnotationSessionResponse, WeakAnnotationSessionResponseSchema, WidgetAppearanceSchema, WidgetPlacementSchema, WireAttachmentFileSchema, type WireFlat, type WireScalar, annotationAppearancesImageOptionsToToken, annotationAppearancesImageOptionsToWire, annotationRenderOptionsFromImageOptions, applyCdnAccess, cdnCoverageForScope, checkResourceAccess, decodeActionsToken, decodeAnnotationAppearancesRenderToken, decodeAnnotationToken, decodeAttachmentsToken, decodeContentToken, decodeDocToken, decodeDownloadToken, decodeLayoutToken, decodeMetadataToken, decodeRenderToken, decodeSearchToken, decodeToken, decodeTokenText, encodeActionsToken, encodeAnnotationAppearancesRenderToken, encodeAnnotationToken, encodeAttachmentsToken, encodeContentToken, encodeDocToken, encodeDownloadToken, encodeLayoutToken, encodeMetadataToken, encodeRenderToken, encodeSearchToken, encodeToken, encodeTokenText, flatten, pageRenderOptionsFromImageOptions, renderImageOptionsToToken, renderImageOptionsToWire, resolveResourceIdForPath, unflatten, wirePaths };
+//# sourceMappingURL=wire.d.cts.map