@embedpdf/engine-core 3.0.0-next.13 → 3.0.0-next.15

package/dist/schemas-Berf1swF.cjs

@@ -0,0 +1,2481 @@
+const require_format = require("./format-Bp3QFSH1.cjs");
+const require_charmap = require("./charmap-aYlefQP9.cjs");
+require("./PageInsertBlankInput-CXHAM7l6.cjs");
+const require_schema = require("./schema-C-gU4vj7.cjs");
+let zod = require("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"]
+	},
+	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"]
+	},
+	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"]
+	},
+	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"
+		]
+	}
+};
+/** The family of a picture that draws `layers`. */
+function pageRenderFamilyOf(layers) {
+	if (layers.includeAnnotations) return layers.includeFormFields ? "all" : "annotations";
+	return layers.includeFormFields ? "fields" : "pages";
+}
+//#endregion
+//#region src/wire/schemas.ts
+/** Who a session acts for; see `Identity` in `auth/scope/types.ts`. */
+const IdentitySchema = zod.z.object({
+	userId: zod.z.string().min(1).max(256).optional(),
+	displayName: zod.z.string().min(1).max(256).optional(),
+	email: zod.z.string().min(1).max(256).optional(),
+	title: zod.z.string().min(1).max(256).optional(),
+	organization: zod.z.string().min(1).max(256).optional(),
+	organizationalUnit: zod.z.string().min(1).max(256).optional(),
+	groupId: zod.z.string().min(1).max(256).optional()
+}).strict();
+const DocumentMetadataSchema = zod.z.object({
+	title: zod.z.string().nullable(),
+	author: zod.z.string().nullable(),
+	subject: zod.z.string().nullable(),
+	keywords: zod.z.string().nullable(),
+	producer: zod.z.string().nullable(),
+	creator: zod.z.string().nullable(),
+	createdAt: require_schema.IsoDateTimeSchema.nullable(),
+	modifiedAt: require_schema.IsoDateTimeSchema.nullable(),
+	trapped: zod.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 = zod.z.object({
+	title: zod.z.string().nullable().optional(),
+	author: zod.z.string().nullable().optional(),
+	subject: zod.z.string().nullable().optional(),
+	keywords: zod.z.string().nullable().optional(),
+	producer: zod.z.string().nullable().optional(),
+	creator: zod.z.string().nullable().optional(),
+	createdAt: require_schema.DateInputSchema.nullable().optional(),
+	modifiedAt: require_schema.DateInputSchema.nullable().optional(),
+	trapped: zod.z.enum([
+		"true",
+		"false",
+		"unknown"
+	]).optional()
+}).strict();
+/** The Info dict's other keys, `{ key: value }`. */
+const CustomMetadataSchema = zod.z.record(zod.z.string(), zod.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 = zod.z.record(zod.z.string(), zod.z.string().nullable());
+const OpenDocumentResponseSchema = zod.z.object({ id: zod.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 = zod.z.object({
+	id: zod.z.string(),
+	baseSha: zod.z.string(),
+	storageSizeBytes: zod.z.number().int().nonnegative(),
+	docVersion: zod.z.number().int().positive(),
+	state: zod.z.enum([
+		"pending",
+		"ready",
+		"failed",
+		"deleting"
+	]),
+	encryption: zod.z.object({
+		state: zod.z.enum([
+			"unknown",
+			"none",
+			"encrypted",
+			"unsupported"
+		]),
+		requiresPassword: zod.z.boolean().nullable()
+	}),
+	permissions: zod.z.object({
+		known: zod.z.boolean(),
+		bits: zod.z.number().int().nonnegative().nullable(),
+		allAllowed: zod.z.boolean().nullable(),
+		openedAs: zod.z.enum([
+			"none",
+			"user",
+			"owner"
+		]).nullable(),
+		securityHandlerRevision: zod.z.number().int().nullable(),
+		canUpgradeToOwner: zod.z.boolean()
+	}),
+	access: zod.z.object({
+		required: zod.z.boolean(),
+		reasons: zod.z.array(zod.z.enum([
+			"password",
+			"cdn",
+			"permissions-unknown"
+		])),
+		endpoint: zod.z.string().optional()
+	})
+});
+const AccessRequestSchema = zod.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: zod.z.string().min(1).optional(),
+	layerName: zod.z.string().min(1).optional(),
+	password: zod.z.string().optional(),
+	passwordGrant: zod.z.string().optional(),
+	mode: zod.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: zod.z.number().int().nonnegative().optional()
+});
+/** `first`, `first + 1`, …, `first + count - 1`. */
+const ObjectNumberRangeSchema = zod.z.object({
+	first: zod.z.number().int().positive(),
+	count: zod.z.number().int().positive()
+});
+/** See `EditSessionAccess`. */
+const EditSessionAccessSchema = zod.z.object({
+	session: zod.z.enum([
+		"new",
+		"revived",
+		"live"
+	]),
+	expiresIn: zod.z.number().int().nonnegative(),
+	objectNumbers: zod.z.array(ObjectNumberRangeSchema)
+});
+/** See `EditSessionStatus`: the event stream's `session` event. */
+const EditSessionStatusSchema = zod.z.object({
+	held: zod.z.array(ObjectNumberRangeSchema),
+	expiresIn: zod.z.number().int().nonnegative()
+});
+/** `POST …/object-numbers`: a bulk reservation. */
+const ObjectNumberReservationRequestSchema = zod.z.object({ count: zod.z.number().int().positive() });
+const ObjectNumberReservationResponseSchema = zod.z.object({
+	objectNumbers: zod.z.array(ObjectNumberRangeSchema),
+	expiresIn: zod.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 = zod.z.object({
+	bit3: zod.z.boolean(),
+	bit4: zod.z.boolean(),
+	bit5: zod.z.boolean(),
+	bit6: zod.z.boolean(),
+	bit9: zod.z.boolean(),
+	bit10: zod.z.boolean(),
+	bit11: zod.z.boolean(),
+	bit12: zod.z.boolean()
+});
+/**
+* Capability-shaped advisory for the client UI. Mirrors
+* `PdfPermissionAdvisory` in @embedpdf/engine-core/runtime; one
+* boolean per UI badge.
+*/
+const PdfPermissionAdvisoryObjectSchema = zod.z.object({
+	canPrint: zod.z.boolean(),
+	canPrintHigh: zod.z.boolean(),
+	canCopy: zod.z.boolean(),
+	canAnnotate: zod.z.boolean(),
+	canFillForms: zod.z.boolean(),
+	canModifyForms: zod.z.boolean(),
+	canModifyPages: zod.z.boolean(),
+	canAssemble: zod.z.boolean()
+});
+const PdfPermissionInfoSchema = zod.z.object({
+	known: zod.z.boolean(),
+	allAllowed: zod.z.boolean().nullable(),
+	bits: zod.z.number().int().nonnegative().nullable(),
+	openedAs: zod.z.enum([
+		"none",
+		"user",
+		"owner"
+	]).nullable(),
+	securityHandlerRevision: zod.z.number().int().nullable(),
+	flags: PdfBitsObjectSchema.optional(),
+	advisory: PdfPermissionAdvisoryObjectSchema.optional()
+}).nullable();
+const DocumentSecurityStateSchema = zod.z.object({
+	encryption: zod.z.object({
+		state: zod.z.enum([
+			"unknown",
+			"none",
+			"encrypted",
+			"unsupported"
+		]),
+		requiresPassword: zod.z.boolean().nullable()
+	}),
+	permissions: zod.z.object({
+		known: zod.z.boolean(),
+		bits: zod.z.number().int().nonnegative().nullable(),
+		allAllowed: zod.z.boolean().nullable(),
+		openedAs: zod.z.enum([
+			"none",
+			"user",
+			"owner"
+		]).nullable(),
+		securityHandlerRevision: zod.z.number().int().nullable(),
+		canUpgradeToOwner: zod.z.boolean()
+	}),
+	access: zod.z.object({
+		required: zod.z.boolean(),
+		reasons: zod.z.array(zod.z.enum([
+			"password",
+			"cdn",
+			"permissions-unknown"
+		])),
+		endpoint: zod.z.string().optional()
+	})
+});
+const positiveCount = zod.z.number().int().positive();
+/** See `BundleLimits`. */
+const BundleLimitsSchema = zod.z.object({
+	bundleBytes: positiveCount,
+	manifestBytes: positiveCount,
+	items: positiveCount,
+	pages: positiveCount,
+	resources: positiveCount,
+	resourceBytes: positiveCount,
+	imagePixels: positiveCount
+}).strict();
+const AccessResponseSchema = zod.z.object({
+	security: DocumentSecurityStateSchema,
+	cdn: zod.z.object({
+		adapter: zod.z.enum([
+			"none",
+			"cloudfront",
+			"cloud-cdn",
+			"bunny",
+			"azure-fd",
+			"custom-hmac"
+		]),
+		expiresAt: zod.z.number().int().positive(),
+		cache: zod.z.object({
+			scope: zod.z.enum(["browser-private", "edge-shared"]),
+			immutableVersionedReads: zod.z.boolean()
+		}),
+		baseUrlOverrides: zod.z.record(zod.z.string(), zod.z.string()).nullable(),
+		authHeader: zod.z.object({
+			name: zod.z.string(),
+			value: zod.z.string()
+		}).nullable(),
+		signedQueryParams: zod.z.record(zod.z.string(), zod.z.string()).nullable(),
+		signedCookies: zod.z.array(zod.z.object({
+			name: zod.z.string(),
+			value: zod.z.string(),
+			domain: zod.z.string().optional(),
+			path: zod.z.string().optional(),
+			expires: zod.z.number().int().optional()
+		})).nullable(),
+		signedPathPolicies: zod.z.array(zod.z.object({
+			pathPrefix: zod.z.string(),
+			queryParams: zod.z.record(zod.z.string(), zod.z.string())
+		})).nullable()
+	}),
+	passwordGrant: zod.z.string().nullable(),
+	pdfPermissions: PdfPermissionInfoSchema,
+	scope: zod.z.array(zod.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: zod.z.array(zod.z.string()),
+	/** What the document's signatures forbid; `effectiveScope` already leaves it out. */
+	protection: zod.z.lazy(() => DocumentProtectionSchema).nullable(),
+	identity: IdentitySchema,
+	originPasswordPolicy: zod.z.object({ mode: zod.z.enum([
+		"not-needed",
+		"client-retry",
+		"server-session"
+	]) }),
+	expiresAt: zod.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: zod.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: zod.z.object({ widths: zod.z.array(zod.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: zod.z.object({
+			tileSizes: zod.z.array(zod.z.number().int().positive()),
+			scales: zod.z.array(zod.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: zod.z.object({ scales: zod.z.array(zod.z.number().positive()) }).optional(),
+		/** Worker-side output budget for degenerate page geometry. */
+		maxRenderPixels: zod.z.number().int().positive().optional(),
+		formats: zod.z.array(zod.z.enum(["webp", "png"])),
+		background: zod.z.enum(["white"]),
+		enforced: zod.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 = zod.z.enum(["incremental", "rewrite"]);
+const engineErrorCodeValues = Object.values(require_format.EngineErrorCode);
+const EngineErrorPayloadSchema = zod.z.object({
+	name: zod.z.literal("EngineError"),
+	code: zod.z.enum(engineErrorCodeValues),
+	message: zod.z.string(),
+	details: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+const CachePinsSchema = zod.z.object({
+	contentVersion: zod.z.number().int().positive(),
+	annotationVersion: zod.z.number().int().positive(),
+	widgetVersion: zod.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 = zod.z.enum(["base", "layer"]);
+const LayerScopesSchema = zod.z.object({
+	content: LayerScopeValueSchema,
+	annotations: LayerScopeValueSchema,
+	forms: LayerScopeValueSchema,
+	layout: LayerScopeValueSchema,
+	attachments: LayerScopeValueSchema,
+	metadata: LayerScopeValueSchema,
+	actions: 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 = zod.z.object({
+	page: require_schema.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 = zod.z.object({
+	docVersion: zod.z.number().int().positive(),
+	layoutVersion: zod.z.number().int().positive(),
+	metadataVersion: zod.z.number().int().positive(),
+	actionsVersion: zod.z.number().int().positive().default(1),
+	attachmentsVersion: zod.z.number().int().positive().default(1),
+	annotationsVersion: zod.z.number().int().positive().default(1),
+	formsVersion: zod.z.number().int().positive().default(1),
+	auditHead: zod.z.number().int().nonnegative(),
+	baseSha: zod.z.string(),
+	layerVersion: zod.z.number().int().nonnegative().default(0),
+	working: zod.z.boolean().default(false),
+	baseByteLength: zod.z.number().int().nonnegative().default(0),
+	scopes: LayerScopesSchema.optional(),
+	protection: zod.z.lazy(() => DocumentProtectionSchema).nullable(),
+	pages: zod.z.array(ManifestPageSchema)
+});
+/** What both engines' `annotations.list()` return, and the server's list endpoints send. */
+const AnnotationListSchema = zod.z.object({
+	annotations: zod.z.array(require_schema.AnnotationSchema),
+	pages: zod.z.array(require_schema.PageRefSchema),
+	auditHead: zod.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 = zod.z.object({
+	text: zod.z.string(),
+	charCount: zod.z.number().int().nonnegative(),
+	charMap: zod.z.array(zod.z.tuple([zod.z.number().int().nonnegative(), zod.z.number().int().nonnegative()])).optional()
+}).superRefine((snapshot, ctx) => {
+	const violation = require_charmap.charMapViolation(snapshot.charCount, snapshot.text.length, snapshot.charMap);
+	if (violation !== null) ctx.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["charMap"],
+		message: violation
+	});
+});
+const PageGeometryGlyphSchema = zod.z.object({
+	loose: require_schema.PageBoxSchema,
+	tight: require_schema.PageBoxSchema.optional(),
+	space: zod.z.literal(true).optional(),
+	empty: zod.z.literal(true).optional()
+});
+const RotatedGeometryGlyphSchema = zod.z.object({
+	loose: require_schema.PageQuadSchema,
+	tight: require_schema.PageQuadSchema.optional(),
+	space: zod.z.literal(true).optional(),
+	empty: zod.z.literal(true).optional()
+});
+const UprightGeometryRunSchema = zod.z.object({
+	rect: require_schema.PageBoxSchema,
+	start: zod.z.number().int().nonnegative(),
+	glyphs: zod.z.array(PageGeometryGlyphSchema),
+	fontSize: zod.z.number().optional()
+});
+const RotatedGeometryRunSchema = zod.z.object({
+	rect: require_schema.PageBoxSchema,
+	start: zod.z.number().int().nonnegative(),
+	glyphs: zod.z.array(RotatedGeometryGlyphSchema),
+	rotation: zod.z.number(),
+	ascentFlip: zod.z.boolean(),
+	fontSize: zod.z.number().optional()
+});
+const PageGeometryRunSchema = zod.z.union([RotatedGeometryRunSchema, UprightGeometryRunSchema]);
+const PageGeometrySnapshotSchema = zod.z.object({ runs: zod.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 = zod.z.object({
+	text: zod.z.string(),
+	regex: zod.z.boolean().optional(),
+	matchCase: zod.z.boolean().optional(),
+	wholeWord: zod.z.boolean().optional(),
+	matchDiacritics: zod.z.boolean().optional(),
+	ignoreWhitespace: zod.z.boolean().optional()
+});
+const SearchQuerySchema = searchQueryObject;
+const SearchRequestSchema = searchQueryObject.extend({
+	snippets: zod.z.boolean().optional(),
+	from: require_schema.PageRefSchema.optional(),
+	cursor: zod.z.string().optional(),
+	limit: zod.z.object({
+		matches: zod.z.number().int().positive().optional(),
+		pages: zod.z.number().int().positive().optional()
+	}).optional()
+});
+const SearchSnippetSchema = zod.z.object({
+	before: zod.z.string(),
+	match: zod.z.string(),
+	after: zod.z.string()
+});
+const PdfTextSegmentSchema = zod.z.object({
+	quad: require_schema.PageQuadSchema,
+	rect: require_schema.PageBoxSchema,
+	advance: zod.z.union([zod.z.literal(1), zod.z.literal(-1)])
+});
+const SearchMatchSchema = zod.z.object({
+	page: require_schema.PageRefSchema,
+	start: zod.z.number().int().nonnegative(),
+	count: zod.z.number().int().positive(),
+	segments: zod.z.array(PdfTextSegmentSchema),
+	snippet: SearchSnippetSchema.optional()
+});
+const SearchSliceSchema = zod.z.object({
+	matches: zod.z.array(SearchMatchSchema),
+	nextCursor: zod.z.string().nullable(),
+	pagesSearched: zod.z.number().int().nonnegative(),
+	pageCount: zod.z.number().int().nonnegative()
+});
+const PageNetworkRenderFormatSchema = zod.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 = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("width"),
+	width: zod.z.coerce.number().positive().finite()
+}).strict(), zod.z.object({
+	kind: zod.z.literal("scale"),
+	scale: zod.z.coerce.number().positive().finite().optional()
+}).strict()]);
+const RenderTargetSchema = zod.z.discriminatedUnion("kind", [zod.z.object({ kind: zod.z.literal("page") }).strict(), zod.z.object({
+	kind: zod.z.literal("rect"),
+	rect: zod.z.object({
+		x: zod.z.coerce.number().finite(),
+		y: zod.z.coerce.number().finite(),
+		width: zod.z.coerce.number().positive().finite(),
+		height: zod.z.coerce.number().positive().finite()
+	}).strict()
+}).strict()]);
+const RenderRotationSchema = zod.z.preprocess((raw) => raw === void 0 ? void 0 : Number(raw), zod.z.number().refine((n) => n === 0 || n === 90 || n === 180 || n === 270, { message: "render rotation must be 0, 90, 180, or 270" }));
+const RenderBackgroundSchema = zod.z.enum(["white", "transparent"]);
+/** WebP quality, 0 (smallest) to 1 (best) — the `canvas.toBlob` scale. */
+const RenderQualitySchema = zod.z.coerce.number().min(0).max(1);
+const AppearanceModeSchema = zod.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 = zod.z.string().transform((value, ctx) => {
+	const modes = value.split("-");
+	const canonical = require_charmap.ANNOTATION_APPEARANCE_MODES.filter((mode) => modes.includes(mode));
+	if (canonical.length === 0 || canonical.length === require_charmap.ANNOTATION_APPEARANCE_MODES.length || canonical.join("-") !== value) {
+		ctx.addIssue({
+			code: zod.z.ZodIssueCode.custom,
+			message: "modes must name some but not all of normal, rollover, down, in that order, joined by -"
+		});
+		return zod.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.
+*
+* The transform stamps what the family draws onto the parsed options, so
+* the worker options downstream need no family.
+*/
+function buildPageRenderQuerySchema(family) {
+	const { draws, pins } = PAGE_RENDER_FAMILIES[family];
+	const pinFields = {};
+	for (const pin of pins) pinFields[pin] = zod.z.coerce.number().int().positive().optional();
+	return zod.z.object({
+		...pinFields,
+		format: PageNetworkRenderFormatSchema.optional(),
+		viewport: RenderViewportSchema.optional(),
+		target: RenderTargetSchema.optional(),
+		rotation: RenderRotationSchema.optional(),
+		background: RenderBackgroundSchema.optional(),
+		quality: RenderQualitySchema.optional()
+	}).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: zod.z.ZodIssueCode.custom,
+					path: [pin],
+					message: `${pin} requires contentVersion`
+				});
+			}
+			return;
+		}
+		if (v.format === void 0) ctx.addIssue({
+			code: zod.z.ZodIssueCode.custom,
+			path: ["format"],
+			message: "versioned render requires format"
+		});
+		for (const pin of pins) {
+			if (pinned[pin] !== void 0) continue;
+			ctx.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				path: [pin],
+				message: `a versioned ${family} picture requires ${pin}`
+			});
+		}
+	}).transform((v) => {
+		const pinned = v;
+		const query = { options: {
+			...v.target ? { target: v.target } : {},
+			...v.viewport ? { viewport: v.viewport } : {},
+			...v.rotation !== void 0 ? { rotation: v.rotation } : {},
+			...v.background !== void 0 ? { background: v.background } : {},
+			...v.quality !== void 0 ? { quality: v.quality } : {},
+			...v.format !== void 0 ? { format: v.format } : {},
+			...draws
+		} };
+		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("pages"),
+	annotations: buildPageRenderQuerySchema("annotations"),
+	fields: buildPageRenderQuerySchema("fields"),
+	all: buildPageRenderQuerySchema("all")
+};
+/**
+* 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 zod.z.object({
+		[pin]: zod.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: zod.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 = zod.z.object({
+	page: require_schema.PageRefSchema,
+	appearances: zod.z.array(zod.z.object({
+		resources: require_schema.ImageResourceKeysSchema,
+		ref: require_schema.AnnotationRefSchema,
+		mode: AppearanceModeSchema,
+		state: zod.z.string().nullable(),
+		rect: require_schema.PageBoxSchema,
+		width: zod.z.number().int().positive(),
+		height: zod.z.number().int().positive(),
+		format: PageNetworkRenderFormatSchema,
+		contentType: zod.z.string().min(1)
+	}))
+});
+const CacheDeltaSchema = zod.z.object({
+	previousDocVersion: zod.z.number().int().nonnegative(),
+	docVersion: zod.z.number().int().positive(),
+	annotationsVersion: zod.z.number().int().positive().optional(),
+	formsVersion: zod.z.number().int().positive().optional(),
+	layoutVersion: zod.z.number().int().positive().optional(),
+	metadataVersion: zod.z.number().int().positive().optional(),
+	attachmentsVersion: zod.z.number().int().positive().optional(),
+	layerVersion: zod.z.number().int().nonnegative().optional(),
+	working: zod.z.boolean().optional(),
+	pages: zod.z.array(zod.z.object({
+		page: require_schema.PageRefSchema,
+		cache: CachePinsSchema
+	}))
+});
+const MutationMetaSchema = zod.z.object({
+	affectedPages: zod.z.array(require_schema.PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: zod.z.string(),
+	undoable: zod.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 zod.z.union([zod.z.enum(["start", "end"]), zod.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(require_schema.PageRefSchema);
+/** Where annotations go among their page's annotations, or widgets among its widgets. */
+const AnnotationPositionSchema = listPositionSchema(require_schema.AnnotationRefSchema);
+/** Where fields go in the form's calculation order. */
+const FieldPositionSchema = listPositionSchema(require_schema.FormFieldRefSchema);
+/**
+* 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: require_schema.PageRefSchema,
+	PagePosition: PagePositionSchema,
+	CacheDelta: CacheDeltaSchema,
+	MutationMeta: MutationMetaSchema,
+	DocumentMetadata: DocumentMetadataSchema,
+	MetadataPatch: MetadataPatchSchema
+};
+/** Per-page side-effect envelope every annotation mutation returns. Mirrors `AnnotationListMutationMeta`. */
+const AnnotationListMutationMetaSchema = zod.z.object({
+	affectedPages: zod.z.array(require_schema.PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: zod.z.string(),
+	undoable: zod.z.boolean(),
+	changed: zod.z.array(require_schema.AnnotationRefSchema)
+});
+const AnnotationCreateResultSchema = zod.z.object({
+	annotation: require_schema.AnnotationSchema,
+	meta: AnnotationListMutationMetaSchema
+});
+const AnnotationImportResultSchema = zod.z.object({
+	annotations: zod.z.array(require_schema.AnnotationSchema),
+	refMap: zod.z.array(zod.z.object({
+		from: require_schema.AnnotationRefSchema,
+		to: require_schema.AnnotationRefSchema
+	})),
+	dropped: zod.z.array(zod.z.object({
+		ref: require_schema.AnnotationRefSchema,
+		field: zod.z.string().optional(),
+		reason: zod.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 = zod.z.object({
+	action: zod.z.enum([
+		"preserved",
+		"regenerated",
+		"generation-unavailable",
+		"restored"
+	]),
+	changed: zod.z.boolean()
+});
+const AnnotationUpdateResultSchema = zod.z.object({
+	annotation: require_schema.AnnotationSchema,
+	appearance: AppearanceOutcomeSchema,
+	meta: AnnotationListMutationMetaSchema
+});
+const AnnotationDeleteResultSchema = zod.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: require_schema.AnnotationSchema,
+	AnnotationRef: require_schema.AnnotationRefSchema,
+	AnnotationDraft: require_schema.AnnotationDraftSchema,
+	AnnotationPatch: require_schema.AnnotationPatchSchema,
+	PdfLinkTarget: require_schema.PdfLinkTargetSchema,
+	PdfLinkTargetWritable: require_schema.PdfLinkTargetWritableSchema,
+	AnnotationList: AnnotationListSchema,
+	AnnotationMutationMeta: AnnotationListMutationMetaSchema,
+	AnnotationPosition: AnnotationPositionSchema
+};
+/** What `page.annotations.reorder` takes on the wire. */
+const AnnotationReorderBodySchema = zod.z.object({
+	refs: zod.z.array(require_schema.AnnotationRefSchema).min(1),
+	position: AnnotationPositionSchema
+}).strict();
+/** A stacking-order change: the page's annotations in their new order, as refs. */
+const AnnotationReorderResultSchema = zod.z.object({
+	order: zod.z.array(require_schema.AnnotationRefSchema),
+	meta: AnnotationListMutationMetaSchema
+});
+/** A single-field write's meta: the envelope plus the fields and widgets it changed. */
+const FormMutationMetaSchema = zod.z.object({
+	affectedPages: zod.z.array(require_schema.PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: zod.z.string(),
+	undoable: zod.z.boolean(),
+	changedFields: zod.z.array(require_schema.FormFieldRefSchema),
+	changedWidgets: zod.z.array(require_schema.FormWidgetSchema),
+	redrawnWidgets: zod.z.array(require_schema.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: require_schema.FormFieldRefSchema,
+	FormField: require_schema.FormFieldDTOSchema,
+	FormFieldValue: require_schema.FormFieldValueSchema,
+	FormWidget: require_schema.FormWidgetSchema,
+	FormFieldDraft: require_schema.FormFieldDraftSchema,
+	FormFieldPatch: require_schema.FormFieldPatchSchema,
+	FieldPosition: FieldPositionSchema,
+	WidgetPlacement: require_schema.WidgetPlacementSchema,
+	WidgetAnnotation: require_schema.WidgetDTOSchema,
+	WidgetPatch: require_schema.WidgetPatchSchema,
+	FormMutationMeta: FormMutationMetaSchema
+};
+const FormSetValueResultSchema = zod.z.object({
+	field: require_schema.FormFieldDTOSchema,
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+const FormResetResultSchema = zod.z.object({
+	fields: zod.z.array(require_schema.FormFieldDTOSchema),
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+/** What `reset` takes on the wire: the fields to reset, or none for the whole form. */
+const FormResetBodySchema = zod.z.object({ refs: zod.z.array(require_schema.FormFieldRefSchema).optional() }).strict();
+/** What `updateWidget` takes on the wire: the widget patch (`PATCH …/form/widgets/{p}/{key}`). */
+const FormWidgetUpdateBodySchema = zod.z.object({ patch: require_schema.WidgetPatchSchema }).strict();
+const FormImportResultSchema = zod.z.object({
+	fields: zod.z.array(require_schema.FormFieldDTOSchema),
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	refMap: zod.z.array(zod.z.object({
+		from: require_schema.FormFieldRefSchema,
+		to: require_schema.FormFieldRefSchema
+	})),
+	dropped: zod.z.array(zod.z.object({
+		ref: require_schema.FormFieldRefSchema.nullable(),
+		widget: require_schema.AnnotationRefSchema.optional(),
+		field: zod.z.string().optional(),
+		reason: zod.z.enum([
+			"name-conflict",
+			"no-field",
+			"unsupported-family",
+			"script-not-allowed",
+			"unsupported-action"
+		])
+	})),
+	calculationOrder: zod.z.array(require_schema.FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+const FormValuesImportResultSchema = zod.z.object({
+	fields: zod.z.array(require_schema.FormFieldDTOSchema),
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	dropped: zod.z.array(zod.z.object({
+		ref: require_schema.FormFieldRefSchema,
+		reason: zod.z.enum([
+			"no-field",
+			"wrong-family",
+			"value-not-allowed",
+			"locked",
+			"fill-not-allowed"
+		])
+	})),
+	meta: FormMutationMetaSchema
+});
+const FormFieldCreateResultSchema = zod.z.object({
+	field: require_schema.FormFieldDTOSchema,
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	calculationOrder: zod.z.array(require_schema.FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+const FormFieldUpdateResultSchema = zod.z.object({
+	field: require_schema.FormFieldDTOSchema,
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	calculationOrder: zod.z.array(require_schema.FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetUpdateResultSchema = zod.z.object({
+	widget: require_schema.WidgetDTOSchema,
+	appearance: AppearanceOutcomeSchema,
+	meta: FormMutationMetaSchema
+});
+/** What `forms.reorderWidgets` takes on the wire: the widgets of one page and where they go. */
+const FormWidgetsReorderBodySchema = zod.z.object({
+	widgets: zod.z.array(require_schema.AnnotationRefSchema).min(1),
+	position: AnnotationPositionSchema
+}).strict();
+/** A widget stacking-order change: the page's widgets in their new order, as refs. */
+const FormWidgetsReorderResultSchema = zod.z.object({
+	page: require_schema.PageRefSchema,
+	order: zod.z.array(require_schema.AnnotationRefSchema),
+	meta: FormMutationMetaSchema
+});
+const FormFieldDeleteResultSchema = zod.z.object({
+	calculationOrder: zod.z.array(require_schema.FormFieldRefSchema).optional(),
+	meta: FormMutationMetaSchema
+});
+/** What `forms.reorderCalculations` takes on the wire: the fields and where they go. */
+const FormCalculationsReorderBodySchema = zod.z.object({
+	fields: zod.z.array(require_schema.FormFieldRefSchema).min(1),
+	position: FieldPositionSchema
+}).strict();
+/** A calculation-order change: the form's whole new order. */
+const FormCalculationsReorderResultSchema = zod.z.object({
+	calculationOrder: zod.z.array(require_schema.FormFieldRefSchema),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetLinkResultSchema = zod.z.object({
+	field: require_schema.FormFieldDTOSchema,
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetDeleteResultSchema = zod.z.object({
+	widget: require_schema.AnnotationRefSchema,
+	page: require_schema.PageRefSchema,
+	field: require_schema.FormFieldDTOSchema.nullable(),
+	meta: FormMutationMetaSchema
+});
+const FormWidgetRestoreResultSchema = zod.z.object({
+	field: require_schema.FormFieldDTOSchema.nullable(),
+	widgets: zod.z.array(require_schema.WidgetDTOSchema),
+	meta: FormMutationMetaSchema
+});
+const FormRepairResultSchema = zod.z.object({
+	acroformCreated: zod.z.boolean(),
+	fieldsLinked: zod.z.number().int().nonnegative(),
+	widgetsLinked: zod.z.number().int().nonnegative(),
+	fieldsUnrepairable: zod.z.number().int().nonnegative(),
+	appearancesBaked: zod.z.number().int().nonnegative(),
+	needsAppearancesCleared: zod.z.boolean(),
+	meta: MutationMetaSchema
+});
+/** A page's five boxes in page space: measured from the top-left of the crop box. */
+const PageBoxesSchema = zod.z.object({
+	media: require_schema.PageBoxSchema,
+	crop: require_schema.PageBoxSchema,
+	bleed: require_schema.PageBoxSchema,
+	trim: require_schema.PageBoxSchema,
+	art: require_schema.PageBoxSchema
+});
+/**
+* Pure geometry for one page (`pages.list()` element). No annotation
+* liveness — that lives on annotation reads and the manifest.
+*/
+const PageLayoutSchema = zod.z.object({
+	index: zod.z.number().int().nonnegative(),
+	ref: require_schema.PageRefSchema,
+	label: zod.z.string().nullable(),
+	size: require_schema.PdfSizeSchema,
+	rotation: require_schema.PdfRotationSchema,
+	userUnit: zod.z.number().positive(),
+	tabOrder: zod.z.enum([
+		"rows",
+		"columns",
+		"structure",
+		"annotations",
+		"widgets"
+	]).nullable(),
+	boxes: PageBoxesSchema,
+	pdfCropBox: require_schema.PdfRectSchema,
+	actions: require_schema.PdfPageActionsSchema.optional()
+});
+const PageFlattenResultSchema = zod.z.object({
+	pages: zod.z.array(require_schema.PageRefSchema),
+	usage: zod.z.enum(["display", "print"]),
+	results: zod.z.array(zod.z.object({
+		page: require_schema.PageRefSchema,
+		status: zod.z.enum(["applied", "unchanged"])
+	})),
+	meta: MutationMetaSchema
+});
+/** See `AnnotationFlattenResult`. */
+const AnnotationFlattenResultSchema = zod.z.object({
+	page: require_schema.PageRefSchema,
+	usage: zod.z.enum(["display", "print"]),
+	results: zod.z.array(zod.z.object({
+		ref: require_schema.AnnotationRefSchema,
+		status: zod.z.enum(["applied", "unchanged"])
+	})),
+	meta: MutationMetaSchema
+});
+/** `annotations.flatten` input — see `AnnotationFlattenInput`. */
+const AnnotationFlattenInputSchema = zod.z.object({
+	refs: zod.z.array(require_schema.AnnotationRefSchema).min(1),
+	usage: zod.z.enum(["display", "print"])
+});
+/** `annotations.exportAppearance` input — see `AnnotationAppearanceExportInput`. */
+const AnnotationAppearanceExportInputSchema = zod.z.object({ refs: zod.z.array(require_schema.AnnotationRefSchema).min(1) });
+/** `doc.annotations.export` selection — see `AnnotationExportSelection`. */
+const AnnotationExportSelectionSchema = zod.z.object({
+	refs: zod.z.array(require_schema.AnnotationRefSchema).optional(),
+	pages: zod.z.array(require_schema.PageRefSchema).optional(),
+	include: zod.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 = zod.z.object({
+	annotationsVersion: zod.z.number().int().positive(),
+	layoutVersion: zod.z.number().int().positive(),
+	selection: AnnotationExportSelectionSchema
+}).strict();
+/** Where an import puts each page of a bundle — see `BundleImportPages`. */
+const BundleImportPagesSchema = zod.z.union([
+	zod.z.literal("same"),
+	zod.z.literal("by-position"),
+	zod.z.array(zod.z.object({
+		from: require_schema.PageRefSchema,
+		to: require_schema.PageRefSchema
+	}).strict())
+]);
+/** `doc.forms.export` selection — see `FormExportSelection`. */
+const FormExportSelectionSchema = zod.z.object({
+	fields: zod.z.array(require_schema.FormFieldRefSchema).optional(),
+	pages: zod.z.array(require_schema.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 = zod.z.object({
+	formsVersion: zod.z.number().int().positive(),
+	layoutVersion: zod.z.number().int().positive(),
+	selection: FormExportSelectionSchema
+}).strict();
+/** `doc.forms.import` options on the wire; the `opId` is the `Idempotency-Key` header. */
+const FormImportOptionsSchema = zod.z.object({
+	pages: BundleImportPagesSchema.optional(),
+	attribution: zod.z.enum(["restore", "stamp"]).optional(),
+	values: zod.z.boolean().optional()
+}).strict();
+/** `doc.forms.importValues` options on the wire. */
+const FormValuesImportOptionsSchema = zod.z.object({ attribution: zod.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 = zod.z.object({
+	format: zod.z.literal("embedpdf/form"),
+	version: zod.z.literal(1),
+	pages: zod.z.array(zod.z.unknown()),
+	fields: zod.z.array(zod.z.unknown()),
+	widgets: zod.z.array(zod.z.unknown()),
+	calculationOrder: zod.z.array(zod.z.unknown())
+}).strict();
+/** The `body` part of a form import request. */
+const FormImportBodySchema = zod.z.object({
+	bundle: FormBundleEnvelopeSchema,
+	options: FormImportOptionsSchema
+}).strict();
+/** The `body` part of a form values import request. */
+const FormValuesImportBodySchema = zod.z.object({
+	bundle: FormBundleEnvelopeSchema,
+	options: FormValuesImportOptionsSchema
+}).strict();
+/** `doc.annotations.import` options on the wire; the `opId` is the `Idempotency-Key` header. */
+const AnnotationImportOptionsSchema = zod.z.object({
+	pages: BundleImportPagesSchema.optional(),
+	attribution: zod.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 = zod.z.object({
+	bundle: zod.z.object({
+		format: zod.z.literal("embedpdf/annotations"),
+		version: zod.z.literal(1),
+		pages: zod.z.array(zod.z.unknown()),
+		items: zod.z.array(zod.z.unknown())
+	}).strict(),
+	options: AnnotationImportOptionsSchema
+}).strict();
+const PageFlattenInputSchema = zod.z.object({
+	pages: zod.z.array(require_schema.PageRefSchema),
+	usage: zod.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 = zod.z.object({
+	pages: zod.z.array(require_schema.PageRefSchema).optional(),
+	annotations: zod.z.array(require_schema.AnnotationRefSchema).optional()
+}).strict().refine((scope) => scope.pages === void 0 !== (scope.annotations === void 0), { message: "exactly one of pages or annotations" });
+const RedactionApplyResultSchema = zod.z.object({
+	scope: RedactionApplyScopeSchema,
+	results: zod.z.array(zod.z.object({
+		page: require_schema.PageRefSchema,
+		status: zod.z.enum(["applied", "unchanged"]),
+		removedAnnotationCount: zod.z.number().int().nonnegative()
+	})),
+	removedAnnotationCount: zod.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 = zod.z.object({
+	name: zod.z.string(),
+	target: zod.z.discriminatedUnion("kind", [
+		zod.z.object({
+			kind: zod.z.literal("page"),
+			page: require_schema.PageRefSchema
+		}),
+		zod.z.object({
+			kind: zod.z.literal("template"),
+			objectNumber: zod.z.number().int().positive()
+		}),
+		zod.z.object({ kind: zod.z.literal("dangling") })
+	])
+});
+const PageListSnapshotSchema = zod.z.object({
+	pageCount: zod.z.number().int().nonnegative(),
+	pages: zod.z.array(PageLayoutSchema),
+	namedPages: zod.z.array(NamedPageEntrySchema)
+});
+/** `pages.setName` input — see `PageNameInput`. */
+const PageNameInputSchema = zod.z.object({
+	name: zod.z.string().min(1),
+	page: require_schema.PageRefSchema,
+	replace: zod.z.string().min(1).optional()
+});
+/** `pages.removeName` input — see `PageRemoveNameInput`. */
+const PageRemoveNameInputSchema = zod.z.object({ name: zod.z.string().min(1) });
+/** Page reorder input: the pages, in their new order, and where they go. */
+const PageReorderInputSchema = zod.z.object({
+	pages: zod.z.array(require_schema.PageRefSchema).min(1),
+	position: PagePositionSchema
+}).strict();
+/**
+* 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 = zod.z.object({
+	pages: zod.z.array(require_schema.PageRefSchema),
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/** Named-page mutation result — layout-shaped, see `PageNameResult`. */
+const PageNameResultSchema = zod.z.object({
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/**
+* Page rotate input. Absolute rotation (idempotent — see `PageRotateInput`),
+* one value applied to every listed page.
+*/
+const PageRotateInputSchema = zod.z.object({
+	pages: zod.z.array(require_schema.PageRefSchema),
+	rotation: require_schema.PdfRotationSchema
+});
+/**
+* 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 = zod.z.object({
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/** Page delete input. Deleting every page is rejected server/worker-side. */
+const PageDeleteInputSchema = zod.z.object({ pages: zod.z.array(require_schema.PageRefSchema) });
+/**
+* Page delete result. Deleted page object numbers are retired (never recycled); surviving
+* pages keep identity + revisions (see `PageDeleteResult`).
+*/
+const PageDeleteResultSchema = zod.z.object({
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/**
+* Page insert (bytes) input — the `body` part of the multipart envelope;
+* the PDF rides the part `resources.source` names. `position` omitted →
+* `'end'`.
+*/
+const PageInsertInputSchema = zod.z.object({
+	position: PagePositionSchema.optional(),
+	resources: require_schema.SourceResourceKeysSchema
+}).strict();
+/**
+* Blank-page insert input — plain JSON, pages.insert minus the bytes.
+* `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 PageInsertBlankInputSchema = zod.z.object({
+	size: zod.z.object({
+		width: zod.z.number().positive().finite(),
+		height: zod.z.number().positive().finite()
+	}),
+	count: zod.z.number().int().min(1).max(100).optional(),
+	position: PagePositionSchema.optional()
+});
+/** Page extract input: the pages to export, in the order they should appear. */
+const PageExtractInputSchema = zod.z.object({ pages: zod.z.array(require_schema.PageRefSchema).min(1) });
+/**
+* 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 = zod.z.object({
+	insertedPages: zod.z.array(require_schema.PageRefSchema),
+	layout: PageListSnapshotSchema,
+	meta: MutationMetaSchema
+});
+/** See `AttachmentMutationMeta`. */
+const AttachmentMutationMetaSchema = zod.z.object({
+	affectedPages: zod.z.array(require_schema.PageRefSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	opId: zod.z.string(),
+	undoable: zod.z.boolean(),
+	changed: zod.z.array(require_schema.AttachmentRefSchema)
+});
+const AttachmentCreateResultSchema = zod.z.object({
+	attachment: require_schema.AttachmentSchema,
+	meta: AttachmentMutationMetaSchema
+});
+const AttachmentDeleteResultSchema = zod.z.object({ meta: AttachmentMutationMetaSchema });
+/** See `AttachmentList`. */
+const AttachmentListSchema = zod.z.object({ attachments: zod.z.array(require_schema.AttachmentSchema) });
+/**
+* Metadata write result: the re-read `metadata`. On the cloud,
+* `meta.cacheDelta` advances only `docVersion` and `metadataVersion`.
+*/
+const MetadataUpdateResultSchema = zod.z.object({
+	metadata: DocumentMetadataSchema,
+	meta: MutationMetaSchema
+});
+const CustomMetadataUpdateResultSchema = zod.z.object({
+	custom: CustomMetadataSchema,
+	meta: MutationMetaSchema
+});
+const Base64Schema = zod.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/, "base64");
+const DocumentVersionRefSchema = zod.z.object({
+	baseSha256: zod.z.string().regex(/^[0-9a-f]{64}$/),
+	editsVersion: zod.z.number().int().nonnegative()
+});
+const ByteRangeSchema = zod.z.tuple([
+	zod.z.number().int().nonnegative(),
+	zod.z.number().int().nonnegative(),
+	zod.z.number().int().nonnegative(),
+	zod.z.number().int().nonnegative()
+]);
+/** `SignaturePrepared` with the digest as base64. */
+const SignaturePreparedWireSchema = zod.z.object({
+	signingId: zod.z.string().min(1),
+	digest: Base64Schema,
+	algorithm: zod.z.enum([
+		"sha256",
+		"sha384",
+		"sha512"
+	]),
+	byteRange: ByteRangeSchema,
+	contentsSize: zod.z.number().int().positive(),
+	subFilter: zod.z.string(),
+	expectedVersion: DocumentVersionRefSchema,
+	expiresAt: zod.z.string().nullable()
+});
+function encodePrepared(prepared) {
+	return {
+		...prepared,
+		digest: require_charmap.toBase64(prepared.digest)
+	};
+}
+function decodePrepared(wire) {
+	return {
+		...wire,
+		digest: require_charmap.fromBase64(wire.digest),
+		subFilter: wire.subFilter
+	};
+}
+/** The JSON body of a completion: the CMS as base64 beside the fence. */
+const SignatureCompleteBodySchema = zod.z.object({
+	cms: Base64Schema.refine((v) => v.length > 0, "cms is required"),
+	expectedVersion: DocumentVersionRefSchema
+});
+const DocMdpPermissionSchema = zod.z.union([
+	zod.z.literal(1),
+	zod.z.literal(2),
+	zod.z.literal(3)
+]);
+const ModificationLevelSchema = zod.z.enum([
+	"none",
+	"lta",
+	"fill",
+	"annotate"
+]);
+const DigestAlgorithmSchema = zod.z.enum([
+	"sha1",
+	"sha256",
+	"sha384",
+	"sha512"
+]);
+const FieldLockSpecSchema = zod.z.object({
+	action: zod.z.enum([
+		"all",
+		"include",
+		"exclude"
+	]),
+	fields: zod.z.array(zod.z.string()),
+	permission: DocMdpPermissionSchema.optional()
+});
+const SignatureSeedValueSchema = zod.z.object({
+	requiredFlags: zod.z.number().int(),
+	presentFlags: zod.z.number().int(),
+	version: zod.z.number().int().nullable(),
+	mdp: zod.z.union([
+		zod.z.literal(0),
+		zod.z.literal(1),
+		zod.z.literal(2),
+		zod.z.literal(3)
+	]).nullable(),
+	filter: zod.z.string().nullable(),
+	subFilters: zod.z.array(zod.z.string()),
+	digestMethods: zod.z.array(zod.z.string()),
+	reasons: zod.z.array(zod.z.string()),
+	unsupportedRequired: zod.z.boolean()
+});
+const SignatureDTOSchema = zod.z.object({
+	index: zod.z.number().int().nonnegative(),
+	field: require_schema.FormFieldRefSchema,
+	fieldName: zod.z.string(),
+	widget: require_schema.FormFieldWidgetSchema.nullable(),
+	signed: zod.z.boolean(),
+	kind: zod.z.enum(["signature", "timestamp"]),
+	filter: zod.z.string().nullable(),
+	subFilter: zod.z.string().nullable(),
+	byteRange: ByteRangeSchema.nullable(),
+	contentsSize: zod.z.number().int().nonnegative(),
+	coverage: zod.z.enum([
+		"whole-revision",
+		"partial",
+		"malformed"
+	]).nullable(),
+	revisionIndex: zod.z.number().int().nonnegative().nullable(),
+	signer: zod.z.object({
+		name: zod.z.string().nullable(),
+		reason: zod.z.string().nullable(),
+		location: zod.z.string().nullable(),
+		contactInfo: zod.z.string().nullable(),
+		signedAt: require_schema.IsoDateTimeSchema.nullable()
+	}),
+	docMdp: DocMdpPermissionSchema.nullable(),
+	catalogCertification: zod.z.boolean(),
+	fieldMdp: FieldLockSpecSchema.nullable(),
+	lock: FieldLockSpecSchema.nullable(),
+	seedValue: SignatureSeedValueSchema.nullable()
+});
+const DocumentProtectionSchema = zod.z.object({
+	enforced: ModificationLevelSchema.nullable(),
+	judged: ModificationLevelSchema.nullable(),
+	certification: zod.z.object({
+		signatureIndex: zod.z.number().int().nonnegative(),
+		permission: DocMdpPermissionSchema
+	}).nullable(),
+	fieldLocks: zod.z.array(zod.z.object({
+		signatureIndex: zod.z.number().int().nonnegative(),
+		source: zod.z.enum(["fieldmdp", "lock"]),
+		spec: FieldLockSpecSchema
+	})),
+	policyVersion: zod.z.number().int()
+});
+const PdfRevisionSchema = zod.z.object({
+	index: zod.z.number().int().nonnegative(),
+	end: zod.z.number().int().nonnegative(),
+	xrefOffset: zod.z.number().int().nonnegative(),
+	signatureIndex: zod.z.number().int().nonnegative().nullable()
+});
+const SignatureSnapshotSchema = zod.z.object({
+	chainValid: zod.z.boolean(),
+	revisions: zod.z.array(PdfRevisionSchema),
+	signatures: zod.z.array(SignatureDTOSchema),
+	protection: DocumentProtectionSchema
+});
+const BaseVersionInfoSchema = zod.z.object({
+	sha256: zod.z.string().regex(/^[0-9a-f]{64}$/),
+	byteLength: zod.z.number().int().nonnegative()
+});
+const SignatureCompleteResultSchema = zod.z.object({
+	status: zod.z.enum(["completed", "already-completed"]),
+	signature: SignatureDTOSchema,
+	version: BaseVersionInfoSchema,
+	previous: DocumentVersionRefSchema,
+	protection: DocumentProtectionSchema,
+	meta: MutationMetaSchema
+});
+const SignatureCancelResultSchema = zod.z.object({ status: zod.z.enum([
+	"cancelled",
+	"already-completed",
+	"unknown"
+]) });
+const ChangeFindingSchema = zod.z.object({
+	rule: zod.z.string(),
+	verdict: zod.z.enum([
+		"permitted",
+		"forbidden",
+		"incomplete"
+	]),
+	objectNumber: zod.z.number().int().nonnegative(),
+	edge: zod.z.string().optional(),
+	detail: zod.z.string().optional()
+});
+const AnalysisDetailSchema = zod.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 = zod.z.object({
+	mode: zod.z.enum(["authoritative", "exploratory"]),
+	policyVersion: zod.z.number().int(),
+	basis: zod.z.object({
+		version: BaseVersionInfoSchema,
+		editsVersion: zod.z.number().int().nonnegative(),
+		source: zod.z.enum(["persisted", "working-copy"])
+	}),
+	since: zod.z.object({
+		revisionIndex: zod.z.number().int().nonnegative(),
+		signatureIndex: zod.z.number().int().nonnegative().nullable()
+	}),
+	until: zod.z.object({ revisionIndex: zod.z.number().int().nonnegative() }),
+	restrictions: zod.z.array(zod.z.object({
+		signatureIndex: zod.z.number().int().nonnegative(),
+		revisionIndex: zod.z.number().int().nonnegative(),
+		source: zod.z.enum([
+			"docmdp",
+			"fieldmdp",
+			"lock"
+		]),
+		own: zod.z.boolean(),
+		permission: zod.z.union([
+			zod.z.literal(1),
+			zod.z.literal(2),
+			zod.z.literal(3)
+		]).optional(),
+		fields: zod.z.unknown().optional()
+	})),
+	current: zod.z.object({
+		verdict: zod.z.enum([
+			"unchanged",
+			"permitted",
+			"forbidden",
+			"indeterminate"
+		]),
+		complete: zod.z.boolean(),
+		primary: ChangeFindingSchema.optional(),
+		findings: zod.z.array(ChangeFindingSchema),
+		method: zod.z.enum(["net-state", "net-state+replay"])
+	}),
+	later: zod.z.object({
+		revisionCount: zod.z.number().int().nonnegative(),
+		undoneObjectNumbers: zod.z.array(zod.z.number().int().nonnegative())
+	}),
+	/** Equals `current.verdict`. */
+	verdict: zod.z.enum([
+		"unchanged",
+		"permitted",
+		"forbidden",
+		"indeterminate"
+	]),
+	/** The step DTOs are large and evolving; carried verbatim. */
+	steps: zod.z.array(zod.z.unknown())
+});
+const SignatureSignerInputSchema = zod.z.object({
+	name: zod.z.string().optional(),
+	reason: zod.z.string().optional(),
+	location: zod.z.string().optional(),
+	contactInfo: zod.z.string().optional(),
+	signedAt: require_schema.IsoDateTimeSchema.optional()
+});
+/** The `body` part of a visual signature fill: which part holds the one-page PDF. */
+const SignatureAppearanceBodySchema = zod.z.object({ resources: require_schema.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 = zod.z.object({
+	field: require_schema.FormFieldRefSchema,
+	kind: zod.z.enum(["signature", "timestamp"]).optional(),
+	subFilter: zod.z.enum(["adbe.pkcs7.detached", "ETSI.CAdES.detached"]).optional(),
+	digest: zod.z.enum([
+		"sha256",
+		"sha384",
+		"sha512"
+	]).optional(),
+	contentsSize: zod.z.number().int().positive().optional(),
+	signer: SignatureSignerInputSchema.optional(),
+	certify: zod.z.object({ permission: DocMdpPermissionSchema }).optional(),
+	lock: FieldLockSpecSchema.optional(),
+	resources: require_schema.AppearanceResourceKeysSchema.optional()
+});
+const optionalIndex = zod.z.coerce.number().int().nonnegative().optional();
+/** Layer analysis query (the current form): exactly one `since.*`; the working copy is the end. */
+const LayerAnalysisQuerySchema = zod.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 = zod.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 = zod.z.object({
+	sha256: zod.z.string().regex(/^[0-9a-f]{64}$/),
+	byteLength: zod.z.number().int().nonnegative(),
+	number: zod.z.number().int().positive(),
+	parentSha256: zod.z.string().nullable(),
+	producer: zod.z.enum(["upload", "signature"]),
+	signingId: zod.z.string().nullable(),
+	createdAt: zod.z.number().int()
+});
+const DocumentVersionsSchema = zod.z.object({
+	/** `documents.base_sha`: the version every layer is over, or behind. */
+	head: zod.z.string().regex(/^[0-9a-f]{64}$/),
+	/** Oldest first. */
+	versions: zod.z.array(DocumentVersionSchema)
+});
+const PageScaleResultSchema = zod.z.object({
+	page: require_schema.PageRefSchema,
+	meta: MutationMetaSchema
+});
+//#endregion
+Object.defineProperty(exports, "AccessRequestSchema", {
+	enumerable: true,
+	get: function() {
+		return AccessRequestSchema;
+	}
+});
+Object.defineProperty(exports, "AccessResponseSchema", {
+	enumerable: true,
+	get: function() {
+		return AccessResponseSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationAppearanceBatchSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationAppearanceBatchSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationAppearanceExportInputSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationAppearanceExportInputSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationAppearancesQuerySchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationAppearancesQuerySchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationCreateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationCreateResultSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationDeleteResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationDeleteResultSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationExportSelectionSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationExportSelectionSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationFlattenInputSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationFlattenInputSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationFlattenResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationFlattenResultSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationImportBodySchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationImportBodySchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationImportOptionsSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationImportOptionsSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationImportResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationImportResultSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationListMutationMetaSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationListMutationMetaSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationListSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationListSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationPositionSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationPositionSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationReorderBodySchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationReorderBodySchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationReorderResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationReorderResultSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationUpdateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationUpdateResultSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationWireComponents", {
+	enumerable: true,
+	get: function() {
+		return AnnotationWireComponents;
+	}
+});
+Object.defineProperty(exports, "AnnotationsExportRequestSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationsExportRequestSchema;
+	}
+});
+Object.defineProperty(exports, "AppearanceOutcomeSchema", {
+	enumerable: true,
+	get: function() {
+		return AppearanceOutcomeSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentCreateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentCreateResultSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentDeleteResultSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentDeleteResultSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentListSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentListSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentMutationMetaSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentMutationMetaSchema;
+	}
+});
+Object.defineProperty(exports, "BaseVersionInfoSchema", {
+	enumerable: true,
+	get: function() {
+		return BaseVersionInfoSchema;
+	}
+});
+Object.defineProperty(exports, "BundleLimitsSchema", {
+	enumerable: true,
+	get: function() {
+		return BundleLimitsSchema;
+	}
+});
+Object.defineProperty(exports, "ByteRangeSchema", {
+	enumerable: true,
+	get: function() {
+		return ByteRangeSchema;
+	}
+});
+Object.defineProperty(exports, "CacheDeltaSchema", {
+	enumerable: true,
+	get: function() {
+		return CacheDeltaSchema;
+	}
+});
+Object.defineProperty(exports, "CachePinsSchema", {
+	enumerable: true,
+	get: function() {
+		return CachePinsSchema;
+	}
+});
+Object.defineProperty(exports, "ChangeAnalysisSchema", {
+	enumerable: true,
+	get: function() {
+		return ChangeAnalysisSchema;
+	}
+});
+Object.defineProperty(exports, "CustomMetadataPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return CustomMetadataPatchSchema;
+	}
+});
+Object.defineProperty(exports, "CustomMetadataSchema", {
+	enumerable: true,
+	get: function() {
+		return CustomMetadataSchema;
+	}
+});
+Object.defineProperty(exports, "CustomMetadataUpdateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return CustomMetadataUpdateResultSchema;
+	}
+});
+Object.defineProperty(exports, "DigestAlgorithmSchema", {
+	enumerable: true,
+	get: function() {
+		return DigestAlgorithmSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentHeadSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentHeadSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentManifestSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentManifestSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentMetadataSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentMetadataSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentProtectionSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentProtectionSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentSecurityStateSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentSecurityStateSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentVersionRefSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentVersionRefSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentVersionSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentVersionSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentVersionsSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentVersionsSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentWireComponents", {
+	enumerable: true,
+	get: function() {
+		return DocumentWireComponents;
+	}
+});
+Object.defineProperty(exports, "EditSessionAccessSchema", {
+	enumerable: true,
+	get: function() {
+		return EditSessionAccessSchema;
+	}
+});
+Object.defineProperty(exports, "EditSessionStatusSchema", {
+	enumerable: true,
+	get: function() {
+		return EditSessionStatusSchema;
+	}
+});
+Object.defineProperty(exports, "EngineErrorPayloadSchema", {
+	enumerable: true,
+	get: function() {
+		return EngineErrorPayloadSchema;
+	}
+});
+Object.defineProperty(exports, "FieldLockSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return FieldLockSpecSchema;
+	}
+});
+Object.defineProperty(exports, "FieldPositionSchema", {
+	enumerable: true,
+	get: function() {
+		return FieldPositionSchema;
+	}
+});
+Object.defineProperty(exports, "FormCalculationsReorderBodySchema", {
+	enumerable: true,
+	get: function() {
+		return FormCalculationsReorderBodySchema;
+	}
+});
+Object.defineProperty(exports, "FormCalculationsReorderResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormCalculationsReorderResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormExportRequestSchema", {
+	enumerable: true,
+	get: function() {
+		return FormExportRequestSchema;
+	}
+});
+Object.defineProperty(exports, "FormExportSelectionSchema", {
+	enumerable: true,
+	get: function() {
+		return FormExportSelectionSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldCreateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldCreateResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldDeleteResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldDeleteResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldUpdateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldUpdateResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormImportBodySchema", {
+	enumerable: true,
+	get: function() {
+		return FormImportBodySchema;
+	}
+});
+Object.defineProperty(exports, "FormImportOptionsSchema", {
+	enumerable: true,
+	get: function() {
+		return FormImportOptionsSchema;
+	}
+});
+Object.defineProperty(exports, "FormImportResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormImportResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormMutationMetaSchema", {
+	enumerable: true,
+	get: function() {
+		return FormMutationMetaSchema;
+	}
+});
+Object.defineProperty(exports, "FormRepairResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormRepairResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormResetBodySchema", {
+	enumerable: true,
+	get: function() {
+		return FormResetBodySchema;
+	}
+});
+Object.defineProperty(exports, "FormResetResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormResetResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormSetValueResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormSetValueResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormValuesImportBodySchema", {
+	enumerable: true,
+	get: function() {
+		return FormValuesImportBodySchema;
+	}
+});
+Object.defineProperty(exports, "FormValuesImportOptionsSchema", {
+	enumerable: true,
+	get: function() {
+		return FormValuesImportOptionsSchema;
+	}
+});
+Object.defineProperty(exports, "FormValuesImportResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormValuesImportResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetDeleteResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetDeleteResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetLinkResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetLinkResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetRestoreResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetRestoreResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetUpdateBodySchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetUpdateBodySchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetUpdateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetUpdateResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetsReorderBodySchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetsReorderBodySchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetsReorderResultSchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetsReorderResultSchema;
+	}
+});
+Object.defineProperty(exports, "FormWireComponents", {
+	enumerable: true,
+	get: function() {
+		return FormWireComponents;
+	}
+});
+Object.defineProperty(exports, "IdentitySchema", {
+	enumerable: true,
+	get: function() {
+		return IdentitySchema;
+	}
+});
+Object.defineProperty(exports, "LayerAnalysisQuerySchema", {
+	enumerable: true,
+	get: function() {
+		return LayerAnalysisQuerySchema;
+	}
+});
+Object.defineProperty(exports, "LayerScopesSchema", {
+	enumerable: true,
+	get: function() {
+		return LayerScopesSchema;
+	}
+});
+Object.defineProperty(exports, "ManifestPageSchema", {
+	enumerable: true,
+	get: function() {
+		return ManifestPageSchema;
+	}
+});
+Object.defineProperty(exports, "MetadataPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return MetadataPatchSchema;
+	}
+});
+Object.defineProperty(exports, "MetadataUpdateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return MetadataUpdateResultSchema;
+	}
+});
+Object.defineProperty(exports, "ModificationLevelSchema", {
+	enumerable: true,
+	get: function() {
+		return ModificationLevelSchema;
+	}
+});
+Object.defineProperty(exports, "MutationMetaSchema", {
+	enumerable: true,
+	get: function() {
+		return MutationMetaSchema;
+	}
+});
+Object.defineProperty(exports, "NamedPageEntrySchema", {
+	enumerable: true,
+	get: function() {
+		return NamedPageEntrySchema;
+	}
+});
+Object.defineProperty(exports, "ObjectNumberRangeSchema", {
+	enumerable: true,
+	get: function() {
+		return ObjectNumberRangeSchema;
+	}
+});
+Object.defineProperty(exports, "ObjectNumberReservationRequestSchema", {
+	enumerable: true,
+	get: function() {
+		return ObjectNumberReservationRequestSchema;
+	}
+});
+Object.defineProperty(exports, "ObjectNumberReservationResponseSchema", {
+	enumerable: true,
+	get: function() {
+		return ObjectNumberReservationResponseSchema;
+	}
+});
+Object.defineProperty(exports, "OpenDocumentResponseSchema", {
+	enumerable: true,
+	get: function() {
+		return OpenDocumentResponseSchema;
+	}
+});
+Object.defineProperty(exports, "PAGE_RENDER_FAMILIES", {
+	enumerable: true,
+	get: function() {
+		return PAGE_RENDER_FAMILIES;
+	}
+});
+Object.defineProperty(exports, "PageBoxesSchema", {
+	enumerable: true,
+	get: function() {
+		return PageBoxesSchema;
+	}
+});
+Object.defineProperty(exports, "PageDeleteInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageDeleteInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageDeleteResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageDeleteResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageExtractInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageExtractInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageFlattenInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageFlattenInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageFlattenResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageFlattenResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageGeometrySnapshotSchema", {
+	enumerable: true,
+	get: function() {
+		return PageGeometrySnapshotSchema;
+	}
+});
+Object.defineProperty(exports, "PageInsertBlankInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageInsertBlankInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageInsertInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageInsertInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageInsertResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageInsertResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageLayoutSchema", {
+	enumerable: true,
+	get: function() {
+		return PageLayoutSchema;
+	}
+});
+Object.defineProperty(exports, "PageListSnapshotSchema", {
+	enumerable: true,
+	get: function() {
+		return PageListSnapshotSchema;
+	}
+});
+Object.defineProperty(exports, "PageNameInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageNameInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageNameResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageNameResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageNetworkRenderFormatSchema", {
+	enumerable: true,
+	get: function() {
+		return PageNetworkRenderFormatSchema;
+	}
+});
+Object.defineProperty(exports, "PagePositionSchema", {
+	enumerable: true,
+	get: function() {
+		return PagePositionSchema;
+	}
+});
+Object.defineProperty(exports, "PageRemoveNameInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageRemoveNameInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageRenderQuerySchemas", {
+	enumerable: true,
+	get: function() {
+		return PageRenderQuerySchemas;
+	}
+});
+Object.defineProperty(exports, "PageReorderInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageReorderInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageReorderResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageReorderResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageRotateInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageRotateInputSchema;
+	}
+});
+Object.defineProperty(exports, "PageRotateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageRotateResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageScaleResultSchema", {
+	enumerable: true,
+	get: function() {
+		return PageScaleResultSchema;
+	}
+});
+Object.defineProperty(exports, "PageTextSnapshotSchema", {
+	enumerable: true,
+	get: function() {
+		return PageTextSnapshotSchema;
+	}
+});
+Object.defineProperty(exports, "PdfRevisionSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfRevisionSchema;
+	}
+});
+Object.defineProperty(exports, "PdfSaveModeSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfSaveModeSchema;
+	}
+});
+Object.defineProperty(exports, "RedactionApplyResultSchema", {
+	enumerable: true,
+	get: function() {
+		return RedactionApplyResultSchema;
+	}
+});
+Object.defineProperty(exports, "RedactionApplyScopeSchema", {
+	enumerable: true,
+	get: function() {
+		return RedactionApplyScopeSchema;
+	}
+});
+Object.defineProperty(exports, "SearchMatchSchema", {
+	enumerable: true,
+	get: function() {
+		return SearchMatchSchema;
+	}
+});
+Object.defineProperty(exports, "SearchQuerySchema", {
+	enumerable: true,
+	get: function() {
+		return SearchQuerySchema;
+	}
+});
+Object.defineProperty(exports, "SearchRequestSchema", {
+	enumerable: true,
+	get: function() {
+		return SearchRequestSchema;
+	}
+});
+Object.defineProperty(exports, "SearchSliceSchema", {
+	enumerable: true,
+	get: function() {
+		return SearchSliceSchema;
+	}
+});
+Object.defineProperty(exports, "SearchSnippetSchema", {
+	enumerable: true,
+	get: function() {
+		return SearchSnippetSchema;
+	}
+});
+Object.defineProperty(exports, "SignatureAppearanceBodySchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureAppearanceBodySchema;
+	}
+});
+Object.defineProperty(exports, "SignatureCancelResultSchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureCancelResultSchema;
+	}
+});
+Object.defineProperty(exports, "SignatureCompleteBodySchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureCompleteBodySchema;
+	}
+});
+Object.defineProperty(exports, "SignatureCompleteResultSchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureCompleteResultSchema;
+	}
+});
+Object.defineProperty(exports, "SignatureDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureDTOSchema;
+	}
+});
+Object.defineProperty(exports, "SignaturePrepareBodySchema", {
+	enumerable: true,
+	get: function() {
+		return SignaturePrepareBodySchema;
+	}
+});
+Object.defineProperty(exports, "SignaturePreparedWireSchema", {
+	enumerable: true,
+	get: function() {
+		return SignaturePreparedWireSchema;
+	}
+});
+Object.defineProperty(exports, "SignatureSeedValueSchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureSeedValueSchema;
+	}
+});
+Object.defineProperty(exports, "SignatureSnapshotSchema", {
+	enumerable: true,
+	get: function() {
+		return SignatureSnapshotSchema;
+	}
+});
+Object.defineProperty(exports, "VersionAnalysisQuerySchema", {
+	enumerable: true,
+	get: function() {
+		return VersionAnalysisQuerySchema;
+	}
+});
+Object.defineProperty(exports, "WidgetAppearancesQuerySchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetAppearancesQuerySchema;
+	}
+});
+Object.defineProperty(exports, "analyzeInputFromQuery", {
+	enumerable: true,
+	get: function() {
+		return analyzeInputFromQuery;
+	}
+});
+Object.defineProperty(exports, "decodePrepared", {
+	enumerable: true,
+	get: function() {
+		return decodePrepared;
+	}
+});
+Object.defineProperty(exports, "encodePrepared", {
+	enumerable: true,
+	get: function() {
+		return encodePrepared;
+	}
+});
+Object.defineProperty(exports, "pageRenderFamilyOf", {
+	enumerable: true,
+	get: function() {
+		return pageRenderFamilyOf;
+	}
+});
+
+//# sourceMappingURL=schemas-Berf1swF.cjs.map