@embedpdf/engine-core 3.0.0-next.0

package/dist/schemas-9OpSSeM6.js

@@ -0,0 +1,2493 @@
+import { i as PdfAnnotationSubtypeCode, o as EngineErrorCode } from "./subtype-BvAzLCGC.js";
+import { z } from "zod";
+//#region src/geometry/schemas.ts
+/**
+* Zod schemas for engine PDF-document geometry. Exported from `wire.ts` ONLY
+* (never from `shared.ts`/`runtime`) so the zod-free runtime stays zod-free.
+*/
+const PdfPointSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+const LinePointsSchema = z.object({
+	start: PdfPointSchema,
+	end: PdfPointSchema
+});
+/** `/CL` callout leader line — two points (straight) or three (knee-jointed). */
+const CalloutLineSchema = z.union([z.tuple([PdfPointSchema, PdfPointSchema]), z.tuple([
+	PdfPointSchema,
+	PdfPointSchema,
+	PdfPointSchema
+])]);
+/** `/InkList` — an array of strokes, each an array of points. */
+const InkListSchema = z.array(z.array(PdfPointSchema));
+const PdfRectSchema = z.object({
+	left: z.number(),
+	bottom: z.number(),
+	right: z.number(),
+	top: z.number()
+});
+const PdfSizeSchema = z.object({
+	width: z.number().nonnegative(),
+	height: z.number().nonnegative()
+});
+const PdfQuadSchema = z.object({
+	p1: PdfPointSchema,
+	p2: PdfPointSchema,
+	p3: PdfPointSchema,
+	p4: PdfPointSchema
+});
+const PdfRotationSchema = z.union([
+	z.literal(0),
+	z.literal(90),
+	z.literal(180),
+	z.literal(270)
+]);
+//#endregion
+//#region src/dto/PdfAction.schema.ts
+const PdfActionTypeSchema = z.enum([
+	"unknown",
+	"goto",
+	"goto-remote",
+	"goto-embedded",
+	"launch",
+	"thread",
+	"uri",
+	"sound",
+	"movie",
+	"hide",
+	"named",
+	"submit-form",
+	"reset-form",
+	"import-data",
+	"javascript",
+	"set-ocg-state",
+	"rendition",
+	"transition",
+	"goto-3d-view"
+]);
+const PdfActionNodeSchema = z.lazy(() => z.object({
+	type: PdfActionTypeSchema,
+	subtype: z.string(),
+	script: z.string().optional(),
+	next: z.array(PdfActionNodeSchema)
+}));
+const PdfActionTreeSchema = z.object({
+	root: PdfActionNodeSchema.nullable(),
+	incomplete: z.boolean(),
+	warningFlags: z.number().int().nonnegative(),
+	warnings: z.array(z.enum([
+		"cycle-dropped",
+		"malformed-next",
+		"incomplete"
+	]))
+});
+const PdfFieldActionsSchema = z.object({
+	keystroke: PdfActionTreeSchema.optional(),
+	format: PdfActionTreeSchema.optional(),
+	validate: PdfActionTreeSchema.optional(),
+	calculate: PdfActionTreeSchema.optional()
+});
+const PdfPageActionsSchema = z.object({
+	open: PdfActionTreeSchema.optional(),
+	close: PdfActionTreeSchema.optional()
+});
+const PdfAnnotationActionsSchema = z.object({
+	activate: PdfActionTreeSchema.optional(),
+	cursorEnter: PdfActionTreeSchema.optional(),
+	cursorExit: PdfActionTreeSchema.optional(),
+	mouseDown: PdfActionTreeSchema.optional(),
+	mouseUp: PdfActionTreeSchema.optional(),
+	focus: PdfActionTreeSchema.optional(),
+	blur: PdfActionTreeSchema.optional(),
+	pageOpen: PdfActionTreeSchema.optional(),
+	pageClose: PdfActionTreeSchema.optional(),
+	pageVisible: PdfActionTreeSchema.optional(),
+	pageInvisible: PdfActionTreeSchema.optional()
+});
+const DocumentActionsSnapshotSchema = z.object({
+	nameTreeScripts: z.array(z.object({
+		name: z.string(),
+		action: PdfActionTreeSchema
+	})),
+	openAction: PdfActionTreeSchema.nullable(),
+	willClose: PdfActionTreeSchema.optional(),
+	willSave: PdfActionTreeSchema.optional(),
+	didSave: PdfActionTreeSchema.optional(),
+	willPrint: PdfActionTreeSchema.optional(),
+	didPrint: PdfActionTreeSchema.optional()
+});
+//#endregion
+//#region src/annotation/base.schema.ts
+/** @deprecated Use `PdfPointSchema` from `../geometry/schemas`. */
+const PointSchema = PdfPointSchema;
+/** @deprecated Use `PdfRectSchema` from `../geometry/schemas`. */
+const RectSchema = PdfRectSchema;
+const ColorSchema = z.object({
+	r: z.number().int().min(0).max(255),
+	g: z.number().int().min(0).max(255),
+	b: z.number().int().min(0).max(255)
+});
+const AnnotationBorderStyleSchema = z.enum([
+	"solid",
+	"dashed",
+	"beveled",
+	"inset"
+]);
+const PdfRectDifferencesSchema = z.object({
+	left: z.number().nonnegative(),
+	top: z.number().nonnegative(),
+	right: z.number().nonnegative(),
+	bottom: z.number().nonnegative()
+});
+const LineEndingSchema = z.enum([
+	"none",
+	"square",
+	"circle",
+	"diamond",
+	"open-arrow",
+	"closed-arrow",
+	"butt",
+	"r-open-arrow",
+	"r-closed-arrow",
+	"slash"
+]);
+const LineEndingsSchema = z.object({
+	start: LineEndingSchema,
+	end: LineEndingSchema
+});
+const StandardFontSchema = z.enum([
+	"courier",
+	"courier-bold",
+	"courier-bold-oblique",
+	"courier-oblique",
+	"helvetica",
+	"helvetica-bold",
+	"helvetica-bold-oblique",
+	"helvetica-oblique",
+	"times-roman",
+	"times-bold",
+	"times-bold-italic",
+	"times-italic",
+	"symbol",
+	"zapf-dingbats"
+]);
+const TextAlignmentSchema = z.enum([
+	"left",
+	"center",
+	"right"
+]);
+const FreeTextIntentSchema = z.enum(["free-text", "free-text-callout"]);
+const CaretIntentSchema = z.literal("replace");
+const StrikeoutIntentSchema = z.literal("strikeout-text-edit");
+const InkIntentSchema = z.literal("ink-highlight");
+const BlendModeSchema = z.enum([
+	"normal",
+	"multiply",
+	"screen",
+	"overlay",
+	"darken",
+	"lighten",
+	"color-dodge",
+	"color-burn",
+	"hard-light",
+	"soft-light",
+	"difference",
+	"exclusion",
+	"hue",
+	"saturation",
+	"color",
+	"luminosity"
+]);
+const AnnotationFlagsSchema = z.object({
+	invisible: z.boolean(),
+	hidden: z.boolean(),
+	print: z.boolean(),
+	noZoom: z.boolean(),
+	noRotate: z.boolean(),
+	noView: z.boolean(),
+	readOnly: z.boolean(),
+	locked: z.boolean(),
+	toggleNoView: z.boolean(),
+	lockedContents: z.boolean()
+});
+/**
+* Partial flag set authorable on a Draft or Patch — every key optional so
+* callers set only the bits they care about. The engine merges these onto
+* the annotation's current `/F` bitset.
+*/
+const AnnotationFlagsPartialSchema = z.object({
+	invisible: z.boolean(),
+	hidden: z.boolean(),
+	print: z.boolean(),
+	noZoom: z.boolean(),
+	noRotate: z.boolean(),
+	noView: z.boolean(),
+	readOnly: z.boolean(),
+	locked: z.boolean(),
+	toggleNoView: z.boolean(),
+	lockedContents: z.boolean()
+}).partial();
+const AnnotationStableIdSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("objectNumber"),
+	value: z.number().int().nonnegative()
+}), z.object({
+	kind: z.literal("nm"),
+	value: z.string()
+})]);
+const RevisionTokenSchema = z.object({
+	docSessionId: z.string(),
+	pageObjectNumber: z.number().int().positive(),
+	generation: z.number().int().nonnegative()
+});
+const AnnotationRefSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("objectNumber"),
+		pageObjectNumber: z.number().int().positive(),
+		annotObjectNumber: z.number().int().positive()
+	}),
+	z.object({
+		kind: z.literal("nm"),
+		pageObjectNumber: z.number().int().positive(),
+		nm: z.string()
+	}),
+	z.object({
+		kind: z.literal("index"),
+		pageObjectNumber: z.number().int().positive(),
+		index: z.number().int().nonnegative(),
+		revision: RevisionTokenSchema
+	})
+]);
+/**
+* Shared object literal for every per-subtype DTO schema. Each kind's
+* `dto.schema.ts` extends this with its own `subtype` literal and
+* subtype-specific fields. Note that we do NOT include `subtype` here —
+* each kind sets its own literal so `z.discriminatedUnion('subtype', ...)`
+* works at the catalog level.
+*/
+const AnnotationBaseShape = {
+	ref: AnnotationRefSchema,
+	pageObjectNumber: z.number().int().positive(),
+	index: z.number().int().nonnegative(),
+	identityQuality: z.enum(["durable", "weak"]),
+	nm: z.string().nullable(),
+	flags: AnnotationFlagsSchema,
+	rect: PdfRectSchema,
+	contents: z.string().nullable(),
+	author: z.string().nullable(),
+	created: z.string().datetime().nullable(),
+	modified: z.string().datetime().nullable(),
+	blendMode: BlendModeSchema,
+	inReplyTo: AnnotationRefSchema.nullable(),
+	replyType: z.enum(["reply", "group"]).nullable(),
+	userId: z.string().optional(),
+	groupId: z.string().optional(),
+	createdBy: z.string().optional(),
+	updatedBy: z.string().optional(),
+	actions: PdfAnnotationActionsSchema.optional()
+};
+/**
+* Annotation-wide fields shared by every Draft. Per-kind draft schemas
+* spread this alongside their family-specific shape.
+*
+* Authorial identity (/T, /EMBD_Metadata UserID/GroupID) is set by the
+* server from the caller's JWT identity — see the AnnotationDraftBase
+* docstring.
+*/
+const AnnotationDraftBaseShape = {
+	contents: z.string().nullable().optional(),
+	blendMode: BlendModeSchema.optional(),
+	nm: z.string().optional(),
+	flags: AnnotationFlagsPartialSchema.optional(),
+	inReplyTo: AnnotationRefSchema.optional(),
+	replyType: z.enum(["reply", "group"]).optional()
+};
+/**
+* Annotation-wide fields shared by every Patch. `nm` is monotonic per
+* annotation; clients target an existing annotation via AnnotationRef
+* instead of renaming.
+*
+* `groupId` is the only identity-shaped field on a patch — it
+* represents organizational ownership, and reassignment runs through
+* `checkSetGroup`. See AnnotationPatchBase for the full immutability
+* rules.
+*/
+const AnnotationPatchBaseShape = {
+	contents: z.string().nullable().optional(),
+	blendMode: BlendModeSchema.optional(),
+	groupId: z.string().min(1).optional(),
+	flags: AnnotationFlagsPartialSchema.optional(),
+	inReplyTo: AnnotationRefSchema.nullable().optional(),
+	replyType: z.enum(["reply", "group"]).optional()
+};
+//#endregion
+//#region src/annotation/kinds/style.shared.ts
+const ColorStyleDTOShape = {
+	color: ColorSchema,
+	opacity: z.number().min(0).max(1)
+};
+const ColorStyleDraftShape = {
+	color: ColorSchema.optional(),
+	opacity: z.number().min(0).max(1).optional()
+};
+const ColorStylePatchShape = ColorStyleDraftShape;
+const GeometryStyleDTOShape = {
+	...ColorStyleDTOShape,
+	strokeWidth: z.number().nonnegative(),
+	borderStyle: AnnotationBorderStyleSchema,
+	dashArray: z.array(z.number().nonnegative()).optional()
+};
+const GeometryStyleDraftShape = {
+	...ColorStyleDraftShape,
+	strokeWidth: z.number().nonnegative().optional(),
+	borderStyle: AnnotationBorderStyleSchema.optional(),
+	dashArray: z.array(z.number().nonnegative()).optional()
+};
+const GeometryStylePatchShape = GeometryStyleDraftShape;
+const FilledStyleDTOShape = {
+	...GeometryStyleDTOShape,
+	interiorColor: ColorSchema.nullable()
+};
+const FilledStyleDraftShape = {
+	...GeometryStyleDraftShape,
+	interiorColor: ColorSchema.nullable().optional()
+};
+const FilledStylePatchShape = FilledStyleDraftShape;
+//#endregion
+//#region src/annotation/kinds/caret/schema.ts
+const CaretDTOSchema = z.object({
+	...AnnotationBaseShape,
+	...ColorStyleDTOShape,
+	intent: CaretIntentSchema.nullable(),
+	rectDifferences: PdfRectDifferencesSchema.nullable(),
+	subtype: z.literal("caret")
+});
+const CaretDraftSchema = z.object({
+	...ColorStyleDraftShape,
+	...AnnotationDraftBaseShape,
+	intent: CaretIntentSchema.optional(),
+	rect: PdfRectSchema,
+	rectDifferences: PdfRectDifferencesSchema.nullable().optional(),
+	subtype: z.literal("caret")
+});
+const CaretPatchSchema = z.object({
+	...ColorStylePatchShape,
+	...AnnotationPatchBaseShape,
+	intent: CaretIntentSchema.optional(),
+	rect: PdfRectSchema.optional(),
+	rectDifferences: PdfRectDifferencesSchema.nullable().optional(),
+	subtype: z.literal("caret")
+});
+//#endregion
+//#region src/annotation/kinds/caret/index.ts
+const CaretKind = {
+	subtype: "caret",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.CARET,
+	dtoSchema: CaretDTOSchema,
+	draftSchema: CaretDraftSchema,
+	patchSchema: CaretPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/shape.shared.ts
+const ShapeDTOShape = {
+	...AnnotationBaseShape,
+	...FilledStyleDTOShape,
+	cloudyIntensity: z.number().positive().nullable(),
+	rectDifferences: PdfRectDifferencesSchema.nullable(),
+	rotation: z.number().optional(),
+	unrotatedRect: PdfRectSchema.optional()
+};
+const ShapeDraftShape = {
+	...FilledStyleDraftShape,
+	rect: PdfRectSchema,
+	cloudyIntensity: z.number().positive().nullable().optional(),
+	rectDifferences: PdfRectDifferencesSchema.nullable().optional(),
+	rotation: z.number().nullable().optional(),
+	unrotatedRect: PdfRectSchema.nullable().optional()
+};
+const ShapePatchShape = {
+	...FilledStylePatchShape,
+	rect: PdfRectSchema.optional(),
+	cloudyIntensity: z.number().positive().nullable().optional(),
+	rectDifferences: PdfRectDifferencesSchema.nullable().optional(),
+	rotation: z.number().nullable().optional(),
+	unrotatedRect: PdfRectSchema.nullable().optional()
+};
+//#endregion
+//#region src/annotation/kinds/circle/schema.ts
+const CircleDTOSchema = z.object({
+	...ShapeDTOShape,
+	subtype: z.literal("circle")
+});
+const CircleDraftSchema = z.object({
+	...ShapeDraftShape,
+	...AnnotationDraftBaseShape,
+	subtype: z.literal("circle")
+});
+const CirclePatchSchema = z.object({
+	...ShapePatchShape,
+	...AnnotationPatchBaseShape,
+	subtype: z.literal("circle")
+});
+//#endregion
+//#region src/annotation/kinds/circle/index.ts
+const CircleKind = {
+	subtype: "circle",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.CIRCLE,
+	dtoSchema: CircleDTOSchema,
+	draftSchema: CircleDraftSchema,
+	patchSchema: CirclePatchSchema
+};
+//#endregion
+//#region src/dto/Attachment.schema.ts
+/**
+* Wire schemas for the attachment read vocabulary (see `Attachment.ts`).
+* The write-side `AttachmentFileSource` carries inline bytes and never
+* appears on the wire — its post-normalization form is the kind-owned
+* `WireAttachmentFile` (see `annotation/kinds/file-attachment/schema.ts`).
+*/
+const AttachmentFileInfoSchema = z.object({
+	name: z.string(),
+	mimeType: z.string().optional(),
+	description: z.string().optional(),
+	size: z.number().int().nonnegative().optional(),
+	checksum: z.string().optional(),
+	creationDate: z.string().optional()
+});
+const EmbeddedFileRefSchema = z.object({
+	kind: z.literal("key"),
+	key: z.string().min(1)
+});
+const EmbeddedFileItemSchema = z.object({
+	key: z.string(),
+	name: z.string(),
+	mimeType: z.string().optional(),
+	description: z.string().optional(),
+	size: z.number().int().nonnegative().optional(),
+	checksum: z.string().optional(),
+	creationDate: z.string().optional(),
+	index: z.number().int().nonnegative()
+});
+//#endregion
+//#region src/annotation/kinds/file-attachment/schema.ts
+const FileAttachmentIconSchema = z.enum([
+	"push-pin",
+	"paperclip",
+	"graph",
+	"tag"
+]);
+/** Post-normalization form of the attached file: metadata + resource ref. */
+const WireAttachmentFileSchema = z.object({
+	resource: z.string().min(1),
+	name: z.string().min(1),
+	mimeType: z.string().optional(),
+	description: z.string().optional()
+});
+const FileAttachmentDTOSchema = z.object({
+	...AnnotationBaseShape,
+	...ColorStyleDTOShape,
+	icon: FileAttachmentIconSchema,
+	file: AttachmentFileInfoSchema,
+	subtype: z.literal("file-attachment")
+});
+const FileAttachmentWireDraftSchema = z.object({
+	...ColorStyleDraftShape,
+	...AnnotationDraftBaseShape,
+	rect: PdfRectSchema,
+	file: WireAttachmentFileSchema,
+	icon: FileAttachmentIconSchema.optional(),
+	subtype: z.literal("file-attachment")
+});
+const FileAttachmentPatchSchema = z.object({
+	...ColorStylePatchShape,
+	...AnnotationPatchBaseShape,
+	rect: PdfRectSchema.optional(),
+	icon: FileAttachmentIconSchema.optional(),
+	subtype: z.literal("file-attachment")
+});
+//#endregion
+//#region src/annotation/kinds/file-attachment/index.ts
+/**
+* WIRE-typed like `StampKind`: the draft schema validates the
+* post-normalization form (`file` as metadata + resource ref). The
+* authoring `FileAttachmentDraft` (inline bytes) is swapped into the
+* public `AnnotationDraft` union in `kinds/index.ts`. The patch carries
+* no binary (`file` is create-only), so its authoring and wire forms are
+* the same type.
+*/
+const FileAttachmentKind = {
+	subtype: "file-attachment",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.FILEATTACHMENT,
+	dtoSchema: FileAttachmentDTOSchema,
+	draftSchema: FileAttachmentWireDraftSchema,
+	patchSchema: FileAttachmentPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/free-text/schema.ts
+/** Authoring `fontFamily`: a standard font name OR a registered font `key`.
+*  Any non-empty string is accepted; the writer resolves which it is (and a
+*  key that was never registered fails loud there). The read-back DTO keeps the
+*  narrower {@link StandardFontSchema}. */
+const FreeTextFontSchema = z.string().min(1);
+const FreeTextDTOSchema = z.object({
+	...AnnotationBaseShape,
+	intent: FreeTextIntentSchema,
+	fontFamily: StandardFontSchema,
+	fontSize: z.number().positive(),
+	textAlign: TextAlignmentSchema,
+	color: ColorSchema,
+	fontColor: ColorSchema.optional(),
+	interiorColor: ColorSchema.nullable(),
+	opacity: z.number().min(0).max(1),
+	strokeWidth: z.number().nonnegative(),
+	borderStyle: AnnotationBorderStyleSchema,
+	dashArray: z.array(z.number().nonnegative()).optional(),
+	rectDifferences: PdfRectDifferencesSchema.nullable(),
+	calloutLine: CalloutLineSchema.optional(),
+	lineEnding: LineEndingSchema.optional(),
+	rotation: z.number().optional(),
+	unrotatedRect: PdfRectSchema.optional(),
+	subtype: z.literal("free-text")
+});
+const FreeTextDraftSchema = z.object({
+	...AnnotationDraftBaseShape,
+	intent: FreeTextIntentSchema,
+	fontFamily: FreeTextFontSchema,
+	fontSize: z.number().positive(),
+	textAlign: TextAlignmentSchema,
+	rect: PdfRectSchema,
+	color: ColorSchema.optional(),
+	fontColor: ColorSchema.optional(),
+	interiorColor: ColorSchema.nullable().optional(),
+	opacity: z.number().min(0).max(1).optional(),
+	strokeWidth: z.number().nonnegative().optional(),
+	borderStyle: AnnotationBorderStyleSchema.optional(),
+	dashArray: z.array(z.number().nonnegative()).optional(),
+	rectDifferences: PdfRectDifferencesSchema.nullable().optional(),
+	calloutLine: CalloutLineSchema.optional(),
+	lineEnding: LineEndingSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	unrotatedRect: PdfRectSchema.nullable().optional(),
+	subtype: z.literal("free-text")
+});
+const FreeTextPatchSchema = z.object({
+	...AnnotationPatchBaseShape,
+	intent: FreeTextIntentSchema.optional(),
+	fontFamily: FreeTextFontSchema.optional(),
+	fontSize: z.number().positive().optional(),
+	textAlign: TextAlignmentSchema.optional(),
+	rect: PdfRectSchema.optional(),
+	color: ColorSchema.optional(),
+	fontColor: ColorSchema.optional(),
+	interiorColor: ColorSchema.nullable().optional(),
+	opacity: z.number().min(0).max(1).optional(),
+	strokeWidth: z.number().nonnegative().optional(),
+	borderStyle: AnnotationBorderStyleSchema.optional(),
+	dashArray: z.array(z.number().nonnegative()).optional(),
+	rectDifferences: PdfRectDifferencesSchema.nullable().optional(),
+	calloutLine: CalloutLineSchema.optional(),
+	lineEnding: LineEndingSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	unrotatedRect: PdfRectSchema.nullable().optional(),
+	subtype: z.literal("free-text")
+});
+//#endregion
+//#region src/annotation/kinds/free-text/index.ts
+const FreeTextKind = {
+	subtype: "free-text",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.FREETEXT,
+	dtoSchema: FreeTextDTOSchema,
+	draftSchema: FreeTextDraftSchema,
+	patchSchema: FreeTextPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/text-markup.shared.ts
+const TextMarkupDTOShape = {
+	...AnnotationBaseShape,
+	...ColorStyleDTOShape,
+	quadPoints: z.array(PdfQuadSchema)
+};
+const TextMarkupDraftShape = {
+	...ColorStyleDraftShape,
+	quadPoints: z.array(PdfQuadSchema)
+};
+const TextMarkupPatchShape = {
+	...ColorStylePatchShape,
+	quadPoints: z.array(PdfQuadSchema).optional()
+};
+//#endregion
+//#region src/annotation/kinds/highlight/schema.ts
+const HighlightDTOSchema = z.object({
+	...TextMarkupDTOShape,
+	subtype: z.literal("highlight")
+});
+const HighlightDraftSchema = z.object({
+	...TextMarkupDraftShape,
+	...AnnotationDraftBaseShape,
+	subtype: z.literal("highlight")
+});
+const HighlightPatchSchema = z.object({
+	...TextMarkupPatchShape,
+	...AnnotationPatchBaseShape,
+	subtype: z.literal("highlight")
+});
+//#endregion
+//#region src/annotation/kinds/highlight/index.ts
+const HighlightKind = {
+	subtype: "highlight",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.HIGHLIGHT,
+	dtoSchema: HighlightDTOSchema,
+	draftSchema: HighlightDraftSchema,
+	patchSchema: HighlightPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/ink/schema.ts
+const InkDTOSchema = z.object({
+	...AnnotationBaseShape,
+	...GeometryStyleDTOShape,
+	intent: InkIntentSchema.nullable(),
+	inkList: InkListSchema,
+	rotation: z.number().optional(),
+	subtype: z.literal("ink")
+});
+const InkDraftSchema = z.object({
+	...GeometryStyleDraftShape,
+	...AnnotationDraftBaseShape,
+	intent: InkIntentSchema.optional(),
+	inkList: InkListSchema,
+	rect: PdfRectSchema,
+	rotation: z.number().nullable().optional(),
+	subtype: z.literal("ink")
+});
+const InkPatchSchema = z.object({
+	...GeometryStylePatchShape,
+	...AnnotationPatchBaseShape,
+	intent: InkIntentSchema.optional(),
+	inkList: InkListSchema.optional(),
+	rect: PdfRectSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	subtype: z.literal("ink")
+});
+//#endregion
+//#region src/annotation/kinds/ink/index.ts
+const InkKind = {
+	subtype: "ink",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.INK,
+	dtoSchema: InkDTOSchema,
+	draftSchema: InkDraftSchema,
+	patchSchema: InkPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/line/schema.ts
+const LineDTOSchema = z.object({
+	...AnnotationBaseShape,
+	...FilledStyleDTOShape,
+	linePoints: LinePointsSchema,
+	lineEndings: LineEndingsSchema,
+	rotation: z.number().optional(),
+	subtype: z.literal("line")
+});
+const LineDraftSchema = z.object({
+	...FilledStyleDraftShape,
+	...AnnotationDraftBaseShape,
+	linePoints: LinePointsSchema,
+	rect: PdfRectSchema,
+	lineEndings: LineEndingsSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	subtype: z.literal("line")
+});
+const LinePatchSchema = z.object({
+	...FilledStylePatchShape,
+	...AnnotationPatchBaseShape,
+	linePoints: LinePointsSchema.optional(),
+	rect: PdfRectSchema.optional(),
+	lineEndings: LineEndingsSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	subtype: z.literal("line")
+});
+//#endregion
+//#region src/annotation/kinds/line/index.ts
+const LineKind = {
+	subtype: "line",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.LINE,
+	dtoSchema: LineDTOSchema,
+	draftSchema: LineDraftSchema,
+	patchSchema: LinePatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/link/schema.ts
+const pageObjectNumber = z.number().int().positive();
+/** Spec-nullable axis value: absent and `null` both mean "retain current". */
+const axis = z.number().nullable().optional();
+/**
+* Runtime schema for {@link PdfDestination}. Lives with the link kind (its
+* first wire consumer); the outline/bookmark port reuses it from here.
+*/
+const PdfDestinationSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("xyz"),
+		pageObjectNumber,
+		left: axis,
+		top: axis,
+		zoom: axis
+	}),
+	z.object({
+		kind: z.literal("fit"),
+		pageObjectNumber
+	}),
+	z.object({
+		kind: z.literal("fitH"),
+		pageObjectNumber,
+		top: axis
+	}),
+	z.object({
+		kind: z.literal("fitV"),
+		pageObjectNumber,
+		left: axis
+	}),
+	z.object({
+		kind: z.literal("fitR"),
+		pageObjectNumber,
+		left: z.number(),
+		bottom: z.number(),
+		right: z.number(),
+		top: z.number()
+	}),
+	z.object({
+		kind: z.literal("fitB"),
+		pageObjectNumber
+	}),
+	z.object({
+		kind: z.literal("fitBH"),
+		pageObjectNumber,
+		top: axis
+	}),
+	z.object({
+		kind: z.literal("fitBV"),
+		pageObjectNumber,
+		left: axis
+	})
+]);
+const GotoTargetSchema = z.object({
+	kind: z.literal("goto"),
+	destination: PdfDestinationSchema
+});
+const UriTargetSchema = z.object({
+	kind: z.literal("uri"),
+	uri: z.string()
+});
+const PdfLinkTargetSchema = z.discriminatedUnion("kind", [
+	GotoTargetSchema,
+	UriTargetSchema,
+	z.object({
+		kind: z.literal("goto-remote"),
+		file: z.string()
+	}),
+	z.object({
+		kind: z.literal("launch"),
+		path: z.string()
+	}),
+	z.object({ kind: z.literal("javascript") }),
+	z.object({
+		kind: z.literal("named"),
+		name: z.string()
+	}),
+	z.object({ kind: z.literal("unsupported") })
+]);
+/** Drafts/patches only author `goto`/`uri` — see {@link PdfLinkTargetWritable}. */
+const PdfLinkTargetWritableSchema = z.discriminatedUnion("kind", [GotoTargetSchema, UriTargetSchema]);
+const LinkDTOSchema = z.object({
+	...AnnotationBaseShape,
+	subtype: z.literal("link"),
+	target: PdfLinkTargetSchema.nullable()
+});
+const LinkDraftSchema = z.object({
+	...AnnotationDraftBaseShape,
+	subtype: z.literal("link"),
+	rect: PdfRectSchema,
+	target: PdfLinkTargetWritableSchema.nullable()
+});
+const LinkPatchSchema = z.object({
+	...AnnotationPatchBaseShape,
+	subtype: z.literal("link"),
+	rect: PdfRectSchema.optional(),
+	target: PdfLinkTargetWritableSchema.nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/link/index.ts
+const LinkKind = {
+	subtype: "link",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.LINK,
+	dtoSchema: LinkDTOSchema,
+	draftSchema: LinkDraftSchema,
+	patchSchema: LinkPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/vertex.shared.ts
+const VertexDTOShape = {
+	...AnnotationBaseShape,
+	...FilledStyleDTOShape,
+	vertices: z.array(PdfPointSchema),
+	rotation: z.number().optional()
+};
+const VertexDraftShape = {
+	...FilledStyleDraftShape,
+	vertices: z.array(PdfPointSchema),
+	rect: PdfRectSchema,
+	rotation: z.number().nullable().optional()
+};
+const VertexPatchShape = {
+	...FilledStylePatchShape,
+	vertices: z.array(PdfPointSchema).optional(),
+	rect: PdfRectSchema.optional(),
+	rotation: z.number().nullable().optional()
+};
+//#endregion
+//#region src/annotation/kinds/polygon/schema.ts
+const PolygonDTOSchema = z.object({
+	...VertexDTOShape,
+	vertices: z.array(PdfPointSchema).min(3),
+	cloudyIntensity: z.number().positive().nullable(),
+	subtype: z.literal("polygon")
+});
+const PolygonDraftSchema = z.object({
+	...VertexDraftShape,
+	...AnnotationDraftBaseShape,
+	vertices: z.array(PdfPointSchema).min(3),
+	cloudyIntensity: z.number().positive().nullable().optional(),
+	subtype: z.literal("polygon")
+});
+const PolygonPatchSchema = z.object({
+	...VertexPatchShape,
+	...AnnotationPatchBaseShape,
+	vertices: z.array(PdfPointSchema).min(3).optional(),
+	cloudyIntensity: z.number().positive().nullable().optional(),
+	subtype: z.literal("polygon")
+});
+//#endregion
+//#region src/annotation/kinds/polygon/index.ts
+const PolygonKind = {
+	subtype: "polygon",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.POLYGON,
+	dtoSchema: PolygonDTOSchema,
+	draftSchema: PolygonDraftSchema,
+	patchSchema: PolygonPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/polyline/schema.ts
+const PolylineDTOSchema = z.object({
+	...VertexDTOShape,
+	vertices: z.array(PdfPointSchema).min(2),
+	lineEndings: LineEndingsSchema,
+	subtype: z.literal("polyline")
+});
+const PolylineDraftSchema = z.object({
+	...VertexDraftShape,
+	...AnnotationDraftBaseShape,
+	vertices: z.array(PdfPointSchema).min(2),
+	lineEndings: LineEndingsSchema.optional(),
+	subtype: z.literal("polyline")
+});
+const PolylinePatchSchema = z.object({
+	...VertexPatchShape,
+	...AnnotationPatchBaseShape,
+	vertices: z.array(PdfPointSchema).min(2).optional(),
+	lineEndings: LineEndingsSchema.optional(),
+	subtype: z.literal("polyline")
+});
+//#endregion
+//#region src/annotation/kinds/polyline/index.ts
+const PolylineKind = {
+	subtype: "polyline",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.POLYLINE,
+	dtoSchema: PolylineDTOSchema,
+	draftSchema: PolylineDraftSchema,
+	patchSchema: PolylinePatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/redact/schema.ts
+/** Authoring `fontFamily`: a standard font name OR a registered font `key`.
+*  Any non-empty string is accepted; the writer resolves which it is (and a
+*  key that was never registered fails loud there). The read-back DTO keeps
+*  the narrower {@link StandardFontSchema}. */
+const RedactFontSchema = z.string().min(1);
+/** `/DA` size — unlike free text, `0` is meaningful for a redaction label:
+*  auto-fit to the region. */
+const RedactFontSizeSchema = z.number().nonnegative();
+const RedactDTOSchema = z.object({
+	...AnnotationBaseShape,
+	quadPoints: z.array(PdfQuadSchema),
+	color: ColorSchema,
+	opacity: z.number().min(0).max(1),
+	interiorColor: ColorSchema.nullable(),
+	overlayText: z.string().nullable(),
+	repeat: z.boolean(),
+	fontFamily: StandardFontSchema,
+	fontSize: RedactFontSizeSchema,
+	fontColor: ColorSchema,
+	textAlign: TextAlignmentSchema,
+	subtype: z.literal("redact")
+});
+const RedactDraftSchema = z.object({
+	...AnnotationDraftBaseShape,
+	rect: PdfRectSchema,
+	quadPoints: z.array(PdfQuadSchema).optional(),
+	color: ColorSchema.optional(),
+	opacity: z.number().min(0).max(1).optional(),
+	interiorColor: ColorSchema.nullable().optional(),
+	overlayText: z.string().optional(),
+	repeat: z.boolean().optional(),
+	fontFamily: RedactFontSchema.optional(),
+	fontSize: RedactFontSizeSchema.optional(),
+	fontColor: ColorSchema.optional(),
+	textAlign: TextAlignmentSchema.optional(),
+	subtype: z.literal("redact")
+});
+const RedactPatchSchema = z.object({
+	...AnnotationPatchBaseShape,
+	rect: PdfRectSchema.optional(),
+	quadPoints: z.array(PdfQuadSchema).optional(),
+	color: ColorSchema.optional(),
+	opacity: z.number().min(0).max(1).optional(),
+	interiorColor: ColorSchema.nullable().optional(),
+	overlayText: z.string().nullable().optional(),
+	repeat: z.boolean().optional(),
+	fontFamily: RedactFontSchema.optional(),
+	fontSize: RedactFontSizeSchema.optional(),
+	fontColor: ColorSchema.optional(),
+	textAlign: TextAlignmentSchema.optional(),
+	subtype: z.literal("redact")
+});
+//#endregion
+//#region src/annotation/kinds/redact/index.ts
+const RedactKind = {
+	subtype: "redact",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.REDACT,
+	dtoSchema: RedactDTOSchema,
+	draftSchema: RedactDraftSchema,
+	patchSchema: RedactPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/square/schema.ts
+const SquareDTOSchema = z.object({
+	...ShapeDTOShape,
+	subtype: z.literal("square")
+});
+const SquareDraftSchema = z.object({
+	...ShapeDraftShape,
+	...AnnotationDraftBaseShape,
+	subtype: z.literal("square")
+});
+const SquarePatchSchema = z.object({
+	...ShapePatchShape,
+	...AnnotationPatchBaseShape,
+	subtype: z.literal("square")
+});
+//#endregion
+//#region src/annotation/kinds/square/index.ts
+const SquareKind = {
+	subtype: "square",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.SQUARE,
+	dtoSchema: SquareDTOSchema,
+	draftSchema: SquareDraftSchema,
+	patchSchema: SquarePatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/squiggly/schema.ts
+const SquigglyDTOSchema = z.object({
+	...TextMarkupDTOShape,
+	subtype: z.literal("squiggly")
+});
+const SquigglyDraftSchema = z.object({
+	...TextMarkupDraftShape,
+	...AnnotationDraftBaseShape,
+	subtype: z.literal("squiggly")
+});
+const SquigglyPatchSchema = z.object({
+	...TextMarkupPatchShape,
+	...AnnotationPatchBaseShape,
+	subtype: z.literal("squiggly")
+});
+//#endregion
+//#region src/annotation/kinds/squiggly/index.ts
+const SquigglyKind = {
+	subtype: "squiggly",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.SQUIGGLY,
+	dtoSchema: SquigglyDTOSchema,
+	draftSchema: SquigglyDraftSchema,
+	patchSchema: SquigglyPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/stamp/schema.ts
+/**
+* Schemas validate the WIRE forms. The authoring types (`StampDraft`,
+* `StampPatch`) carry inline `BinarySource` bytes and are normalized to
+* these shapes before validation — see `annotation/normalize.ts`.
+*/
+const ResourceRefSchema = z.object({ resource: z.string().min(1) });
+const StampFitSchema = z.enum([
+	"contain",
+	"cover",
+	"fill"
+]);
+const StampDTOSchema = z.object({
+	...AnnotationBaseShape,
+	name: z.string().nullable(),
+	rotation: z.number().optional(),
+	unrotatedRect: PdfRectSchema.optional(),
+	subtype: z.literal("stamp")
+});
+const StampWireDraftSchema = z.object({
+	...AnnotationDraftBaseShape,
+	rect: PdfRectSchema,
+	source: ResourceRefSchema,
+	name: z.string().optional(),
+	fit: StampFitSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	unrotatedRect: PdfRectSchema.nullable().optional(),
+	subtype: z.literal("stamp")
+});
+const StampWirePatchSchema = z.object({
+	...AnnotationPatchBaseShape,
+	rect: PdfRectSchema.optional(),
+	source: ResourceRefSchema.optional(),
+	name: z.string().optional(),
+	fit: StampFitSchema.optional(),
+	rotation: z.number().nullable().optional(),
+	unrotatedRect: PdfRectSchema.nullable().optional(),
+	subtype: z.literal("stamp")
+});
+//#endregion
+//#region src/annotation/kinds/stamp/index.ts
+/**
+* The kind module is WIRE-typed (schemas validate the post-normalization
+* form). The authoring types with inline bytes (`StampDraft`, `StampPatch`)
+* are swapped into the public `AnnotationDraft`/`AnnotationPatch` unions in
+* `kinds/index.ts`; `annotation/normalize.ts` bridges the two.
+*/
+const StampKind = {
+	subtype: "stamp",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.STAMP,
+	dtoSchema: StampDTOSchema,
+	draftSchema: StampWireDraftSchema,
+	patchSchema: StampWirePatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/strikeout/schema.ts
+const StrikeoutDTOSchema = z.object({
+	...TextMarkupDTOShape,
+	intent: StrikeoutIntentSchema.nullable(),
+	subtype: z.literal("strikeout")
+});
+const StrikeoutDraftSchema = z.object({
+	...TextMarkupDraftShape,
+	...AnnotationDraftBaseShape,
+	intent: StrikeoutIntentSchema.optional(),
+	subtype: z.literal("strikeout")
+});
+const StrikeoutPatchSchema = z.object({
+	...TextMarkupPatchShape,
+	...AnnotationPatchBaseShape,
+	intent: StrikeoutIntentSchema.optional(),
+	subtype: z.literal("strikeout")
+});
+//#endregion
+//#region src/annotation/kinds/strikeout/index.ts
+const StrikeoutKind = {
+	subtype: "strikeout",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.STRIKEOUT,
+	dtoSchema: StrikeoutDTOSchema,
+	draftSchema: StrikeoutDraftSchema,
+	patchSchema: StrikeoutPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/text/schema.ts
+const NoteIconSchema = z.enum([
+	"comment",
+	"key",
+	"note",
+	"help",
+	"new-paragraph",
+	"paragraph",
+	"insert"
+]);
+const TextDTOSchema = z.object({
+	...AnnotationBaseShape,
+	...ColorStyleDTOShape,
+	icon: NoteIconSchema,
+	subtype: z.literal("text")
+});
+const TextDraftSchema = z.object({
+	...ColorStyleDraftShape,
+	...AnnotationDraftBaseShape,
+	rect: PdfRectSchema,
+	icon: NoteIconSchema.optional(),
+	subtype: z.literal("text")
+});
+const TextPatchSchema = z.object({
+	...ColorStylePatchShape,
+	...AnnotationPatchBaseShape,
+	rect: PdfRectSchema.optional(),
+	icon: NoteIconSchema.optional(),
+	subtype: z.literal("text")
+});
+//#endregion
+//#region src/annotation/kinds/text/index.ts
+const TextKind = {
+	subtype: "text",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.TEXT,
+	dtoSchema: TextDTOSchema,
+	draftSchema: TextDraftSchema,
+	patchSchema: TextPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/underline/schema.ts
+const UnderlineDTOSchema = z.object({
+	...TextMarkupDTOShape,
+	subtype: z.literal("underline")
+});
+const UnderlineDraftSchema = z.object({
+	...TextMarkupDraftShape,
+	...AnnotationDraftBaseShape,
+	subtype: z.literal("underline")
+});
+const UnderlinePatchSchema = z.object({
+	...TextMarkupPatchShape,
+	...AnnotationPatchBaseShape,
+	subtype: z.literal("underline")
+});
+//#endregion
+//#region src/annotation/kinds/underline/index.ts
+const UnderlineKind = {
+	subtype: "underline",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.UNDERLINE,
+	dtoSchema: UnderlineDTOSchema,
+	draftSchema: UnderlineDraftSchema,
+	patchSchema: UnderlinePatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/unsupported/schema.ts
+const UnsupportedDTOSchema = z.object({
+	...AnnotationBaseShape,
+	subtype: z.literal("unsupported"),
+	rawSubtypeCode: z.number().int(),
+	rawSubtypeName: z.string().nullable()
+});
+const UnsupportedDraftSchema = z.never();
+const UnsupportedPatchSchema = z.never();
+//#endregion
+//#region src/annotation/kinds/unsupported/index.ts
+const UnsupportedKind = {
+	subtype: "unsupported",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.UNKNOWN,
+	dtoSchema: UnsupportedDTOSchema,
+	draftSchema: UnsupportedDraftSchema,
+	patchSchema: UnsupportedPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/widget.shared.ts
+const WidgetStyleDTOShape = {
+	color: ColorSchema.nullable(),
+	interiorColor: ColorSchema.nullable(),
+	strokeWidth: z.number().nonnegative(),
+	borderStyle: AnnotationBorderStyleSchema,
+	fontFamily: StandardFontSchema.optional(),
+	fontSize: z.number().nonnegative().optional(),
+	fontColor: ColorSchema.optional(),
+	textAlign: TextAlignmentSchema
+};
+const WidgetStyleDraftShape = {
+	color: ColorSchema.nullable().optional(),
+	interiorColor: ColorSchema.nullable().optional(),
+	strokeWidth: z.number().nonnegative().optional(),
+	borderStyle: AnnotationBorderStyleSchema.optional(),
+	fontFamily: StandardFontSchema.optional(),
+	fontSize: z.number().nonnegative().optional(),
+	fontColor: ColorSchema.optional(),
+	textAlign: TextAlignmentSchema.optional()
+};
+const WidgetStylePatchShape = WidgetStyleDraftShape;
+const WidgetAppearanceSchema = z.object(WidgetStyleDraftShape);
+//#endregion
+//#region src/annotation/kinds/widget/schema.ts
+const WidgetDTOSchema = z.object({
+	...AnnotationBaseShape,
+	...WidgetStyleDTOShape,
+	subtype: z.literal("widget"),
+	fieldObjectNumber: z.number().int().nonnegative(),
+	fieldFamily: z.enum([
+		"text",
+		"checkbox",
+		"radio",
+		"combobox",
+		"listbox",
+		"pushbutton",
+		"signature",
+		"unknown"
+	])
+});
+const WidgetDraftSchema = z.object({
+	...AnnotationDraftBaseShape,
+	...WidgetStyleDraftShape,
+	subtype: z.literal("widget"),
+	rect: PdfRectSchema
+});
+const WidgetPatchSchema = z.object({
+	...AnnotationPatchBaseShape,
+	...WidgetStylePatchShape,
+	subtype: z.literal("widget"),
+	rect: PdfRectSchema.optional()
+});
+//#endregion
+//#region src/annotation/kinds/widget/index.ts
+const WidgetKind = {
+	subtype: "widget",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.WIDGET,
+	dtoSchema: WidgetDTOSchema,
+	draftSchema: WidgetDraftSchema,
+	patchSchema: WidgetPatchSchema
+};
+//#endregion
+//#region src/annotation/kinds/index.ts
+/**
+* The closed-world catalog of currently-implemented annotation kinds.
+*
+* Adding a new subtype is one folder under `kinds/<name>/` exporting the
+* five files (dto, draft, patch, schema, index) and one entry in this
+* tuple. The discriminated unions and zod discriminator below regenerate
+* automatically; no other file in the package needs to change.
+*
+* Every subtype the engine has not yet wired up rides on
+* `UnsupportedKind`. The wire format is stable: when a per-subtype reader
+* lands later, the engine starts emitting the dedicated DTO instead of
+* `unsupported`, and existing clients widen their handling without a
+* version bump.
+*/
+const ANNOTATION_KINDS = [
+	HighlightKind,
+	UnderlineKind,
+	SquigglyKind,
+	StrikeoutKind,
+	CircleKind,
+	SquareKind,
+	PolygonKind,
+	PolylineKind,
+	LineKind,
+	LinkKind,
+	InkKind,
+	FreeTextKind,
+	CaretKind,
+	TextKind,
+	StampKind,
+	FileAttachmentKind,
+	WidgetKind,
+	RedactKind,
+	UnsupportedKind
+];
+/**
+* Lookup helper for the engine's reader catalog and identity resolver.
+* O(1) by `subtype` literal at runtime.
+*/
+const KIND_BY_SUBTYPE = Object.freeze(Object.fromEntries(ANNOTATION_KINDS.map((kind) => [kind.subtype, kind])));
+/**
+* Runtime zod schema for the discriminated union. The cast unwinds the
+* generic schema map into the specific tuple form `discriminatedUnion`
+* needs. Servers and cloud clients use this to validate every annotation
+* payload on the wire.
+*/
+const AnnotationDTOSchema = z.discriminatedUnion("subtype", [
+	HighlightKind.dtoSchema,
+	UnderlineKind.dtoSchema,
+	SquigglyKind.dtoSchema,
+	StrikeoutKind.dtoSchema,
+	CircleKind.dtoSchema,
+	SquareKind.dtoSchema,
+	PolygonKind.dtoSchema,
+	PolylineKind.dtoSchema,
+	LineKind.dtoSchema,
+	LinkKind.dtoSchema,
+	InkKind.dtoSchema,
+	FreeTextKind.dtoSchema,
+	CaretKind.dtoSchema,
+	TextKind.dtoSchema,
+	StampKind.dtoSchema,
+	FileAttachmentKind.dtoSchema,
+	WidgetKind.dtoSchema,
+	RedactKind.dtoSchema,
+	UnsupportedKind.dtoSchema
+]);
+/**
+* Validates the WIRE draft form (post-normalization) — binary-carrying
+* kinds appear here with `{ resource }` refs, never inline bytes.
+*/
+const AnnotationDraftSchema = z.discriminatedUnion("subtype", [
+	HighlightKind.draftSchema,
+	UnderlineKind.draftSchema,
+	SquigglyKind.draftSchema,
+	StrikeoutKind.draftSchema,
+	CircleKind.draftSchema,
+	SquareKind.draftSchema,
+	PolygonKind.draftSchema,
+	PolylineKind.draftSchema,
+	LineKind.draftSchema,
+	LinkKind.draftSchema,
+	InkKind.draftSchema,
+	FreeTextKind.draftSchema,
+	CaretKind.draftSchema,
+	TextKind.draftSchema,
+	StampKind.draftSchema,
+	FileAttachmentKind.draftSchema,
+	WidgetKind.draftSchema,
+	RedactKind.draftSchema
+]);
+/** Validates the WIRE patch form (post-normalization). */
+const AnnotationPatchSchema = z.discriminatedUnion("subtype", [
+	HighlightKind.patchSchema,
+	UnderlineKind.patchSchema,
+	SquigglyKind.patchSchema,
+	StrikeoutKind.patchSchema,
+	CircleKind.patchSchema,
+	SquareKind.patchSchema,
+	PolygonKind.patchSchema,
+	PolylineKind.patchSchema,
+	LineKind.patchSchema,
+	LinkKind.patchSchema,
+	InkKind.patchSchema,
+	FreeTextKind.patchSchema,
+	CaretKind.patchSchema,
+	TextKind.patchSchema,
+	StampKind.patchSchema,
+	FileAttachmentKind.patchSchema,
+	WidgetKind.patchSchema,
+	RedactKind.patchSchema
+]);
+//#endregion
+//#region src/forms/schema.ts
+const FormFieldRefSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("objectNumber"),
+	fieldObjectNumber: z.number().int().positive()
+}), z.object({
+	kind: z.literal("fqn"),
+	name: z.string().min(1)
+})]);
+const FormWidgetRefShape = {
+	annotObjectNumber: z.number().int().nonnegative(),
+	pageObjectNumber: z.number().int().nonnegative()
+};
+const FormWidgetRefSchema = z.object(FormWidgetRefShape);
+const FormFieldFlagsSchema = z.object({
+	readOnly: z.boolean(),
+	required: z.boolean(),
+	noExport: z.boolean(),
+	raw: z.number().int().nonnegative()
+});
+const ToggleFieldWidgetSchema = z.object({
+	...FormWidgetRefShape,
+	onState: z.string(),
+	exportValue: z.string(),
+	checked: z.boolean()
+});
+const FormFieldOptionSchema = z.object({
+	label: z.string(),
+	value: z.string(),
+	selected: z.boolean()
+});
+const FormValueEntrySchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }),
+	z.object({
+		kind: z.literal("scalar"),
+		value: z.string()
+	}),
+	z.object({
+		kind: z.literal("array"),
+		values: z.array(z.string())
+	}),
+	z.object({ kind: z.literal("unsupported") })
+]);
+const FormFieldBaseShape = {
+	ref: FormFieldRefSchema,
+	fieldObjectNumber: z.number().int().nonnegative(),
+	name: z.string(),
+	origin: z.enum(["acroform", "recovered"]),
+	flags: FormFieldFlagsSchema,
+	alternateName: z.string().nullable(),
+	mappingName: z.string().nullable(),
+	valueEntry: FormValueEntrySchema,
+	defaultValueEntry: FormValueEntrySchema,
+	actions: PdfFieldActionsSchema.optional(),
+	widgets: z.array(FormWidgetRefSchema)
+};
+const FormFieldDTOSchema = z.discriminatedUnion("family", [
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("text"),
+		value: z.string(),
+		defaultValue: z.string(),
+		maxLength: z.number().int().positive().nullable(),
+		multiline: z.boolean(),
+		password: z.boolean(),
+		comb: z.boolean()
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("checkbox"),
+		checked: z.boolean(),
+		exportValue: z.string(),
+		widgets: z.array(ToggleFieldWidgetSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("radio"),
+		value: z.string(),
+		radiosInUnison: z.boolean(),
+		noToggleToOff: z.boolean(),
+		widgets: z.array(ToggleFieldWidgetSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("combobox"),
+		value: z.string(),
+		defaultValue: z.string(),
+		edit: z.boolean(),
+		options: z.array(FormFieldOptionSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("listbox"),
+		selectedValues: z.array(z.string()),
+		multiSelect: z.boolean(),
+		options: z.array(FormFieldOptionSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("pushbutton")
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("signature")
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("unknown"),
+		rawValue: z.string()
+	})
+]);
+const FormKindSchema = z.enum([
+	"none",
+	"acroform",
+	"xfa"
+]);
+const FormSnapshotSchema = z.object({
+	formKind: FormKindSchema,
+	needsAppearances: z.boolean(),
+	fields: z.array(FormFieldDTOSchema),
+	calculationOrder: z.array(FormFieldRefSchema.nullable())
+});
+const FormFieldValueSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("text"),
+		value: z.string()
+	}),
+	z.object({
+		type: z.literal("toggle"),
+		state: z.string().nullable()
+	}),
+	z.object({
+		type: z.literal("choice"),
+		values: z.array(z.string())
+	})
+]);
+const FormDataFormatSchema = z.enum(["fdf", "xfdf"]);
+const WidgetPlacementSchema = z.object({
+	pageObjectNumber: z.number().int().positive(),
+	rect: PdfRectSchema,
+	onState: z.string().min(1).optional(),
+	appearance: WidgetAppearanceSchema.optional()
+});
+const FormFieldOptionInputSchema = z.object({
+	label: z.string(),
+	value: z.string()
+});
+const FormFieldDraftBaseShape = {
+	name: z.string().min(1),
+	readOnly: z.boolean().optional(),
+	required: z.boolean().optional(),
+	noExport: z.boolean().optional(),
+	alternateName: z.string().optional(),
+	mappingName: z.string().optional()
+};
+const FormFieldDraftSchema = z.discriminatedUnion("family", [
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("text"),
+		defaultValue: z.string().optional(),
+		maxLength: z.number().int().positive().optional(),
+		multiline: z.boolean().optional(),
+		password: z.boolean().optional(),
+		comb: z.boolean().optional(),
+		widget: WidgetPlacementSchema.optional()
+	}),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("checkbox"),
+		widget: WidgetPlacementSchema.optional()
+	}),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("radio"),
+		radiosInUnison: z.boolean().optional(),
+		noToggleToOff: z.boolean().optional(),
+		widgets: z.array(WidgetPlacementSchema).optional()
+	}),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("combobox"),
+		edit: z.boolean().optional(),
+		options: z.array(FormFieldOptionInputSchema).optional(),
+		defaultValue: z.string().optional(),
+		widget: WidgetPlacementSchema.optional()
+	}),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("listbox"),
+		multiSelect: z.boolean().optional(),
+		options: z.array(FormFieldOptionInputSchema).optional(),
+		widget: WidgetPlacementSchema.optional()
+	})
+]);
+const FormFieldPatchBaseShape = {
+	name: z.string().min(1).optional(),
+	readOnly: z.boolean().optional(),
+	required: z.boolean().optional(),
+	noExport: z.boolean().optional(),
+	alternateName: z.string().nullable().optional(),
+	mappingName: z.string().nullable().optional()
+};
+const FormFieldPatchSchema = z.discriminatedUnion("family", [
+	z.object({
+		...FormFieldPatchBaseShape,
+		family: z.literal("text"),
+		defaultValue: z.string().nullable().optional(),
+		maxLength: z.number().int().positive().nullable().optional(),
+		multiline: z.boolean().optional(),
+		password: z.boolean().optional(),
+		comb: z.boolean().optional()
+	}),
+	z.object({
+		...FormFieldPatchBaseShape,
+		family: z.literal("checkbox")
+	}),
+	z.object({
+		...FormFieldPatchBaseShape,
+		family: z.literal("radio"),
+		radiosInUnison: z.boolean().optional(),
+		noToggleToOff: z.boolean().optional()
+	}),
+	z.object({
+		...FormFieldPatchBaseShape,
+		family: z.literal("combobox"),
+		edit: z.boolean().optional(),
+		defaultValue: z.string().nullable().optional(),
+		options: z.array(FormFieldOptionInputSchema).optional()
+	}),
+	z.object({
+		...FormFieldPatchBaseShape,
+		family: z.literal("listbox"),
+		multiSelect: z.boolean().optional(),
+		options: z.array(FormFieldOptionInputSchema).optional()
+	})
+]);
+//#endregion
+//#region src/wire/schemas.ts
+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(),
+	created: z.string().datetime().nullable(),
+	modified: z.string().datetime().nullable(),
+	trapped: z.enum([
+		"true",
+		"false",
+		"unknown"
+	]),
+	custom: z.record(z.string(), z.string())
+});
+/**
+* Three-state metadata patch. Mirrors annotation patch semantics:
+* `undefined` leaves a field, `null` clears it, a value sets it. `custom`
+* is a per-key three-state map (string set / null clear / absent leave).
+*/
+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(),
+	created: z.string().datetime().nullable().optional(),
+	modified: z.string().datetime().nullable().optional(),
+	trapped: z.enum([
+		"true",
+		"false",
+		"unknown"
+	]).optional(),
+	custom: z.record(z.string(), z.string().nullable()).optional()
+}).strict();
+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, per-page weak-flag), which
+* makes `/manifest@docVersion=N` fully content-addressed and cache-friendly.
+* Phase 4 hard-codes it to `1`; Phase 5's mutation handler is what
+* actually bumps it.
+*/
+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({
+	docId: z.string().min(1),
+	layerName: z.string().min(1).optional(),
+	password: z.string().optional(),
+	passwordGrant: z.string().optional(),
+	mode: z.enum(["any", "owner"]).optional()
+});
+/**
+* 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 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()),
+	identity: z.object({
+		user_id: z.string().optional(),
+		group_id: z.string().optional(),
+		groups: z.array(z.string()).optional(),
+		display_name: z.string().optional()
+	}),
+	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()
+});
+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 WeakAnnotationStateSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("unknown") }), z.object({
+	kind: z.literal("known"),
+	hasAnyWeakAnnotations: z.boolean()
+})]);
+const PageStateSchema = z.object({
+	pageObjectNumber: z.number().int().positive(),
+	revision: RevisionTokenSchema,
+	weakAnnotationState: WeakAnnotationStateSchema
+});
+const CachePinsSchema = z.object({
+	contentVersion: z.number().int().positive(),
+	annotationVersion: z.number().int().positive()
+});
+/**
+* Plane scopes are DERIVED from the version counters at every emission
+* point (layer manifests, mutation cache envelopes, SSE rows), never stored.
+* Additive/optional both ways: old clients ignore it, old servers omit it
+* (consumers treat absence as all-'layer' — never wrong, only unshared).
+*/
+const LayerScopeValueSchema = z.enum(["base", "layer"]);
+const LayerScopesSchema = z.object({
+	content: LayerScopeValueSchema,
+	annotations: LayerScopeValueSchema,
+	layout: LayerScopeValueSchema,
+	attachments: LayerScopeValueSchema,
+	metadata: LayerScopeValueSchema,
+	actions: LayerScopeValueSchema
+});
+/**
+* Per-page envelope inside `DocumentManifest`. Carries the full
+* `PageState` plus the cache-busting integers the SDK embeds in
+* leaf URLs (`/pages/:pon/text@contentVersion=N`, `/pages/:pon/annotations@annotationVersion=N`).
+*
+* `contentVersion` bumps when the page's content stream changes
+* (text, page reorder doesn't, the pon is durable). `annotationVersion`
+* bumps when /Annots gains/loses entries or when a tracked annotation
+* mutates. `hasWeakAnnotations` is hoisted from `PageState` so the
+* SDK can decide whether to display a "stale-on-reorder" badge
+* without re-fetching the page.
+*
+* Phase 4 hard-codes all three to (1, 1, false); Phase 5's
+* `layer_pages` table drives the real values.
+*/
+const ManifestPageSchema = z.object({
+	state: PageStateSchema,
+	cache: CachePinsSchema
+}).superRefine((page, ctx) => {
+	if (page.state.weakAnnotationState.kind !== "known") ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["state", "weakAnnotationState"],
+		message: "manifest pages must have a known weak annotation state"
+	});
+});
+/**
+* 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),
+	auditHead: z.number().int().nonnegative(),
+	baseSha: z.string(),
+	scopes: LayerScopesSchema.optional(),
+	pages: z.array(ManifestPageSchema)
+});
+const AnnotationListPageSnapshotSchema = z.object({
+	pageState: PageStateSchema,
+	annotations: z.array(AnnotationDTOSchema)
+});
+const AnnotationListSnapshotAllPagesSchema = z.object({ pages: z.array(AnnotationListPageSnapshotSchema) });
+/**
+* Wire shape of `GET /v1/docs/:docId/pages/:pon/text@contentVersion=N` and the
+* `pages.text` worker result. Carries the same `pageState` envelope
+* every page-scoped read returns, plus the full plain-text extraction
+* in display order and PDFium's char-count (which may exceed
+* `text.length / 1` when astral-plane characters are present).
+*/
+const PageTextSnapshotSchema = z.object({
+	text: z.string(),
+	charCount: z.number().int().nonnegative()
+});
+const PageGeometryGlyphSchema = z.object({
+	looseBox: PdfRectSchema,
+	flags: z.number().int().nonnegative(),
+	tightBox: PdfRectSchema.optional()
+});
+const PageGeometryRunSchema = z.object({
+	rect: PdfRectSchema,
+	charStart: z.number().int().nonnegative(),
+	glyphs: z.array(PageGeometryGlyphSchema),
+	fontSize: z.number().optional()
+});
+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 SearchQuerySchema = z.object({
+	text: z.string(),
+	regex: z.boolean().optional(),
+	matchCase: z.boolean().optional(),
+	wholeWord: z.boolean().optional(),
+	matchDiacritics: z.boolean().optional()
+});
+const SearchModeSchema = z.enum(["rects", "full"]);
+const SearchRequestSchema = z.object({
+	query: SearchQuerySchema,
+	mode: SearchModeSchema.optional(),
+	cursor: z.string().optional(),
+	startPage: z.number().int().positive().optional(),
+	skip: z.number().int().nonnegative().optional(),
+	budget: z.object({
+		maxMatches: z.number().int().positive().optional(),
+		maxPages: z.number().int().positive().optional()
+	}).optional()
+});
+const SearchSnippetSchema = z.object({
+	text: z.string(),
+	matchStart: z.number().int().nonnegative(),
+	matchLength: z.number().int().positive()
+});
+const SearchMatchSchema = z.object({
+	pageObjectNumber: z.number().int().positive(),
+	charStart: z.number().int().nonnegative(),
+	charCount: z.number().int().positive(),
+	rects: z.array(PdfRectSchema),
+	snippet: SearchSnippetSchema.optional()
+});
+const SearchSliceSchema = z.object({
+	matches: z.array(SearchMatchSchema),
+	nextCursor: z.string().nullable(),
+	scannedPages: z.number().int().nonnegative(),
+	totalPages: 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({
+		left: z.coerce.number().finite(),
+		bottom: z.coerce.number().finite(),
+		right: z.coerce.number().finite(),
+		top: z.coerce.number().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"]);
+const RenderQualitySchema = z.coerce.number().int().min(1).max(100);
+/**
+* Token/path rule: annotatedness is PATH-expressed —
+* the render FAMILY the route belongs to — never token/query-expressed.
+* Each family therefore gets its own query schema, built from one shared
+* base:
+*
+*   - the annotation-free family (`…/render/pages/`) has NO
+*     `annotationVersion` field at all — `.strict()` rejects it as an
+*     unrecognized key, so the illegal combination is unrepresentable;
+*   - the annotated family (`…/render/annotated/pages/`) REQUIRES
+*     `annotationVersion` on versioned requests — its artifact depends on
+*     the `annotations` plane, so the pin must be in the cache key.
+*
+* Both transforms stamp `includeAnnotations` onto the parsed SDK options
+* from the family, so downstream consumers (worker options, classify) are
+* family-blind.
+*/
+function buildPageRenderQuerySchema(annotated) {
+	return z.object({
+		contentVersion: z.coerce.number().int().positive().optional(),
+		...annotated ? { annotationVersion: z.coerce.number().int().positive().optional() } : {},
+		format: PageNetworkRenderFormatSchema.optional(),
+		viewport: RenderViewportSchema.optional(),
+		target: RenderTargetSchema.optional(),
+		rotation: RenderRotationSchema.optional(),
+		background: RenderBackgroundSchema.optional(),
+		quality: RenderQualitySchema.optional()
+	}).strict().superRefine((v, ctx) => {
+		const pins = v;
+		if (pins.contentVersion !== void 0 && v.format === void 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["format"],
+			message: "versioned render requires format"
+		});
+		if (annotated && pins.annotationVersion !== void 0 && pins.contentVersion === void 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["annotationVersion"],
+			message: "annotationVersion requires contentVersion"
+		});
+		if (annotated && pins.contentVersion !== void 0 && pins.annotationVersion === void 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["annotationVersion"],
+			message: "versioned annotated render requires annotationVersion"
+		});
+	}).transform((v) => {
+		const pins = v;
+		return {
+			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 } : {},
+				includeAnnotations: annotated
+			},
+			...pins.contentVersion !== void 0 ? { contentVersion: pins.contentVersion } : {},
+			...pins.annotationVersion !== void 0 ? { annotationVersion: pins.annotationVersion } : {}
+		};
+	});
+}
+/** Query/token schema for the annotation-free render family (`page-render`). */
+const PageRenderQuerySchema = buildPageRenderQuerySchema(false);
+/** Query/token schema for the annotated render family (`page-render-annotated`). */
+const PageRenderAnnotatedQuerySchema = buildPageRenderQuerySchema(true);
+/**
+* Query/token schema for the batch annotation-appearance render endpoint.
+* Mirrors `PageRenderQuerySchema` but without page target/viewport/background
+* or `includeAnnotations` (appearances are always annotation-derived), and
+* keyed by `annotationVersion` only — appearance bitmaps do not depend on
+* page base content, so `contentVersion` is not part of the cache key. The
+* endpoint renders the Normal appearance only.
+*/
+const AnnotationAppearancesQuerySchema = z.object({
+	annotationVersion: z.coerce.number().int().positive().optional(),
+	format: PageNetworkRenderFormatSchema.optional(),
+	rotation: RenderRotationSchema.optional(),
+	scale: z.coerce.number().positive().finite().optional(),
+	quality: RenderQualitySchema.optional()
+}).strict().superRefine((v, ctx) => {
+	if (v.annotationVersion !== 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.scale !== void 0 ? { scale: v.scale } : {},
+			...v.quality !== void 0 ? { quality: v.quality } : {},
+			...v.format !== void 0 ? { format: v.format } : {}
+		},
+		...v.annotationVersion !== void 0 ? { annotationVersion: v.annotationVersion } : {}
+	};
+});
+/**
+* The JSON manifest part of the appearance `multipart/form-data` response.
+* Wire-stable; the cloud client validates the parsed `manifest` part against
+* this before reconstructing image handles from the binary parts.
+*/
+const AnnotationAppearanceManifestSchema = z.object({
+	pageState: PageStateSchema,
+	appearances: z.array(z.object({
+		part: z.string().min(1),
+		ref: AnnotationRefSchema,
+		mode: z.enum([
+			"normal",
+			"rollover",
+			"down"
+		]),
+		rect: PdfRectSchema,
+		width: z.number().int().positive(),
+		height: z.number().int().positive(),
+		format: PageNetworkRenderFormatSchema,
+		contentType: z.string().min(1)
+	}))
+});
+/**
+* Reasons a mutation tells the client its old snapshot is stale. Wire-stable;
+* extend with care (forward-compat clients accept only known values).
+*/
+const RefetchReasonSchema = z.enum([
+	"weakRefsInvalidated",
+	"externalChange",
+	"pageRebuilt"
+]);
+const CacheDeltaSchema = z.object({
+	previousDocVersion: z.number().int().positive(),
+	docVersion: z.number().int().positive(),
+	pages: z.array(z.object({
+		pageObjectNumber: z.number().int().positive(),
+		cache: CachePinsSchema
+	}))
+});
+const MutationMetaSchema = z.object({
+	affectedPages: z.array(PageStateSchema),
+	cacheDelta: CacheDeltaSchema.nullable()
+});
+/**
+* Per-page side-effect envelope every annotation mutation returns. Mirrors
+* `AnnotationListMutationMeta`. The `shouldRefetch` field is `null` when the
+* client's existing index-based references remain valid; non-null only when
+* the engine knows for sure the snapshot is stale.
+*/
+const AnnotationListMutationMetaSchema = z.object({
+	affectedPages: z.array(PageStateSchema),
+	cacheDelta: CacheDeltaSchema.nullable(),
+	changed: z.array(AnnotationStableIdSchema),
+	weakRefsInvalidated: z.boolean(),
+	shouldRefetch: z.object({ reason: RefetchReasonSchema }).nullable()
+});
+const AnnotationCreateResultSchema = z.object({
+	created: AnnotationDTOSchema,
+	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"
+	]),
+	changed: z.boolean()
+});
+const AnnotationUpdateResultSchema = z.object({
+	updated: AnnotationDTOSchema,
+	appearance: AppearanceOutcomeSchema,
+	meta: AnnotationListMutationMetaSchema
+});
+/**
+* `deleted` is nullable: a weak annotation (no /NM, no indirect object
+* number) has no durable id to report after removal. Cloud server and local
+* worker both emit `null` in that case so callers don't have to special-case
+* a sentinel.
+*/
+const AnnotationDeleteResultSchema = z.object({
+	deleted: AnnotationStableIdSchema.nullable(),
+	meta: AnnotationListMutationMetaSchema
+});
+/**
+* Batch annotation move (contiguous-block, symmetric with `pages.move`).
+* `moved` is in caller order; each `moved[i]` lives at index `toIndex + i`
+* after the move. ONE structural envelope per batch.
+*/
+const AnnotationMoveResultSchema = z.object({
+	moved: z.array(AnnotationDTOSchema),
+	meta: AnnotationListMutationMetaSchema
+});
+const FormSetValueResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	changedWidgets: z.array(FormWidgetRefSchema),
+	meta: MutationMetaSchema
+});
+const FormEffectSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("setValue"),
+		ref: FormFieldRefSchema,
+		value: FormFieldValueSchema
+	}),
+	z.object({
+		kind: z.literal("setDisplay"),
+		ref: FormFieldRefSchema,
+		display: z.enum([
+			"visible",
+			"hidden",
+			"noPrint",
+			"noView"
+		])
+	}),
+	z.object({
+		kind: z.literal("setAppearanceText"),
+		ref: FormFieldRefSchema,
+		text: z.string()
+	}),
+	z.object({
+		kind: z.literal("reset"),
+		refs: z.array(FormFieldRefSchema)
+	})
+]);
+const FormEffectsResultSchema = z.object({
+	results: z.array(z.object({
+		index: z.number().int().nonnegative(),
+		status: z.enum([
+			"applied",
+			"unchanged",
+			"rejected",
+			"failed",
+			"skipped"
+		]),
+		fields: z.array(FormFieldDTOSchema),
+		changedWidgets: z.array(FormWidgetRefSchema),
+		error: EngineErrorPayloadSchema.optional()
+	})),
+	changedWidgets: z.array(FormWidgetRefSchema),
+	meta: MutationMetaSchema.nullable()
+});
+const FormImportResultSchema = z.object({
+	fieldsTotal: z.number().int().nonnegative(),
+	fieldsApplied: z.number().int().nonnegative(),
+	fieldsSkipped: z.number().int().nonnegative(),
+	widgetsChanged: z.number().int().nonnegative(),
+	snapshot: FormSnapshotSchema,
+	meta: MutationMetaSchema
+});
+const FormFieldCreateResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	meta: MutationMetaSchema
+});
+const FormFieldUpdateResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	meta: MutationMetaSchema
+});
+const FormFieldDeleteResultSchema = z.object({
+	deletedFieldObjectNumber: z.number().int().positive(),
+	removedWidgets: z.array(FormWidgetRefSchema),
+	meta: MutationMetaSchema
+});
+const FormWidgetLinkResultSchema = z.object({
+	field: FormFieldDTOSchema,
+	meta: MutationMetaSchema
+});
+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(),
+	needAppearancesCleared: z.boolean(),
+	meta: MutationMetaSchema
+});
+const PageBoxesSchema = z.object({
+	media: PdfRectSchema,
+	crop: PdfRectSchema,
+	bleed: PdfRectSchema.optional(),
+	trim: PdfRectSchema.optional(),
+	art: PdfRectSchema.optional()
+});
+/**
+* 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(),
+	pageObjectNumber: z.number().int().positive(),
+	label: z.string().nullable(),
+	size: PdfSizeSchema,
+	rotation: PdfRotationSchema,
+	userUnit: z.number().positive(),
+	boxes: PageBoxesSchema,
+	actions: PdfPageActionsSchema.optional()
+});
+const PageFlattenResultSchema = z.object({
+	pageObjectNumbers: z.array(z.number().int().positive()),
+	usage: z.enum(["display", "print"]),
+	results: z.array(z.object({
+		pageObjectNumber: z.number().int().positive(),
+		status: z.enum([
+			"applied",
+			"unchanged",
+			"failed",
+			"skipped"
+		]),
+		error: EngineErrorPayloadSchema.optional()
+	})),
+	meta: MutationMetaSchema.nullable()
+});
+const PageFlattenInputSchema = z.object({
+	pageObjectNumbers: z.array(z.number().int().positive()),
+	usage: z.enum(["display", "print"])
+});
+const RedactionApplyScopeSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("pages"),
+	pageObjectNumbers: z.array(z.number().int().positive())
+}), z.object({
+	kind: z.literal("annotations"),
+	refs: z.array(AnnotationRefSchema)
+})]);
+const RedactionApplyResultSchema = z.object({
+	scope: RedactionApplyScopeSchema,
+	results: z.array(z.object({
+		pageObjectNumber: z.number().int().positive(),
+		status: z.enum([
+			"applied",
+			"unchanged",
+			"failed",
+			"skipped"
+		]),
+		removedAnnotationCount: z.number().int().nonnegative(),
+		error: EngineErrorPayloadSchema.optional()
+	})),
+	removedAnnotationCount: z.number().int().nonnegative(),
+	meta: MutationMetaSchema.nullable()
+});
+/**
+* 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.
+*/
+const PageListSnapshotSchema = z.object({
+	pageCount: z.number().int().nonnegative(),
+	pages: z.array(PageLayoutSchema)
+});
+/**
+* Page reorder input. Pages are always addressed by `pageObjectNumber`;
+* `destIndex` is the insertion point in the post-removal index space.
+*/
+const PageMoveInputSchema = z.object({
+	pageObjectNumbers: z.array(z.number().int().positive()),
+	destIndex: z.number().int().nonnegative()
+});
+/**
+* Coherence pins shared by every page-STRUCTURE result (move/rotate/delete) —
+* see `PageStructureCache`. Nullable at each use site (local engines).
+*/
+const PageStructureCacheSchema = z.object({
+	previousDocVersion: z.number().int().nonnegative(),
+	docVersion: z.number().int().positive(),
+	layoutVersion: z.number().int().positive()
+});
+/**
+* Page reorder result. No revision is bumped (no doc-level revision exists,
+* and per-page revisions intentionally survive a page reorder). The full
+* post-move order is returned so callers can swap their snapshot directly.
+*/
+const PageMoveResultSchema = z.object({
+	layout: PageListSnapshotSchema,
+	cache: PageStructureCacheSchema.nullable()
+});
+/**
+* Page rotate input. ABSOLUTE rotation (idempotent — see `PageRotateInput`),
+* one value applied to every listed page.
+*/
+const PageRotateInputSchema = z.object({
+	pageObjectNumbers: z.array(z.number().int().positive()),
+	rotation: 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 = z.object({
+	layout: PageListSnapshotSchema,
+	cache: PageStructureCacheSchema.nullable()
+});
+/** Page delete input. Deleting every page is rejected server/worker-side. */
+const PageDeleteInputSchema = z.object({ pageObjectNumbers: z.array(z.number().int().positive()) });
+/**
+* Page delete result. Deleted PONs are retired (never recycled); surviving
+* pages keep identity + revisions (see `PageDeleteResult`).
+*/
+const PageDeleteResultSchema = z.object({
+	layout: PageListSnapshotSchema,
+	cache: PageStructureCacheSchema.nullable()
+});
+/**
+* Metadata write result. The Info dict is rewritten in place, so the
+* result returns the re-read `metadata` plus cloud coherence pins. No
+* `layoutVersion` is touched — a metadata edit bumps only `docVersion`
+* and `metadataVersion`. `cache` is `null` for local engines.
+*/
+const AttachmentsCacheSchema = z.object({
+	previousDocVersion: z.number().int().nonnegative(),
+	docVersion: z.number().int().positive(),
+	attachmentsVersion: z.number().int().positive()
+});
+const AttachmentCreateResultSchema = z.object({
+	created: EmbeddedFileItemSchema,
+	cache: AttachmentsCacheSchema.nullable()
+});
+const AttachmentDeleteResultSchema = z.object({
+	deleted: EmbeddedFileRefSchema,
+	cache: AttachmentsCacheSchema.nullable()
+});
+const MetadataUpdateResultSchema = z.object({
+	metadata: DocumentMetadataSchema,
+	cache: z.object({
+		previousDocVersion: z.number().int().nonnegative(),
+		docVersion: z.number().int().positive(),
+		metadataVersion: z.number().int().positive()
+	}).nullable()
+});
+const WeakAnnotationSessionResponseSchema = z.object({
+	sessionId: z.string().min(1),
+	expiresAt: z.number().int().positive(),
+	heartbeatIntervalMs: z.number().int().positive(),
+	pageObjectNumbers: z.array(z.number().int().positive())
+});
+const WeakAnnotationSessionPagesRequestSchema = z.object({ pageObjectNumbers: z.array(z.number().int().positive()).transform((pages) => [...new Set(pages)]) });
+//#endregion
+export { PageStateSchema as $, FreeTextIntentSchema as $n, SquigglyDraftSchema as $t, FormSetValueResultSchema as A, FileAttachmentPatchSchema as An, AnnotationDTOSchema as At, PageDeleteResultSchema as B, CaretDraftSchema as Bn, UnderlinePatchSchema as Bt, FormEffectSchema as C, HighlightDraftSchema as Cn, PdfRotationSchema as Cr, FormKindSchema as Ct, FormFieldUpdateResultSchema as D, FreeTextPatchSchema as Dn, ToggleFieldWidgetSchema as Dt, FormFieldDeleteResultSchema as E, FreeTextDraftSchema as En, FormWidgetRefSchema as Et, MetadataUpdateResultSchema as F, EmbeddedFileRefSchema as Fn, UnsupportedDTOSchema as Ft, PageListSnapshotSchema as G, AnnotationFlagsPartialSchema as Gn, StrikeoutDTOSchema as Gt, PageFlattenResultSchema as H, AnnotationBaseShape as Hn, TextDTOSchema as Ht, MutationMetaSchema as I, CircleDTOSchema as In, UnsupportedDraftSchema as It, PageNetworkRenderFormatSchema as J, AnnotationRefSchema as Jn, ResourceRefSchema as Jt, PageMoveInputSchema as K, AnnotationFlagsSchema as Kn, StrikeoutDraftSchema as Kt, OpenDocumentResponseSchema as L, CircleDraftSchema as Ln, UnsupportedPatchSchema as Lt, LayerScopesSchema as M, WireAttachmentFileSchema as Mn, AnnotationPatchSchema as Mt, ManifestPageSchema as N, AttachmentFileInfoSchema as Nn, KIND_BY_SUBTYPE as Nt, FormImportResultSchema as O, FileAttachmentDTOSchema as On, WidgetPlacementSchema as Ot, MetadataPatchSchema as P, EmbeddedFileItemSchema as Pn, WidgetAppearanceSchema as Pt, PageRotateResultSchema as Q, ColorSchema as Qn, SquigglyDTOSchema as Qt, PageBoxesSchema as R, CirclePatchSchema as Rn, UnderlineDTOSchema as Rt, EngineErrorPayloadSchema as S, HighlightDTOSchema as Sn, PdfRectSchema as Sr, FormFieldValueSchema as St, FormFieldCreateResultSchema as T, FreeTextDTOSchema as Tn, FormValueEntrySchema as Tt, PageGeometrySnapshotSchema as U, AnnotationBorderStyleSchema as Un, TextDraftSchema as Ut, PageFlattenInputSchema as V, CaretPatchSchema as Vn, NoteIconSchema as Vt, PageLayoutSchema as W, AnnotationDraftBaseShape as Wn, TextPatchSchema as Wt, PageRenderQuerySchema as X, BlendModeSchema as Xn, StampWireDraftSchema as Xt, PageRenderAnnotatedQuerySchema as Y, AnnotationStableIdSchema as Yn, StampDTOSchema as Yt, PageRotateInputSchema as Z, CaretIntentSchema as Zn, StampWirePatchSchema as Zt, CachePinsSchema as _, LineDraftSchema as _n, CalloutLineSchema as _r, FormFieldFlagsSchema as _t, AnnotationCreateResultSchema as a, PolylineDraftSchema as an, RectSchema as ar, RefetchReasonSchema as at, DocumentMetadataSchema as b, InkDraftSchema as bn, PdfPointSchema as br, FormFieldPatchSchema as bt, AnnotationListPageSnapshotSchema as c, PolygonDraftSchema as cn, StrikeoutIntentSchema as cr, SearchQuerySchema as ct, AnnotationUpdateResultSchema as d, LinkDraftSchema as dn, PdfActionNodeSchema as dr, SearchSnippetSchema as dt, SquigglyPatchSchema as en, InkIntentSchema as er, PageStructureCacheSchema as et, AppearanceOutcomeSchema as f, LinkPatchSchema as fn, PdfActionTreeSchema as fr, WeakAnnotationSessionPagesRequestSchema as ft, CacheDeltaSchema as g, LineDTOSchema as gn, PdfPageActionsSchema as gr, FormFieldDraftSchema as gt, AttachmentsCacheSchema as h, PdfLinkTargetWritableSchema as hn, PdfFieldActionsSchema as hr, FormFieldDTOSchema as ht, AnnotationAppearancesQuerySchema as i, PolylineDTOSchema as in, PointSchema as ir, RedactionApplyScopeSchema as it, FormWidgetLinkResultSchema as j, FileAttachmentWireDraftSchema as jn, AnnotationDraftSchema as jt, FormRepairResultSchema as k, FileAttachmentIconSchema as kn, ANNOTATION_KINDS as kt, AnnotationListSnapshotAllPagesSchema as l, PolygonPatchSchema as ln, TextAlignmentSchema as lr, SearchRequestSchema as lt, AttachmentDeleteResultSchema as m, PdfLinkTargetSchema as mn, PdfAnnotationActionsSchema as mr, FormDataFormatSchema as mt, AccessResponseSchema as n, SquareDraftSchema as nn, LineEndingsSchema as nr, PdfSaveModeSchema as nt, AnnotationDeleteResultSchema as o, PolylinePatchSchema as on, RevisionTokenSchema as or, SearchMatchSchema as ot, AttachmentCreateResultSchema as p, PdfDestinationSchema as pn, PdfActionTypeSchema as pr, WeakAnnotationSessionResponseSchema as pt, PageMoveResultSchema as q, AnnotationPatchBaseShape as qn, StrikeoutPatchSchema as qt, AnnotationAppearanceManifestSchema as r, SquarePatchSchema as rn, PdfRectDifferencesSchema as rr, RedactionApplyResultSchema as rt, AnnotationListMutationMetaSchema as s, PolygonDTOSchema as sn, StandardFontSchema as sr, SearchModeSchema as st, AccessRequestSchema as t, SquareDTOSchema as tn, LineEndingSchema as tr, PageTextSnapshotSchema as tt, AnnotationMoveResultSchema as u, LinkDTOSchema as un, DocumentActionsSnapshotSchema as ur, SearchSliceSchema as ut, DocumentHeadSchema as v, LinePatchSchema as vn, InkListSchema as vr, FormFieldOptionInputSchema as vt, FormEffectsResultSchema as w, HighlightPatchSchema as wn, PdfSizeSchema as wr, FormSnapshotSchema as wt, DocumentSecurityStateSchema as x, InkPatchSchema as xn, PdfQuadSchema as xr, FormFieldRefSchema as xt, DocumentManifestSchema as y, InkDTOSchema as yn, LinePointsSchema as yr, FormFieldOptionSchema as yt, PageDeleteInputSchema as z, CaretDTOSchema as zn, UnderlineDraftSchema as zt };
+
+//# sourceMappingURL=schemas-9OpSSeM6.js.map