@embedpdf/engine-core 3.0.0-next.14 → 3.0.0-next.16

package/dist/schemas-BE2QGOit.js

@@ -0,0 +1,1851 @@
+import { y as EngineErrorCode } from "./format-Dgg428Kb.js";
+import { c as toBase64, l as ANNOTATION_APPEARANCE_MODES, r as charMapViolation, s as fromBase64 } from "./charmap-Cprti1ta.js";
+import "./PageInsertBlankInput-DhVYVJ_S.js";
+import { At as AppearanceResourceKeysSchema, Cn as AnnotationRefSchema, Dt as AttachmentSchema, E as FormFieldRefSchema, En as ColorSchema, Et as AttachmentRefSchema, Kn as PageQuadSchema, Mt as ImageResourceKeysSchema, Qn as PageRefSchema, T as WidgetPatchSchema, Tt as AttachmentFileInfoSchema, Wn as PageBoxSchema, Xn as PdfRotationSchema, Yn as PdfRectSchema, Zn as PdfSizeSchema, _ as AnnotationSchema, _n as PdfPageActionsSchema, a as FormFieldPatchSchema, bn as PdfLinkTargetWritableSchema, d as FormWidgetSchema, dn as PdfActionTreeSchema, g as AnnotationPatchSchema, h as AnnotationDraftSchema, in as IsoDateTimeSchema, n as FormFieldDraftSchema, o as FormFieldValueSchema, p as WidgetPlacementSchema, rn as DateInputSchema, s as FormFieldWidgetSchema, t as FormFieldDTOSchema, w as WidgetDTOSchema, wt as AttachmentFileBaseSchema, yn as PdfLinkTargetSchema } from "./schema-6S2VmlAj.js";
+import { z } from "zod";
+//#region src/wire/renderFamilies.ts
+const PAGE_RENDER_FAMILIES = {
+	pages: {
+		family: "pages",
+		resource: "page-render",
+		layerResource: "layer-page-render",
+		draws: {
+			includeAnnotations: false,
+			includeFormFields: false
+		},
+		path: "render/pages",
+		needs: ["doc.render"],
+		planes: ["content"],
+		pins: ["contentVersion"],
+		print: null
+	},
+	annotations: {
+		family: "annotations",
+		resource: "page-render-annotations",
+		layerResource: "layer-page-render-annotations",
+		draws: {
+			includeAnnotations: true,
+			includeFormFields: false
+		},
+		path: "render/annotations/pages",
+		needs: ["doc.render", "doc.annotate.read"],
+		planes: ["content", "annotations"],
+		pins: ["contentVersion", "annotationVersion"],
+		print: null
+	},
+	fields: {
+		family: "fields",
+		resource: "page-render-fields",
+		layerResource: "layer-page-render-fields",
+		draws: {
+			includeAnnotations: false,
+			includeFormFields: true
+		},
+		path: "render/fields/pages",
+		needs: ["doc.render", "doc.forms.read"],
+		planes: ["content", "forms"],
+		pins: ["contentVersion", "widgetVersion"],
+		print: null
+	},
+	all: {
+		family: "all",
+		resource: "page-render-all",
+		layerResource: "layer-page-render-all",
+		draws: {
+			includeAnnotations: true,
+			includeFormFields: true
+		},
+		path: "render/all/pages",
+		needs: [
+			"doc.render",
+			"doc.annotate.read",
+			"doc.forms.read"
+		],
+		planes: [
+			"content",
+			"annotations",
+			"forms"
+		],
+		pins: [
+			"contentVersion",
+			"annotationVersion",
+			"widgetVersion"
+		],
+		print: null
+	}
+};
+/** The family of a picture that draws `layers`. */
+function pageRenderFamilyOf(layers) {
+	if (layers.includeAnnotations) return layers.includeFormFields ? "all" : "annotations";
+	return layers.includeFormFields ? "fields" : "pages";
+}
+const PAGE_PRINT_TIERS = {
+	print: {
+		tier: "print",
+		dpi: 150,
+		needs: ["doc.print"]
+	},
+	"print-high": {
+		tier: "print-high",
+		dpi: 300,
+		needs: ["doc.print", "doc.print.high"]
+	}
+};
+/** The tier that prints at `dpi`. */
+function pagePrintTierOf(dpi) {
+	return dpi === 300 ? "print-high" : "print";
+}
+/**
+* The print pictures: each of the four families, printed at each tier. A
+* print picture draws what its family draws, by the print rules: layers in
+* their print state, annotations and fields by their `print` flag. So no
+* print family is a screen picture under another name, and each needs its
+* family's rights plus its tier's. It keeps its family's planes and pins,
+* and its path is the family's with the tier after `render/`:
+* `render/print-high/annotations/pages`.
+*/
+const PAGE_PRINT_FAMILIES = {
+	print: {
+		pages: printFamily("print", "pages", "page-print", "layer-page-print"),
+		annotations: printFamily("print", "annotations", "page-print-annotations", "layer-page-print-annotations"),
+		fields: printFamily("print", "fields", "page-print-fields", "layer-page-print-fields"),
+		all: printFamily("print", "all", "page-print-all", "layer-page-print-all")
+	},
+	"print-high": {
+		pages: printFamily("print-high", "pages", "page-print-high", "layer-page-print-high"),
+		annotations: printFamily("print-high", "annotations", "page-print-high-annotations", "layer-page-print-high-annotations"),
+		fields: printFamily("print-high", "fields", "page-print-high-fields", "layer-page-print-high-fields"),
+		all: printFamily("print-high", "all", "page-print-high-all", "layer-page-print-high-all")
+	}
+};
+/** Every page picture: the four screen families and the eight print ones. */
+const PAGE_PICTURES = [...Object.values(PAGE_RENDER_FAMILIES), ...Object.values(PAGE_PRINT_FAMILIES).flatMap((tier) => Object.values(tier))];
+/** The picture that draws `layers`, for the screen or printed at `dpi`. */
+function pagePictureOf(layers, printDpi) {
+	const family = pageRenderFamilyOf(layers);
+	return printDpi === void 0 ? PAGE_RENDER_FAMILIES[family] : PAGE_PRINT_FAMILIES[pagePrintTierOf(printDpi)][family];
+}
+function printFamily(tier, family, resource, layerResource) {
+	const screen = PAGE_RENDER_FAMILIES[family];
+	const print = PAGE_PRINT_TIERS[tier];
+	return {
+		...screen,
+		resource,
+		layerResource,
+		path: `render/${tier}/${screen.path.slice(7)}`,
+		needs: [...screen.needs, ...print.needs],
+		print
+	};
+}
+//#endregion
+//#region src/identity/OutlineItemRef.schema.ts
+/** Wire form of `OutlineItemRef` — see the type. */
+const OutlineItemRefSchema = z.object({
+	kind: z.literal("objectNumber"),
+	objectNumber: z.number().int().positive()
+});
+//#endregion
+//#region src/dto/DocumentOutline.schema.ts
+/** Wire form of an `OutlineItem` (page space) — see the type. */
+const OutlineItemSchema = z.object({
+	ref: OutlineItemRefSchema,
+	parent: OutlineItemRefSchema.nullable(),
+	title: z.string(),
+	target: PdfLinkTargetSchema.nullable(),
+	action: PdfActionTreeSchema.nullable(),
+	open: z.boolean(),
+	color: ColorSchema.nullable(),
+	bold: z.boolean(),
+	italic: z.boolean()
+});
+/** Wire form of a `DocumentOutline` (page space): what `GET …/outline` answers. */
+const DocumentOutlineSchema = z.object({
+	items: z.array(OutlineItemSchema),
+	incomplete: z.boolean()
+});
+/**
+* A title as a write takes it: at most 32,767 UTF-16 code units, the most a
+* PDF text string holds in every PDF app (ISO 32000-2 Annex C).
+*/
+const OutlineTitleSchema = z.string().max(32767);
+const outlineFields = {
+	title: OutlineTitleSchema,
+	target: PdfLinkTargetWritableSchema.nullable().optional(),
+	color: ColorSchema.nullable().optional(),
+	bold: z.boolean().optional(),
+	italic: z.boolean().optional()
+};
+/** Wire form of an `OutlineItemDraft` (page space). */
+const OutlineItemDraftSchema = z.object(outlineFields).strict();
+/** Wire form of an `OutlineItemPatch` (page space). */
+const OutlineItemPatchSchema = z.object({
+	...outlineFields,
+	title: OutlineTitleSchema.optional(),
+	open: z.boolean().optional()
+}).strict();
+//#endregion
+//#region src/wire/schemas.ts
+/** Who a session acts for; see `Identity` in `auth/scope/types.ts`. */
+const IdentitySchema = z.object({
+	userId: z.string().min(1).max(256).optional(),
+	displayName: z.string().min(1).max(256).optional(),
+	email: z.string().min(1).max(256).optional(),
+	title: z.string().min(1).max(256).optional(),
+	organization: z.string().min(1).max(256).optional(),
+	organizationalUnit: z.string().min(1).max(256).optional(),
+	groupId: z.string().min(1).max(256).optional()
+}).strict();
+const DocumentMetadataSchema = z.object({
+	title: z.string().nullable(),
+	author: z.string().nullable(),
+	subject: z.string().nullable(),
+	keywords: z.string().nullable(),
+	producer: z.string().nullable(),
+	creator: z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	modifiedAt: IsoDateTimeSchema.nullable(),
+	trapped: z.enum([
+		"true",
+		"false",
+		"unknown"
+	])
+});
+/**
+* Three-state metadata patch. Mirrors annotation patch semantics:
+* `undefined` leaves a field, `null` clears it, a value sets it.
+*/
+const MetadataPatchSchema = z.object({
+	title: z.string().nullable().optional(),
+	author: z.string().nullable().optional(),
+	subject: z.string().nullable().optional(),
+	keywords: z.string().nullable().optional(),
+	producer: z.string().nullable().optional(),
+	creator: z.string().nullable().optional(),
+	createdAt: DateInputSchema.nullable().optional(),
+	modifiedAt: DateInputSchema.nullable().optional(),
+	trapped: z.enum([
+		"true",
+		"false",
+		"unknown"
+	]).optional()
+}).strict();
+/** The Info dict's other keys, `{ key: value }`. */
+const CustomMetadataSchema = z.record(z.string(), z.string());
+/**
+* A custom-key patch: every key is a field (string sets, `null` removes, left
+* out stays). Which keys a PDF can hold is the engine's check, so a refusal
+* names the key the same way on both engines.
+*/
+const CustomMetadataPatchSchema = z.record(z.string(), z.string().nullable());
+const OpenDocumentResponseSchema = z.object({ id: z.string() });
+/**
+* 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), which
+* makes `/manifest@docVersion=N` fully content-addressed and cache-friendly.
+* The server's layer mutations bump it.
+*/
+const DocumentHeadSchema = z.object({
+	id: z.string(),
+	baseSha: z.string(),
+	storageSizeBytes: z.number().int().nonnegative(),
+	docVersion: z.number().int().positive(),
+	state: z.enum([
+		"pending",
+		"ready",
+		"failed",
+		"deleting"
+	]),
+	encryption: z.object({
+		state: z.enum([
+			"unknown",
+			"none",
+			"encrypted",
+			"unsupported"
+		]),
+		requiresPassword: z.boolean().nullable()
+	}),
+	permissions: z.object({
+		known: z.boolean(),
+		bits: z.number().int().nonnegative().nullable(),
+		allAllowed: z.boolean().nullable(),
+		openedAs: z.enum([
+			"none",
+			"user",
+			"owner"
+		]).nullable(),
+		securityHandlerRevision: z.number().int().nullable(),
+		canUpgradeToOwner: z.boolean()
+	}),
+	access: z.object({
+		required: z.boolean(),
+		reasons: z.array(z.enum([
+			"password",
+			"cdn",
+			"permissions-unknown"
+		])),
+		endpoint: z.string().optional()
+	})
+});
+const AccessRequestSchema = z.object({
+	/** Deprecated: identity now rides the path
+	*  (`/v1/docs/:docId/layers/:layerName/access`). Kept optional for the
+	*  legacy `/v1/access` alias, which requires `docId` in the body. */
+	docId: z.string().min(1).optional(),
+	layerName: z.string().min(1).optional(),
+	password: z.string().optional(),
+	passwordGrant: z.string().optional(),
+	mode: z.enum(["any", "owner"]).optional(),
+	/**
+	* How many object numbers the caller's editing session wants now, at
+	* most 32: 8 for a new session when absent, 0 for a client that holds
+	* enough.
+	*/
+	objectNumbers: z.number().int().nonnegative().optional()
+});
+/** `first`, `first + 1`, …, `first + count - 1`. */
+const ObjectNumberRangeSchema = z.object({
+	first: z.number().int().positive(),
+	count: z.number().int().positive()
+});
+/** See `EditSessionAccess`. */
+const EditSessionAccessSchema = z.object({
+	session: z.enum([
+		"new",
+		"revived",
+		"live"
+	]),
+	expiresIn: z.number().int().nonnegative(),
+	objectNumbers: z.array(ObjectNumberRangeSchema)
+});
+/** See `EditSessionStatus`: the event stream's `session` event. */
+const EditSessionStatusSchema = z.object({
+	held: z.array(ObjectNumberRangeSchema),
+	expiresIn: z.number().int().nonnegative()
+});
+/** `POST …/object-numbers`: a bulk reservation. */
+const ObjectNumberReservationRequestSchema = z.object({ count: z.number().int().positive() });
+const ObjectNumberReservationResponseSchema = z.object({
+	objectNumbers: z.array(ObjectNumberRangeSchema),
+	expiresIn: z.number().int().nonnegative()
+});
+/**
+* Typed boolean view of the PDF user-access permission word. Names
+* mirror the `PdfBits` shape in @embedpdf/engine-core/auth/scope; ISO
+* bit numbers (3, 4, 5, 6, 9, 10, 11, 12).
+*/
+const PdfBitsObjectSchema = z.object({
+	bit3: z.boolean(),
+	bit4: z.boolean(),
+	bit5: z.boolean(),
+	bit6: z.boolean(),
+	bit9: z.boolean(),
+	bit10: z.boolean(),
+	bit11: z.boolean(),
+	bit12: z.boolean()
+});
+/**
+* Capability-shaped advisory for the client UI. Mirrors
+* `PdfPermissionAdvisory` in @embedpdf/engine-core/runtime; one
+* boolean per UI badge.
+*/
+const PdfPermissionAdvisoryObjectSchema = z.object({
+	canPrint: z.boolean(),
+	canPrintHigh: z.boolean(),
+	canCopy: z.boolean(),
+	canAnnotate: z.boolean(),
+	canFillForms: z.boolean(),
+	canModifyForms: z.boolean(),
+	canModifyPages: z.boolean(),
+	canAssemble: z.boolean()
+});
+const PdfPermissionInfoSchema = z.object({
+	known: z.boolean(),
+	allAllowed: z.boolean().nullable(),
+	bits: z.number().int().nonnegative().nullable(),
+	openedAs: z.enum([
+		"none",
+		"user",
+		"owner"
+	]).nullable(),
+	securityHandlerRevision: z.number().int().nullable(),
+	flags: PdfBitsObjectSchema.optional(),
+	advisory: PdfPermissionAdvisoryObjectSchema.optional()
+}).nullable();
+const DocumentSecurityStateSchema = z.object({
+	encryption: z.object({
+		state: z.enum([
+			"unknown",
+			"none",
+			"encrypted",
+			"unsupported"
+		]),
+		requiresPassword: z.boolean().nullable()
+	}),
+	permissions: z.object({
+		known: z.boolean(),
+		bits: z.number().int().nonnegative().nullable(),
+		allAllowed: z.boolean().nullable(),
+		openedAs: z.enum([
+			"none",
+			"user",
+			"owner"
+		]).nullable(),
+		securityHandlerRevision: z.number().int().nullable(),
+		canUpgradeToOwner: z.boolean()
+	}),
+	access: z.object({
+		required: z.boolean(),
+		reasons: z.array(z.enum([
+			"password",
+			"cdn",
+			"permissions-unknown"
+		])),
+		endpoint: z.string().optional()
+	})
+});
+const positiveCount = z.number().int().positive();
+/** See `BundleLimits`. */
+const BundleLimitsSchema = z.object({
+	bundleBytes: positiveCount,
+	manifestBytes: positiveCount,
+	items: positiveCount,
+	pages: positiveCount,
+	resources: positiveCount,
+	resourceBytes: positiveCount,
+	imagePixels: positiveCount
+}).strict();
+const AccessResponseSchema = z.object({
+	security: DocumentSecurityStateSchema,
+	cdn: z.object({
+		adapter: z.enum([
+			"none",
+			"cloudfront",
+			"cloud-cdn",
+			"bunny",
+			"azure-fd",
+			"custom-hmac"
+		]),
+		expiresAt: z.number().int().positive(),
+		cache: z.object({
+			scope: z.enum(["browser-private", "edge-shared"]),
+			immutableVersionedReads: z.boolean()
+		}),
+		baseUrlOverrides: z.record(z.string(), z.string()).nullable(),
+		authHeader: z.object({
+			name: z.string(),
+			value: z.string()
+		}).nullable(),
+		signedQueryParams: z.record(z.string(), z.string()).nullable(),
+		signedCookies: z.array(z.object({
+			name: z.string(),
+			value: z.string(),
+			domain: z.string().optional(),
+			path: z.string().optional(),
+			expires: z.number().int().optional()
+		})).nullable(),
+		signedPathPolicies: z.array(z.object({
+			pathPrefix: z.string(),
+			queryParams: z.record(z.string(), z.string())
+		})).nullable()
+	}),
+	passwordGrant: z.string().nullable(),
+	pdfPermissions: PdfPermissionInfoSchema,
+	scope: z.array(z.string()),
+	/**
+	* 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.array(z.string()),
+	/** What the document's signatures forbid; `effectiveScope` already leaves it out. */
+	protection: z.lazy(() => DocumentProtectionSchema).nullable(),
+	identity: IdentitySchema,
+	originPasswordPolicy: z.object({ mode: z.enum([
+		"not-needed",
+		"client-retry",
+		"server-session"
+	]) }),
+	expiresAt: z.number().int().positive(),
+	/**
+	* 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.object({
+		/**
+		* 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.object({ widths: z.array(z.number().int().positive()) }),
+		/**
+		* Reserved for deep-zoom tile support: scale-based pyramid ×
+		* fixed tile size, constant per-job cost. Absent until the tiling
+		* plugin ships.
+		*/
+		tiles: z.object({
+			tileSizes: z.array(z.number().int().positive()),
+			scales: z.array(z.number().positive())
+		}).optional(),
+		/**
+		* 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.object({ scales: z.array(z.number().positive()) }).optional(),
+		/** Worker-side output budget for degenerate page geometry. */
+		maxRenderPixels: z.number().int().positive().optional(),
+		formats: z.array(z.enum(["webp", "png"])),
+		background: z.enum(["white"]),
+		enforced: z.boolean()
+	}).optional(),
+	/** The deployment's limits for an annotation import (see `BundleLimits`). */
+	bundleLimits: BundleLimitsSchema,
+	/** The caller's editing session (see `DocumentAccessInfo.edit`). */
+	edit: EditSessionAccessSchema.optional()
+});
+const PdfSaveModeSchema = z.enum(["incremental", "rewrite"]);
+const engineErrorCodeValues = Object.values(EngineErrorCode);
+const EngineErrorPayloadSchema = z.object({
+	name: z.literal("EngineError"),
+	code: z.enum(engineErrorCodeValues),
+	message: z.string(),
+	details: z.record(z.string(), z.unknown()).optional()
+});
+const CachePinsSchema = z.object({
+	contentVersion: z.number().int().positive(),
+	annotationVersion: z.number().int().positive(),
+	widgetVersion: z.number().int().positive()
+});
+/**
+* Plane scopes are derived from the version counters when a layer manifest
+* is built, never stored. Absent on base manifests: consumers treat absence
+* as all-'layer' (never wrong, only unshared).
+*/
+const LayerScopeValueSchema = z.enum(["base", "layer"]);
+const LayerScopesSchema = z.object({
+	content: LayerScopeValueSchema,
+	annotations: LayerScopeValueSchema,
+	forms: LayerScopeValueSchema,
+	layout: LayerScopeValueSchema,
+	attachments: LayerScopeValueSchema,
+	metadata: LayerScopeValueSchema,
+	actions: LayerScopeValueSchema,
+	outline: LayerScopeValueSchema
+});
+/**
+* Per-page envelope inside `DocumentManifest`: the page, 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. The server derives both from its per-layer page state.
+*/
+const ManifestPageSchema = z.object({
+	page: PageRefSchema,
+	cache: CachePinsSchema
+});
+/**
+* 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`.
+*/
+const DocumentManifestSchema = z.object({
+	docVersion: z.number().int().positive(),
+	layoutVersion: z.number().int().positive(),
+	metadataVersion: z.number().int().positive(),
+	actionsVersion: z.number().int().positive().default(1),
+	attachmentsVersion: z.number().int().positive().default(1),
+	annotationsVersion: z.number().int().positive().default(1),
+	formsVersion: z.number().int().positive().default(1),
+	outlineVersion: z.number().int().positive().default(1),
+	auditHead: z.number().int().nonnegative(),
+	baseSha: z.string(),
+	layerVersion: z.number().int().nonnegative().default(0),
+	working: z.boolean().default(false),
+	baseByteLength: z.number().int().nonnegative().default(0),
+	scopes: LayerScopesSchema.optional(),
+	protection: z.lazy(() => DocumentProtectionSchema).nullable(),
+	pages: z.array(ManifestPageSchema)
+});
+/** What both engines' `annotations.list()` return, and the server's list endpoints send. */
+const AnnotationListSchema = z.object({
+	annotations: z.array(AnnotationSchema),
+	pages: z.array(PageRefSchema),
+	auditHead: z.number().int().nonnegative().optional()
+});
+/**
+* Wire shape of `GET …/text/pages/:pon/data@<contentVersion>` and the
+* `pages.text` worker result: the UTF-16-faithful extraction, the character
+* space size (`charCount` — the space geometry runs tile; not `text.length`),
+* and the optional character→text anchor map. Malformed maps are rejected
+* here with the shared `charMapViolation` invariants — absent/empty map
+* requires `charCount === text.length` (identity).
+*/
+const PageTextSnapshotSchema = z.object({
+	text: z.string(),
+	charCount: z.number().int().nonnegative(),
+	charMap: z.array(z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()])).optional()
+}).superRefine((snapshot, ctx) => {
+	const violation = charMapViolation(snapshot.charCount, snapshot.text.length, snapshot.charMap);
+	if (violation !== null) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["charMap"],
+		message: violation
+	});
+});
+const PageGeometryGlyphSchema = z.object({
+	loose: PageBoxSchema,
+	tight: PageBoxSchema.optional(),
+	space: z.literal(true).optional(),
+	empty: z.literal(true).optional()
+});
+const RotatedGeometryGlyphSchema = z.object({
+	loose: PageQuadSchema,
+	tight: PageQuadSchema.optional(),
+	space: z.literal(true).optional(),
+	empty: z.literal(true).optional()
+});
+const UprightGeometryRunSchema = z.object({
+	rect: PageBoxSchema,
+	start: z.number().int().nonnegative(),
+	glyphs: z.array(PageGeometryGlyphSchema),
+	fontSize: z.number().optional()
+});
+const RotatedGeometryRunSchema = z.object({
+	rect: PageBoxSchema,
+	start: z.number().int().nonnegative(),
+	glyphs: z.array(RotatedGeometryGlyphSchema),
+	rotation: z.number(),
+	ascentFlip: z.boolean(),
+	fontSize: z.number().optional()
+});
+const PageGeometryRunSchema = z.union([RotatedGeometryRunSchema, UprightGeometryRunSchema]);
+const PageGeometrySnapshotSchema = z.object({ runs: z.array(PageGeometryRunSchema) });
+/**
+* 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.
+*/
+const searchQueryObject = z.object({
+	text: z.string(),
+	regex: z.boolean().optional(),
+	matchCase: z.boolean().optional(),
+	wholeWord: z.boolean().optional(),
+	matchDiacritics: z.boolean().optional(),
+	ignoreWhitespace: z.boolean().optional()
+});
+const SearchQuerySchema = searchQueryObject;
+const SearchRequestSchema = searchQueryObject.extend({
+	snippets: z.boolean().optional(),
+	from: PageRefSchema.optional(),
+	cursor: z.string().optional(),
+	limit: z.object({
+		matches: z.number().int().positive().optional(),
+		pages: z.number().int().positive().optional()
+	}).optional()
+});
+const SearchSnippetSchema = z.object({
+	before: z.string(),
+	match: z.string(),
+	after: z.string()
+});
+const PdfTextSegmentSchema = z.object({
+	quad: PageQuadSchema,
+	rect: PageBoxSchema,
+	advance: z.union([z.literal(1), z.literal(-1)])
+});
+const SearchMatchSchema = z.object({
+	page: PageRefSchema,
+	start: z.number().int().nonnegative(),
+	count: z.number().int().positive(),
+	segments: z.array(PdfTextSegmentSchema),
+	snippet: SearchSnippetSchema.optional()
+});
+const SearchSliceSchema = z.object({
+	matches: z.array(SearchMatchSchema),
+	nextCursor: z.string().nullable(),
+	pagesSearched: z.number().int().nonnegative(),
+	pageCount: z.number().int().nonnegative()
+});
+const PageNetworkRenderFormatSchema = z.enum(["png", "webp"]);
+/**
+* Wire schema for the cloud render endpoints, applied to the **nested**
+* shape produced by `unflatten(...)` of the parsed token or query string.
+*
+* Adding a new render option is one change here (a new field plus any
+* cross-field rule in `superRefine`) plus one entry in
+* `RenderTokenSchema.fields`. The token codec, flatten/unflatten helpers,
+* route handlers, and SDK URL builder are all generic and pick the new
+* field up automatically.
+*
+* Coercion: token fields and query strings both arrive as strings, so every
+* scalar uses `z.coerce.*`. Discriminated unions on `viewport.kind` and
+* `target.kind` enforce viewport / rect coherence by construction — no
+* superRefine for "fields must appear together" rules.
+*/
+const RenderViewportSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("width"),
+	width: z.coerce.number().positive().finite()
+}).strict(), z.object({
+	kind: z.literal("scale"),
+	scale: z.coerce.number().positive().finite().optional()
+}).strict()]);
+const RenderTargetSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("page") }).strict(), z.object({
+	kind: z.literal("rect"),
+	rect: z.object({
+		x: z.coerce.number().finite(),
+		y: z.coerce.number().finite(),
+		width: z.coerce.number().positive().finite(),
+		height: z.coerce.number().positive().finite()
+	}).strict()
+}).strict()]);
+const RenderRotationSchema = z.preprocess((raw) => raw === void 0 ? void 0 : Number(raw), z.number().refine((n) => n === 0 || n === 90 || n === 180 || n === 270, { message: "render rotation must be 0, 90, 180, or 270" }));
+const RenderBackgroundSchema = z.enum(["white", "transparent"]);
+/** WebP quality, 0 (smallest) to 1 (best) — the `canvas.toBlob` scale. */
+const RenderQualitySchema = z.coerce.number().min(0).max(1);
+const AppearanceModeSchema = z.enum([
+	"normal",
+	"rollover",
+	"down"
+]);
+/**
+* A token's `modes`: the modes it asks for, in the engine's mode order,
+* joined by `-` (`normal-down`). Anything else is refused, so one set of
+* modes has one spelling and one URL.
+*/
+const AppearanceModesSchema = z.string().transform((value, ctx) => {
+	const modes = value.split("-");
+	const canonical = ANNOTATION_APPEARANCE_MODES.filter((mode) => modes.includes(mode));
+	if (canonical.length === 0 || canonical.length === ANNOTATION_APPEARANCE_MODES.length || canonical.join("-") !== value) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "modes must name some but not all of normal, rollover, down, in that order, joined by -"
+		});
+		return z.NEVER;
+	}
+	return canonical;
+});
+/**
+* The query/token schema of one picture family (`PAGE_RENDER_FAMILIES`).
+* What a picture draws is in its path, never its token, so each family has
+* its own schema, built from one shared base:
+*
+*   - its pins are the family's own (`contentVersion`, plus
+*     `annotationVersion` and `widgetVersion` for the planes it draws), and
+*     `.strict()` refuses any other, so a pin the family doesn't depend on
+*     is unrepresentable;
+*   - a versioned request (one with `contentVersion`) carries every one of
+*     them, since the picture changes with each.
+*
+* A print picture (`PAGE_PRINT_FAMILIES`) takes only its pins and its image
+* format: its path says what it draws and at which DPI, and its size comes
+* from that and the paper, so a page has one print picture per family and
+* tier.
+*
+* The transform stamps what the picture draws (and, for a print picture,
+* `usage` and its `dpi` viewport) onto the parsed options, so the worker
+* options downstream need no family.
+*/
+function buildPageRenderQuerySchema(picture) {
+	const { family, draws, pins, print } = picture;
+	const pinFields = {};
+	for (const pin of pins) pinFields[pin] = z.coerce.number().int().positive().optional();
+	const screenFields = print ? {} : {
+		viewport: RenderViewportSchema.optional(),
+		target: RenderTargetSchema.optional(),
+		rotation: RenderRotationSchema.optional(),
+		background: RenderBackgroundSchema.optional()
+	};
+	return z.object({
+		...pinFields,
+		format: PageNetworkRenderFormatSchema.optional(),
+		quality: RenderQualitySchema.optional(),
+		...screenFields
+	}).strict().superRefine((v, ctx) => {
+		const pinned = v;
+		if (pinned.contentVersion === void 0) {
+			for (const pin of pins) {
+				if (pinned[pin] === void 0) continue;
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					path: [pin],
+					message: `${pin} requires contentVersion`
+				});
+			}
+			return;
+		}
+		if (v.format === void 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["format"],
+			message: "versioned render requires format"
+		});
+		for (const pin of pins) {
+			if (pinned[pin] !== void 0) continue;
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: [pin],
+				message: `a versioned ${family} picture requires ${pin}`
+			});
+		}
+	}).transform((v) => {
+		const pinned = v;
+		const screen = v;
+		const query = { options: {
+			...screen.target ? { target: screen.target } : {},
+			...screen.viewport ? { viewport: screen.viewport } : {},
+			...screen.rotation !== void 0 ? { rotation: screen.rotation } : {},
+			...screen.background !== void 0 ? { background: screen.background } : {},
+			...v.quality !== void 0 ? { quality: v.quality } : {},
+			...v.format !== void 0 ? { format: v.format } : {},
+			...draws,
+			...print ? {
+				usage: "print",
+				viewport: {
+					kind: "dpi",
+					dpi: print.dpi
+				}
+			} : {}
+		} };
+		for (const pin of pins) if (pinned[pin] !== void 0) query[pin] = pinned[pin];
+		return query;
+	});
+}
+/** Query/token schemas of the four picture families, by family. */
+const PageRenderQuerySchemas = {
+	pages: buildPageRenderQuerySchema(PAGE_RENDER_FAMILIES.pages),
+	annotations: buildPageRenderQuerySchema(PAGE_RENDER_FAMILIES.annotations),
+	fields: buildPageRenderQuerySchema(PAGE_RENDER_FAMILIES.fields),
+	all: buildPageRenderQuerySchema(PAGE_RENDER_FAMILIES.all)
+};
+/** Query/token schemas of the print pictures, by tier and family. */
+const PagePrintQuerySchemas = {
+	print: {
+		pages: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES.print.pages),
+		annotations: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES.print.annotations),
+		fields: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES.print.fields),
+		all: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES.print.all)
+	},
+	"print-high": {
+		pages: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES["print-high"].pages),
+		annotations: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES["print-high"].annotations),
+		fields: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES["print-high"].fields),
+		all: buildPageRenderQuerySchema(PAGE_PRINT_FAMILIES["print-high"].all)
+	}
+};
+/** The query/token schema of `picture`, screen or print. */
+function pagePictureQuerySchema(picture) {
+	return picture.print ? PagePrintQuerySchemas[picture.print.tier][picture.family] : PageRenderQuerySchemas[picture.family];
+}
+/**
+* Query/token schema of an appearance batch, keyed by `pin`. Mirrors
+* `PageRenderQuerySchema` but without page target/background or
+* `includeAnnotations` (appearances are always annotation-derived), and keyed
+* by the page's pin for its family only — appearance bitmaps do not depend on
+* page base content, so `contentVersion` is not part of the cache key. The
+* endpoint renders every mode and state an annotation stores, or the `modes`
+* asked for.
+*/
+function buildAppearancesQuerySchema(pin) {
+	return z.object({
+		[pin]: z.coerce.number().int().positive().optional(),
+		format: PageNetworkRenderFormatSchema.optional(),
+		modes: AppearanceModesSchema.optional(),
+		rotation: RenderRotationSchema.optional(),
+		viewport: RenderViewportSchema.optional(),
+		quality: RenderQualitySchema.optional()
+	}).strict().superRefine((v, ctx) => {
+		if (v[pin] !== void 0 && v.format === void 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["format"],
+			message: "versioned appearance render requires format"
+		});
+	}).transform((v) => {
+		return {
+			options: {
+				...v.rotation !== void 0 ? { rotation: v.rotation } : {},
+				...v.viewport ? { viewport: v.viewport } : {},
+				...v.quality !== void 0 ? { quality: v.quality } : {},
+				...v.format !== void 0 ? { format: v.format } : {},
+				...v.modes !== void 0 ? { modes: v.modes } : {}
+			},
+			...v[pin] !== void 0 ? { [pin]: v[pin] } : {}
+		};
+	});
+}
+/** Query/token schema of a page's annotation images (`annotations/pages/{p}/appearances@`). */
+const AnnotationAppearancesQuerySchema = buildAppearancesQuerySchema("annotationVersion");
+/** Query/token schema of a page's widget images (`form/pages/{p}/appearances@`). */
+const WidgetAppearancesQuerySchema = buildAppearancesQuerySchema("widgetVersion");
+/**
+* The `body` part of the appearance `multipart/form-data` response.
+* Wire-stable; the cloud client validates the parsed `body` part against
+* this before reconstructing image handles from the binary parts.
+*/
+const AnnotationAppearanceBatchSchema = z.object({
+	page: PageRefSchema,
+	appearances: z.array(z.object({
+		resources: ImageResourceKeysSchema,
+		ref: AnnotationRefSchema,
+		mode: AppearanceModeSchema,
+		state: z.string().nullable(),
+		rect: PageBoxSchema,
+		width: z.number().int().positive(),
+		height: z.number().int().positive(),
+		format: PageNetworkRenderFormatSchema,
+		contentType: z.string().min(1)
+	}))
+});
+const CacheDeltaSchema = z.object({
+	previousDocVersion: z.number().int().nonnegative(),
+	docVersion: z.number().int().positive(),
+	annotationsVersion: z.number().int().positive().optional(),
+	formsVersion: z.number().int().positive().optional(),
+	layoutVersion: z.number().int().positive().optional(),
+	metadataVersion: z.number().int().positive().optional(),
+	attachmentsVersion: z.number().int().positive().optional(),
+	outlineVersion: z.number().int().positive().optional(),
+	layerVersion: z.number().int().nonnegative().optional(),
+	working: z.boolean().optional(),
+	pages: z.array(z.object({
+		page: PageRefSchema,
+		cache: CachePinsSchema
+	}))
+});
+const MutationMetaSchema = z.object({
+	affectedPages: z.array(PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: z.string(),
+	undoable: z.boolean()
+});
+/**
+* Where rows go in their list, on the wire: `'start'`, `'end'`, or one
+* object naming exactly one neighbour (`before` or `after`).
+*/
+function listPositionSchema(ref) {
+	return z.union([z.enum(["start", "end"]), z.object({
+		before: ref.optional(),
+		after: ref.optional()
+	}).strict().refine((position) => position.before === void 0 !== (position.after === void 0), { message: "exactly one of before or after" })]);
+}
+/** Where pages go among the document's pages. */
+const PagePositionSchema = listPositionSchema(PageRefSchema);
+/** Where annotations go among their page's annotations, or widgets among its widgets. */
+const AnnotationPositionSchema = listPositionSchema(AnnotationRefSchema);
+/** Where fields go in the form's calculation order. */
+const FieldPositionSchema = listPositionSchema(FormFieldRefSchema);
+/** Where outline items go among one parent's children. */
+const OutlinePositionSchema = listPositionSchema(OutlineItemRefSchema);
+/**
+* Stable public component names for the models every part of the document
+* wire shares (page refs, a write's meta, the metadata), like
+* `AnnotationWireComponents`.
+*/
+const DocumentWireComponents = {
+	PageRef: PageRefSchema,
+	PagePosition: PagePositionSchema,
+	CacheDelta: CacheDeltaSchema,
+	MutationMeta: MutationMetaSchema,
+	DocumentMetadata: DocumentMetadataSchema,
+	MetadataPatch: MetadataPatchSchema
+};
+/** Per-page side-effect envelope every annotation mutation returns. Mirrors `AnnotationListMutationMeta`. */
+const AnnotationListMutationMetaSchema = z.object({
+	affectedPages: z.array(PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: z.string(),
+	undoable: z.boolean(),
+	changed: z.array(AnnotationRefSchema)
+});
+const AnnotationCreateResultSchema = z.object({
+	annotation: AnnotationSchema,
+	meta: AnnotationListMutationMetaSchema
+});
+const AnnotationImportResultSchema = z.object({
+	annotations: z.array(AnnotationSchema),
+	refMap: z.array(z.object({
+		from: AnnotationRefSchema,
+		to: AnnotationRefSchema
+	})),
+	dropped: z.array(z.object({
+		ref: AnnotationRefSchema,
+		field: z.string().optional(),
+		reason: z.enum([
+			"unsupported-kind",
+			"widget",
+			"geospatial",
+			"unknown-measure",
+			"unsupported-action",
+			"unsupported-value",
+			"name-conflict",
+			"parent-dropped",
+			"parent-missing",
+			"popup-taken"
+		])
+	})),
+	meta: AnnotationListMutationMetaSchema
+});
+/** The engine's `/AP` verdict riding every update result (see engine-core
+*  `annotation/appearance.ts`). `changed` drives client raster invalidation. */
+const AppearanceOutcomeSchema = z.object({
+	action: z.enum([
+		"preserved",
+		"regenerated",
+		"generation-unavailable",
+		"restored"
+	]),
+	changed: z.boolean()
+});
+const AnnotationUpdateResultSchema = z.object({
+	annotation: AnnotationSchema,
+	appearance: AppearanceOutcomeSchema,
+	meta: AnnotationListMutationMetaSchema
+});
+const AnnotationDeleteResultSchema = z.object({ meta: AnnotationListMutationMetaSchema });
+/**
+* Stable public component names for the annotation wire model, so an OpenAPI
+* projection names each once (`Annotation`, not one type per response that
+* carries one), like `PdfActionWireComponents`.
+*/
+const AnnotationWireComponents = {
+	Annotation: AnnotationSchema,
+	AnnotationRef: AnnotationRefSchema,
+	AnnotationDraft: AnnotationDraftSchema,
+	AnnotationPatch: AnnotationPatchSchema,
+	PdfLinkTarget: PdfLinkTargetSchema,
+	PdfLinkTargetWritable: PdfLinkTargetWritableSchema,
+	AnnotationList: AnnotationListSchema,
+	AnnotationMutationMeta: AnnotationListMutationMetaSchema,
+	AnnotationPosition: AnnotationPositionSchema
+};
+/** What `page.annotations.reorder` takes on the wire. */
+const AnnotationReorderBodySchema = z.object({
+	refs: z.array(AnnotationRefSchema).min(1),
+	position: AnnotationPositionSchema
+}).strict();
+/** A stacking-order change: the page's annotations in their new order, as refs. */
+const AnnotationReorderResultSchema = z.object({
+	order: z.array(AnnotationRefSchema),
+	meta: AnnotationListMutationMetaSchema
+});
+/** A single-field write's meta: the envelope plus the fields and widgets it changed. */
+const FormMutationMetaSchema = z.object({
+	affectedPages: z.array(PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: z.string(),
+	undoable: z.boolean(),
+	changedFields: z.array(FormFieldRefSchema),
+	changedWidgets: z.array(FormWidgetSchema),
+	redrawnWidgets: z.array(FormWidgetSchema)
+});
+/**
+* Stable public component names for the form wire model, so an OpenAPI
+* projection names each once (`FormField`, not one type per response that
+* carries one), like `AnnotationWireComponents`.
+*/
+const FormWireComponents = {
+	FormFieldRef: FormFieldRefSchema,
+	FormField: FormFieldDTOSchema,
+	FormFieldValue: FormFieldValueSchema,
+	FormWidget: FormWidgetSchema,
+	FormFieldDraft: FormFieldDraftSchema,
+	FormFieldPatch: FormFieldPatchSchema,
+	FieldPosition: FieldPositionSchema,
+	WidgetPlacement: WidgetPlacementSchema,
+	WidgetAnnotation: WidgetDTOSchema,
+	WidgetPatch: WidgetPatchSchema,
+	FormMutationMeta: FormMutationMetaSchema
+};
+const FormSetValueResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	widgets: z.array(WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+const FormResetResultSchema = z.object({
+	fields: z.array(FormFieldDTOSchema),
+	widgets: z.array(WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+/** What `reset` takes on the wire: the fields to reset, or none for the whole form. */
+const FormResetBodySchema = z.object({ refs: z.array(FormFieldRefSchema).optional() }).strict();
+/** What `updateWidget` takes on the wire: the widget patch (`PATCH …/form/widgets/{p}/{key}`). */
+const FormWidgetUpdateBodySchema = z.object({ patch: WidgetPatchSchema }).strict();
+const FormImportResultSchema = z.object({
+	fields: z.array(FormFieldDTOSchema),
+	widgets: z.array(WidgetDTOSchema),
+	refMap: z.array(z.object({
+		from: FormFieldRefSchema,
+		to: FormFieldRefSchema
+	})),
+	dropped: z.array(z.object({
+		ref: FormFieldRefSchema.nullable(),
+		widget: AnnotationRefSchema.optional(),
+		field: z.string().optional(),
+		reason: z.enum([
+			"name-conflict",
+			"no-field",
+			"unsupported-family",
+			"script-not-allowed",
+			"unsupported-action"
+		])
+	})),
+	calculationOrder: z.array(FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+const FormValuesImportResultSchema = z.object({
+	fields: z.array(FormFieldDTOSchema),
+	widgets: z.array(WidgetDTOSchema),
+	dropped: z.array(z.object({
+		ref: FormFieldRefSchema,
+		reason: z.enum([
+			"no-field",
+			"wrong-family",
+			"value-not-allowed",
+			"locked",
+			"fill-not-allowed"
+		])
+	})),
+	meta: FormMutationMetaSchema
+});
+const FormFieldCreateResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	widgets: z.array(WidgetDTOSchema),
+	calculationOrder: z.array(FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+const FormFieldUpdateResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	widgets: z.array(WidgetDTOSchema),
+	calculationOrder: z.array(FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetUpdateResultSchema = z.object({
+	widget: WidgetDTOSchema,
+	appearance: AppearanceOutcomeSchema,
+	meta: FormMutationMetaSchema
+});
+/** What `forms.reorderWidgets` takes on the wire: the widgets of one page and where they go. */
+const FormWidgetsReorderBodySchema = z.object({
+	widgets: z.array(AnnotationRefSchema).min(1),
+	position: AnnotationPositionSchema
+}).strict();
+/** A widget stacking-order change: the page's widgets in their new order, as refs. */
+const FormWidgetsReorderResultSchema = z.object({
+	page: PageRefSchema,
+	order: z.array(AnnotationRefSchema),
+	meta: FormMutationMetaSchema
+});
+const FormFieldDeleteResultSchema = z.object({
+	calculationOrder: z.array(FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+/** What `forms.reorderCalculations` takes on the wire: the fields and where they go. */
+const FormCalculationsReorderBodySchema = z.object({
+	fields: z.array(FormFieldRefSchema).min(1),
+	position: FieldPositionSchema
+}).strict();
+/** A calculation-order change: the form's whole new order. */
+const FormCalculationsReorderResultSchema = z.object({
+	calculationOrder: z.array(FormFieldRefSchema),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetLinkResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	widgets: z.array(WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetDeleteResultSchema = z.object({
+	widget: AnnotationRefSchema,
+	page: PageRefSchema,
+	field: FormFieldDTOSchema.nullable(),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetRestoreResultSchema = z.object({
+	field: FormFieldDTOSchema.nullable(),
+	widgets: z.array(WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+const FormRepairResultSchema = z.object({
+	acroformCreated: z.boolean(),
+	fieldsLinked: z.number().int().nonnegative(),
+	widgetsLinked: z.number().int().nonnegative(),
+	fieldsUnrepairable: z.number().int().nonnegative(),
+	appearancesBaked: z.number().int().nonnegative(),
+	needsAppearancesCleared: z.boolean(),
+	meta: MutationMetaSchema
+});
+/** A page's five boxes in page space: measured from the top-left of the crop box. */
+const PageBoxesSchema = z.object({
+	media: PageBoxSchema,
+	crop: PageBoxSchema,
+	bleed: PageBoxSchema,
+	trim: PageBoxSchema,
+	art: PageBoxSchema
+});
+/**
+* Pure geometry for one page (`pages.list()` element). No annotation
+* liveness — that lives on annotation reads and the manifest.
+*/
+const PageLayoutSchema = z.object({
+	index: z.number().int().nonnegative(),
+	ref: PageRefSchema,
+	label: z.string().nullable(),
+	size: PdfSizeSchema,
+	rotation: PdfRotationSchema,
+	userUnit: z.number().positive(),
+	tabOrder: z.enum([
+		"rows",
+		"columns",
+		"structure",
+		"annotations",
+		"widgets"
+	]).nullable(),
+	boxes: PageBoxesSchema,
+	pdfCropBox: PdfRectSchema,
+	actions: PdfPageActionsSchema.optional()
+});
+const PageFlattenResultSchema = z.object({
+	pages: z.array(PageRefSchema),
+	usage: z.enum(["display", "print"]),
+	results: z.array(z.object({
+		page: PageRefSchema,
+		status: z.enum(["applied", "unchanged"])
+	})),
+	meta: MutationMetaSchema
+});
+/** See `AnnotationFlattenResult`. */
+const AnnotationFlattenResultSchema = z.object({
+	page: PageRefSchema,
+	usage: z.enum(["display", "print"]),
+	results: z.array(z.object({
+		ref: AnnotationRefSchema,
+		status: z.enum(["applied", "unchanged"])
+	})),
+	meta: MutationMetaSchema
+});
+/** `annotations.flatten` input — see `AnnotationFlattenInput`. */
+const AnnotationFlattenInputSchema = z.object({
+	refs: z.array(AnnotationRefSchema).min(1),
+	usage: z.enum(["display", "print"])
+});
+/** `annotations.exportAppearance` input — see `AnnotationAppearanceExportInput`. */
+const AnnotationAppearanceExportInputSchema = z.object({ refs: z.array(AnnotationRefSchema).min(1) });
+/** `doc.annotations.export` selection — see `AnnotationExportSelection`. */
+const AnnotationExportSelectionSchema = z.object({
+	refs: z.array(AnnotationRefSchema).optional(),
+	pages: z.array(PageRefSchema).optional(),
+	include: z.enum(["references", "threads"]).optional()
+}).strict();
+/**
+* The body of a POST annotation export: the pins a GET's token carries and
+* the selection, for one a URL can't carry.
+*/
+const AnnotationsExportRequestSchema = z.object({
+	annotationsVersion: z.number().int().positive(),
+	layoutVersion: z.number().int().positive(),
+	selection: AnnotationExportSelectionSchema
+}).strict();
+/** Where an import puts each page of a bundle — see `BundleImportPages`. */
+const BundleImportPagesSchema = z.union([
+	z.literal("same"),
+	z.literal("by-position"),
+	z.array(z.object({
+		from: PageRefSchema,
+		to: PageRefSchema
+	}).strict())
+]);
+/** `doc.forms.export` selection — see `FormExportSelection`. */
+const FormExportSelectionSchema = z.object({
+	fields: z.array(FormFieldRefSchema).optional(),
+	pages: z.array(PageRefSchema).optional()
+}).strict();
+/**
+* The body of a POST form export: the pins a GET's token carries and the
+* selection, for one a URL can't carry.
+*/
+const FormExportRequestSchema = z.object({
+	formsVersion: z.number().int().positive(),
+	layoutVersion: z.number().int().positive(),
+	selection: FormExportSelectionSchema
+}).strict();
+/** `doc.forms.import` options on the wire; the `opId` is the `Idempotency-Key` header. */
+const FormImportOptionsSchema = z.object({
+	pages: BundleImportPagesSchema.optional(),
+	attribution: z.enum(["restore", "stamp"]).optional(),
+	values: z.boolean().optional()
+}).strict();
+/** `doc.forms.importValues` options on the wire. */
+const FormValuesImportOptionsSchema = z.object({ attribution: z.enum(["restore", "stamp"]).optional() }).strict();
+/** A form bundle's envelope: its rows are the worker's to check, as an annotation bundle's. */
+const FormBundleEnvelopeSchema = z.object({
+	format: z.literal("embedpdf/form"),
+	version: z.literal(1),
+	pages: z.array(z.unknown()),
+	fields: z.array(z.unknown()),
+	widgets: z.array(z.unknown()),
+	calculationOrder: z.array(z.unknown())
+}).strict();
+/** The `body` part of a form import request. */
+const FormImportBodySchema = z.object({
+	bundle: FormBundleEnvelopeSchema,
+	options: FormImportOptionsSchema
+}).strict();
+/** The `body` part of a form values import request. */
+const FormValuesImportBodySchema = z.object({
+	bundle: FormBundleEnvelopeSchema,
+	options: FormValuesImportOptionsSchema
+}).strict();
+/** `doc.annotations.import` options on the wire; the `opId` is the `Idempotency-Key` header. */
+const AnnotationImportOptionsSchema = z.object({
+	pages: BundleImportPagesSchema.optional(),
+	attribution: z.enum(["restore", "stamp"]).optional()
+}).strict();
+/**
+* The `body` part of an import request. Only its envelope is checked
+* here: the bundle's pages and items are the worker's to check, against the
+* limits and each kind's create schema.
+*/
+const AnnotationImportBodySchema = z.object({
+	bundle: z.object({
+		format: z.literal("embedpdf/annotations"),
+		version: z.literal(1),
+		pages: z.array(z.unknown()),
+		items: z.array(z.unknown())
+	}).strict(),
+	options: AnnotationImportOptionsSchema
+}).strict();
+const PageFlattenInputSchema = z.object({
+	pages: z.array(PageRefSchema),
+	usage: z.enum(["display", "print"])
+});
+/**
+* `{ pages }` or `{ annotations }`: one object with exactly one of the two,
+* so the wire has no untagged union (the API reference labels variants by a
+* discriminating literal, and a scope has none to add).
+*/
+const RedactionApplyScopeSchema = z.object({
+	pages: z.array(PageRefSchema).optional(),
+	annotations: z.array(AnnotationRefSchema).optional()
+}).strict().refine((scope) => scope.pages === void 0 !== (scope.annotations === void 0), { message: "exactly one of pages or annotations" });
+const RedactionApplyResultSchema = z.object({
+	scope: RedactionApplyScopeSchema,
+	results: z.array(z.object({
+		page: PageRefSchema,
+		status: z.enum(["applied", "unchanged"]),
+		removedAnnotationCount: z.number().int().nonnegative()
+	})),
+	removedAnnotationCount: z.number().int().nonnegative(),
+	meta: MutationMetaSchema
+});
+/**
+* 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.
+*/
+/** See `NamedPageEntry`: decoded key + what it resolves to. */
+const NamedPageEntrySchema = z.object({
+	name: z.string(),
+	target: z.discriminatedUnion("kind", [
+		z.object({
+			kind: z.literal("page"),
+			page: PageRefSchema
+		}),
+		z.object({
+			kind: z.literal("template"),
+			objectNumber: z.number().int().positive()
+		}),
+		z.object({ kind: z.literal("dangling") })
+	])
+});
+const PageListSnapshotSchema = z.object({
+	pageCount: z.number().int().nonnegative(),
+	pages: z.array(PageLayoutSchema),
+	namedPages: z.array(NamedPageEntrySchema)
+});
+/** `pages.setName` input — see `PageNameInput`. */
+const PageNameInputSchema = z.object({
+	name: z.string().min(1),
+	page: PageRefSchema,
+	replace: z.string().min(1).optional()
+});
+/** `pages.removeName` input — see `PageRemoveNameInput`. */
+const PageRemoveNameInputSchema = z.object({ name: z.string().min(1) });
+/**
+* Page reorder result. No per-page revision is bumped (they survive a page
+* reorder). The whole new order is returned so callers swap their snapshot.
+*/
+const PageReorderResultSchema = z.object({
+	pages: z.array(PageRefSchema),
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/** Named-page mutation result — layout-shaped, see `PageNameResult`. */
+const PageNameResultSchema = z.object({
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/**
+* Page rotate result. Rotation is presentation metadata over normalized
+* content: nothing per-page invalidates; the new `layout` carries the
+* rotation values (see `PageRotateResult`).
+*/
+const PageRotateResultSchema = z.object({
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/**
+* Page delete result. Deleted page object numbers are retired (never recycled); surviving
+* pages keep identity + revisions (see `PageDeleteResult`).
+*/
+const PageDeleteResultSchema = z.object({
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/**
+* What blank pages to make (`PageInsertBlankSpec`). `size` is in PDF points
+* (un-rotated); `count` shares the contract cap with the worker so a request
+* the schema accepts cannot then fail the worker's own guard.
+*/
+const PageInsertBlankSpecSchema = z.object({
+	size: z.object({
+		width: z.number().positive().finite(),
+		height: z.number().positive().finite()
+	}),
+	count: z.number().int().min(1).max(100).optional()
+});
+/**
+* Page extract input: the pages to export, in the order they should appear,
+* and `pages.extract()`'s options (`PageExtractOptions`).
+*/
+const PageExtractInputSchema = z.object({
+	pages: z.array(PageRefSchema).min(1),
+	flatten: z.object({ usage: z.enum(["display", "print"]).optional() }).strict().optional(),
+	includeAnnotations: z.boolean().optional(),
+	includeFormFields: z.boolean().optional()
+}).strict();
+/**
+* Page insert result — shared by bytes-insert and blank-insert: the fresh
+* page object numbers in insertion order plus the full new layout (see `PageInsertResult`).
+*/
+const PageInsertResultSchema = z.object({
+	insertedPages: z.array(PageRefSchema),
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/** Page restore result: the pages an undo brought back (see `PageRestoreResult`). */
+const PageRestoreResultSchema = z.object({
+	pages: z.array(PageRefSchema),
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/** See `AttachmentMutationMeta`. */
+const AttachmentMutationMetaSchema = z.object({
+	affectedPages: z.array(PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: z.string(),
+	undoable: z.boolean(),
+	changed: z.array(AttachmentRefSchema)
+});
+const AttachmentCreateResultSchema = z.object({
+	attachment: AttachmentSchema,
+	meta: AttachmentMutationMetaSchema
+});
+const AttachmentRestoreResultSchema = z.object({
+	attachment: AttachmentSchema,
+	meta: AttachmentMutationMetaSchema
+});
+const AttachmentDeleteResultSchema = z.object({ meta: AttachmentMutationMetaSchema });
+/** See `AttachmentList`. */
+const AttachmentListSchema = z.object({ attachments: z.array(AttachmentSchema) });
+/** Embedded files (`doc.attachments`): the models the OpenAPI projection names. */
+const AttachmentWireComponents = {
+	AttachmentRef: AttachmentRefSchema,
+	AttachmentFileInfo: AttachmentFileInfoSchema,
+	Attachment: AttachmentSchema,
+	AttachmentList: AttachmentListSchema,
+	AttachmentFileBase: AttachmentFileBaseSchema,
+	AttachmentMutationMeta: AttachmentMutationMetaSchema
+};
+/**
+* Metadata write result: the re-read `metadata`. On the cloud,
+* `meta.cacheDelta` advances only `docVersion` and `metadataVersion`.
+*/
+const MetadataUpdateResultSchema = z.object({
+	metadata: DocumentMetadataSchema,
+	meta: MutationMetaSchema
+});
+const CustomMetadataUpdateResultSchema = z.object({
+	custom: CustomMetadataSchema,
+	meta: MutationMetaSchema
+});
+/** The meta of every outline write: `MutationMeta` and the items it touched. */
+const OutlineMutationMetaSchema = z.object({
+	affectedPages: z.array(PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: z.string(),
+	undoable: z.boolean(),
+	changed: z.array(OutlineItemRefSchema)
+});
+/** One parent's children as a write left them; `parent: null` is the top level. */
+const OutlineOrderSchema = z.object({
+	parent: OutlineItemRefSchema.nullable(),
+	children: z.array(OutlineItemRefSchema)
+});
+const OutlineCreateResultSchema = z.object({
+	item: OutlineItemSchema,
+	order: OutlineOrderSchema,
+	meta: OutlineMutationMetaSchema
+});
+const OutlineUpdateResultSchema = z.object({
+	item: OutlineItemSchema,
+	meta: OutlineMutationMetaSchema
+});
+const OutlineMoveResultSchema = z.object({
+	orders: z.array(OutlineOrderSchema),
+	meta: OutlineMutationMetaSchema
+});
+const OutlineDeleteResultSchema = z.object({ meta: OutlineMutationMetaSchema });
+const OutlineRestoreResultSchema = z.object({
+	items: z.array(OutlineItemSchema),
+	order: OutlineOrderSchema,
+	meta: OutlineMutationMetaSchema
+});
+/**
+* Stable public component names for the outline wire model, so an OpenAPI
+* projection names each once (`OutlineItem`, not one type per response or op
+* that carries one), like `AnnotationWireComponents`.
+*/
+const OutlineWireComponents = {
+	OutlineItemRef: OutlineItemRefSchema,
+	OutlineItem: OutlineItemSchema,
+	DocumentOutline: DocumentOutlineSchema,
+	OutlineItemDraft: OutlineItemDraftSchema,
+	OutlineItemPatch: OutlineItemPatchSchema,
+	OutlinePosition: OutlinePositionSchema,
+	OutlineOrder: OutlineOrderSchema,
+	OutlineMutationMeta: OutlineMutationMetaSchema
+};
+const Base64Schema = z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/, "base64");
+const DocumentVersionRefSchema = z.object({
+	baseSha256: z.string().regex(/^[0-9a-f]{64}$/),
+	editsVersion: z.number().int().nonnegative()
+});
+const ByteRangeSchema = z.tuple([
+	z.number().int().nonnegative(),
+	z.number().int().nonnegative(),
+	z.number().int().nonnegative(),
+	z.number().int().nonnegative()
+]);
+/** `SignaturePrepared` with the digest as base64. */
+const SignaturePreparedWireSchema = z.object({
+	signingId: z.string().min(1),
+	digest: Base64Schema,
+	algorithm: z.enum([
+		"sha256",
+		"sha384",
+		"sha512"
+	]),
+	byteRange: ByteRangeSchema,
+	contentsSize: z.number().int().positive(),
+	subFilter: z.string(),
+	expectedVersion: DocumentVersionRefSchema,
+	expiresAt: z.string().nullable()
+});
+function encodePrepared(prepared) {
+	return {
+		...prepared,
+		digest: toBase64(prepared.digest)
+	};
+}
+function decodePrepared(wire) {
+	return {
+		...wire,
+		digest: fromBase64(wire.digest),
+		subFilter: wire.subFilter
+	};
+}
+/** The JSON body of a completion: the CMS as base64 beside the fence. */
+const SignatureCompleteBodySchema = z.object({
+	cms: Base64Schema.refine((v) => v.length > 0, "cms is required"),
+	expectedVersion: DocumentVersionRefSchema
+});
+const DocMdpPermissionSchema = z.union([
+	z.literal(1),
+	z.literal(2),
+	z.literal(3)
+]);
+const ModificationLevelSchema = z.enum([
+	"none",
+	"lta",
+	"fill",
+	"annotate"
+]);
+const DigestAlgorithmSchema = z.enum([
+	"sha1",
+	"sha256",
+	"sha384",
+	"sha512"
+]);
+const FieldLockSpecSchema = z.object({
+	action: z.enum([
+		"all",
+		"include",
+		"exclude"
+	]),
+	fields: z.array(z.string()),
+	permission: DocMdpPermissionSchema.optional()
+});
+const SignatureSeedValueSchema = z.object({
+	requiredFlags: z.number().int(),
+	presentFlags: z.number().int(),
+	version: z.number().int().nullable(),
+	mdp: z.union([
+		z.literal(0),
+		z.literal(1),
+		z.literal(2),
+		z.literal(3)
+	]).nullable(),
+	filter: z.string().nullable(),
+	subFilters: z.array(z.string()),
+	digestMethods: z.array(z.string()),
+	reasons: z.array(z.string()),
+	unsupportedRequired: z.boolean()
+});
+const SignatureDTOSchema = z.object({
+	index: z.number().int().nonnegative(),
+	field: FormFieldRefSchema,
+	fieldName: z.string(),
+	widget: FormFieldWidgetSchema.nullable(),
+	signed: z.boolean(),
+	kind: z.enum(["signature", "timestamp"]),
+	filter: z.string().nullable(),
+	subFilter: z.string().nullable(),
+	byteRange: ByteRangeSchema.nullable(),
+	contentsSize: z.number().int().nonnegative(),
+	coverage: z.enum([
+		"whole-revision",
+		"partial",
+		"malformed"
+	]).nullable(),
+	revisionIndex: z.number().int().nonnegative().nullable(),
+	signer: z.object({
+		name: z.string().nullable(),
+		reason: z.string().nullable(),
+		location: z.string().nullable(),
+		contactInfo: z.string().nullable(),
+		signedAt: IsoDateTimeSchema.nullable()
+	}),
+	docMdp: DocMdpPermissionSchema.nullable(),
+	catalogCertification: z.boolean(),
+	fieldMdp: FieldLockSpecSchema.nullable(),
+	lock: FieldLockSpecSchema.nullable(),
+	seedValue: SignatureSeedValueSchema.nullable()
+});
+const DocumentProtectionSchema = z.object({
+	enforced: ModificationLevelSchema.nullable(),
+	judged: ModificationLevelSchema.nullable(),
+	certification: z.object({
+		signatureIndex: z.number().int().nonnegative(),
+		permission: DocMdpPermissionSchema
+	}).nullable(),
+	fieldLocks: z.array(z.object({
+		signatureIndex: z.number().int().nonnegative(),
+		source: z.enum(["fieldmdp", "lock"]),
+		spec: FieldLockSpecSchema
+	})),
+	policyVersion: z.number().int()
+});
+const PdfRevisionSchema = z.object({
+	index: z.number().int().nonnegative(),
+	end: z.number().int().nonnegative(),
+	xrefOffset: z.number().int().nonnegative(),
+	signatureIndex: z.number().int().nonnegative().nullable()
+});
+const SignatureSnapshotSchema = z.object({
+	chainValid: z.boolean(),
+	revisions: z.array(PdfRevisionSchema),
+	signatures: z.array(SignatureDTOSchema),
+	protection: DocumentProtectionSchema
+});
+const BaseVersionInfoSchema = z.object({
+	sha256: z.string().regex(/^[0-9a-f]{64}$/),
+	byteLength: z.number().int().nonnegative()
+});
+const SignatureCompleteResultSchema = z.object({
+	status: z.enum(["completed", "already-completed"]),
+	signature: SignatureDTOSchema,
+	version: BaseVersionInfoSchema,
+	previous: DocumentVersionRefSchema,
+	protection: DocumentProtectionSchema,
+	meta: MutationMetaSchema
+});
+const SignatureCancelResultSchema = z.object({ status: z.enum([
+	"cancelled",
+	"already-completed",
+	"unknown"
+]) });
+const ChangeFindingSchema = z.object({
+	rule: z.string(),
+	verdict: z.enum([
+		"permitted",
+		"forbidden",
+		"incomplete"
+	]),
+	objectNumber: z.number().int().nonnegative(),
+	edge: z.string().optional(),
+	detail: z.string().optional()
+});
+const AnalysisDetailSchema = z.enum(["summary", "full"]);
+/** The analysis: one verdict (`current`) with its findings, the restrictions it was judged under, and facts about the revisions in between. */
+const ChangeAnalysisSchema = z.object({
+	mode: z.enum(["authoritative", "exploratory"]),
+	policyVersion: z.number().int(),
+	basis: z.object({
+		version: BaseVersionInfoSchema,
+		editsVersion: z.number().int().nonnegative(),
+		source: z.enum(["persisted", "working-copy"])
+	}),
+	since: z.object({
+		revisionIndex: z.number().int().nonnegative(),
+		signatureIndex: z.number().int().nonnegative().nullable()
+	}),
+	until: z.object({ revisionIndex: z.number().int().nonnegative() }),
+	restrictions: z.array(z.object({
+		signatureIndex: z.number().int().nonnegative(),
+		revisionIndex: z.number().int().nonnegative(),
+		source: z.enum([
+			"docmdp",
+			"fieldmdp",
+			"lock"
+		]),
+		own: z.boolean(),
+		permission: z.union([
+			z.literal(1),
+			z.literal(2),
+			z.literal(3)
+		]).optional(),
+		fields: z.unknown().optional()
+	})),
+	current: z.object({
+		verdict: z.enum([
+			"unchanged",
+			"permitted",
+			"forbidden",
+			"indeterminate"
+		]),
+		complete: z.boolean(),
+		primary: ChangeFindingSchema.optional(),
+		findings: z.array(ChangeFindingSchema),
+		method: z.enum(["net-state", "net-state+replay"])
+	}),
+	later: z.object({
+		revisionCount: z.number().int().nonnegative(),
+		undoneObjectNumbers: z.array(z.number().int().nonnegative())
+	}),
+	/** Equals `current.verdict`. */
+	verdict: z.enum([
+		"unchanged",
+		"permitted",
+		"forbidden",
+		"indeterminate"
+	]),
+	/** The step DTOs are large and evolving; carried verbatim. */
+	steps: z.array(z.unknown())
+});
+const SignatureSignerInputSchema = z.object({
+	name: z.string().optional(),
+	reason: z.string().optional(),
+	location: z.string().optional(),
+	contactInfo: z.string().optional(),
+	signedAt: IsoDateTimeSchema.optional()
+});
+/** The `body` part of a visual signature fill: which part holds the one-page PDF. */
+const SignatureAppearanceBodySchema = z.object({ resources: AppearanceResourceKeysSchema });
+/**
+* The `body` part of a prepare: `SignaturePrepareInput` with the
+* appearance artwork named by the key of its part instead of inline bytes.
+*/
+const SignaturePrepareBodySchema = z.object({
+	field: FormFieldRefSchema,
+	kind: z.enum(["signature", "timestamp"]).optional(),
+	subFilter: z.enum(["adbe.pkcs7.detached", "ETSI.CAdES.detached"]).optional(),
+	digest: z.enum([
+		"sha256",
+		"sha384",
+		"sha512"
+	]).optional(),
+	contentsSize: z.number().int().positive().optional(),
+	signer: SignatureSignerInputSchema.optional(),
+	certify: z.object({ permission: DocMdpPermissionSchema }).optional(),
+	lock: FieldLockSpecSchema.optional(),
+	resources: AppearanceResourceKeysSchema.optional()
+});
+const optionalIndex = z.coerce.number().int().nonnegative().optional();
+/** Layer analysis query (the current form): exactly one `since.*`; the working copy is the end. */
+const LayerAnalysisQuerySchema = z.object({
+	"since.signature": optionalIndex,
+	"since.revision": optionalIndex,
+	level: ModificationLevelSchema.optional(),
+	detail: AnalysisDetailSchema.optional()
+}).refine((q) => q["since.signature"] === void 0 !== (q["since.revision"] === void 0), { message: "exactly one of since.signature / since.revision is required" });
+/** Version analysis query: as the layer's, plus `until` (a revision index; default the last). */
+const VersionAnalysisQuerySchema = z.object({
+	"since.signature": optionalIndex,
+	"since.revision": optionalIndex,
+	until: optionalIndex,
+	level: ModificationLevelSchema.optional(),
+	detail: AnalysisDetailSchema.optional(),
+	/** The judging policy version the caller expects — a cache key, not an input (version responses are immutable). */
+	policy: optionalIndex
+}).refine((q) => q["since.signature"] === void 0 !== (q["since.revision"] === void 0), { message: "exactly one of since.signature / since.revision is required" });
+function analyzeInputFromQuery(query, until) {
+	return {
+		since: query["since.signature"] !== void 0 ? { signatureIndex: query["since.signature"] } : { revisionIndex: query["since.revision"] ?? 0 },
+		...until !== void 0 ? { until } : {},
+		...query.level !== void 0 ? { exploratoryLevel: query.level } : {},
+		...query.detail !== void 0 ? { detail: query.detail } : {}
+	};
+}
+/** One row of the document's version catalog. */
+const DocumentVersionSchema = z.object({
+	sha256: z.string().regex(/^[0-9a-f]{64}$/),
+	byteLength: z.number().int().nonnegative(),
+	number: z.number().int().positive(),
+	parentSha256: z.string().nullable(),
+	producer: z.enum(["upload", "signature"]),
+	signingId: z.string().nullable(),
+	createdAt: z.number().int()
+});
+const DocumentVersionsSchema = z.object({
+	/** `documents.base_sha`: the version every layer is over, or behind. */
+	head: z.string().regex(/^[0-9a-f]{64}$/),
+	/** Oldest first. */
+	versions: z.array(DocumentVersionSchema)
+});
+const PageScaleResultSchema = z.object({
+	page: PageRefSchema,
+	meta: MutationMetaSchema
+});
+//#endregion
+export { FormCalculationsReorderBodySchema as $, PageInsertBlankSpecSchema as $t, BundleLimitsSchema as A, SignaturePreparedWireSchema as An, MetadataUpdateResultSchema as At, DocumentManifestSchema as B, OutlineItemDraftSchema as Bn, OutlineMoveResultSchema as Bt, AttachmentCreateResultSchema as C, SearchSnippetSchema as Cn, FormWidgetsReorderResultSchema as Ct, AttachmentRestoreResultSchema as D, SignatureCompleteResultSchema as Dn, LayerScopesSchema as Dt, AttachmentMutationMetaSchema as E, SignatureCompleteBodySchema as En, LayerAnalysisQuerySchema as Et, CustomMetadataPatchSchema as F, analyzeInputFromQuery as Fn, ObjectNumberReservationRequestSchema as Ft, DocumentVersionSchema as G, PAGE_PRINT_FAMILIES as Gn, OutlineUpdateResultSchema as Gt, DocumentProtectionSchema as H, OutlineItemSchema as Hn, OutlineOrderSchema as Ht, CustomMetadataSchema as I, decodePrepared as In, ObjectNumberReservationResponseSchema as It, EditSessionAccessSchema as J, pagePictureOf as Jn, PageDeleteResultSchema as Jt, DocumentVersionsSchema as K, PAGE_PRINT_TIERS as Kn, OutlineWireComponents as Kt, CustomMetadataUpdateResultSchema as L, encodePrepared as Ln, OpenDocumentResponseSchema as Lt, CacheDeltaSchema as M, SignatureSnapshotSchema as Mn, MutationMetaSchema as Mt, CachePinsSchema as N, VersionAnalysisQuerySchema as Nn, NamedPageEntrySchema as Nt, AttachmentWireComponents as O, SignatureDTOSchema as On, ManifestPageSchema as Ot, ChangeAnalysisSchema as P, WidgetAppearancesQuerySchema as Pn, ObjectNumberRangeSchema as Pt, FieldPositionSchema as Q, PageGeometrySnapshotSchema as Qt, DigestAlgorithmSchema as R, pagePictureQuerySchema as Rn, OutlineCreateResultSchema as Rt, AppearanceOutcomeSchema as S, SearchSliceSchema as Sn, FormWidgetsReorderBodySchema as St, AttachmentListSchema as T, SignatureCancelResultSchema as Tn, IdentitySchema as Tt, DocumentSecurityStateSchema as U, OutlineItemRefSchema as Un, OutlinePositionSchema as Ut, DocumentMetadataSchema as V, OutlineItemPatchSchema as Vn, OutlineMutationMetaSchema as Vt, DocumentVersionRefSchema as W, PAGE_PICTURES as Wn, OutlineRestoreResultSchema as Wt, EngineErrorPayloadSchema as X, pageRenderFamilyOf as Xn, PageFlattenInputSchema as Xt, EditSessionStatusSchema as Y, pagePrintTierOf as Yn, PageExtractInputSchema as Yt, FieldLockSpecSchema as Z, PageFlattenResultSchema as Zt, AnnotationReorderBodySchema as _, RedactionApplyResultSchema as _n, FormWidgetDeleteResultSchema as _t, AnnotationAppearancesQuerySchema as a, PageNetworkRenderFormatSchema as an, FormFieldUpdateResultSchema as at, AnnotationWireComponents as b, SearchQuerySchema as bn, FormWidgetUpdateBodySchema as bt, AnnotationExportSelectionSchema as c, PageRemoveNameInputSchema as cn, FormImportResultSchema as ct, AnnotationImportBodySchema as d, PageRestoreResultSchema as dn, FormResetBodySchema as dt, PageInsertResultSchema as en, FormCalculationsReorderResultSchema as et, AnnotationImportOptionsSchema as f, PageRotateResultSchema as fn, FormResetResultSchema as ft, AnnotationPositionSchema as g, PdfSaveModeSchema as gn, FormValuesImportResultSchema as gt, AnnotationListSchema as h, PdfRevisionSchema as hn, FormValuesImportOptionsSchema as ht, AnnotationAppearanceExportInputSchema as i, PageNameResultSchema as in, FormFieldDeleteResultSchema as it, ByteRangeSchema as j, SignatureSeedValueSchema as jn, ModificationLevelSchema as jt, BaseVersionInfoSchema as k, SignaturePrepareBodySchema as kn, MetadataPatchSchema as kt, AnnotationFlattenInputSchema as l, PageRenderQuerySchemas as ln, FormMutationMetaSchema as lt, AnnotationListMutationMetaSchema as m, PageTextSnapshotSchema as mn, FormValuesImportBodySchema as mt, AccessResponseSchema as n, PageListSnapshotSchema as nn, FormExportSelectionSchema as nt, AnnotationCreateResultSchema as o, PagePositionSchema as on, FormImportBodySchema as ot, AnnotationImportResultSchema as p, PageScaleResultSchema as pn, FormSetValueResultSchema as pt, DocumentWireComponents as q, PAGE_RENDER_FAMILIES as qn, PageBoxesSchema as qt, AnnotationAppearanceBatchSchema as r, PageNameInputSchema as rn, FormFieldCreateResultSchema as rt, AnnotationDeleteResultSchema as s, PagePrintQuerySchemas as sn, FormImportOptionsSchema as st, AccessRequestSchema as t, PageLayoutSchema as tn, FormExportRequestSchema as tt, AnnotationFlattenResultSchema as u, PageReorderResultSchema as un, FormRepairResultSchema as ut, AnnotationReorderResultSchema as v, RedactionApplyScopeSchema as vn, FormWidgetLinkResultSchema as vt, AttachmentDeleteResultSchema as w, SignatureAppearanceBodySchema as wn, FormWireComponents as wt, AnnotationsExportRequestSchema as x, SearchRequestSchema as xn, FormWidgetUpdateResultSchema as xt, AnnotationUpdateResultSchema as y, SearchMatchSchema as yn, FormWidgetRestoreResultSchema as yt, DocumentHeadSchema as z, DocumentOutlineSchema as zn, OutlineDeleteResultSchema as zt };
+
+//# sourceMappingURL=schemas-BE2QGOit.js.map