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

package/dist/schema-C-gU4vj7.cjs

@@ -0,0 +1,3034 @@
+const require_format = require("./format-Bp3QFSH1.cjs");
+const require_subtype = require("./subtype-aDt5TFmK.cjs");
+let zod = require("zod");
+//#region src/identity/PageRef.schema.ts
+/** Wire form of `PageRef` — see the type. */
+const PageRefSchema = zod.z.object({
+	kind: zod.z.literal("objectNumber"),
+	objectNumber: zod.z.number().int().positive()
+});
+//#endregion
+//#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 = zod.z.object({
+	x: zod.z.number(),
+	y: zod.z.number()
+});
+const LinePointsSchema = zod.z.object({
+	start: PdfPointSchema,
+	end: PdfPointSchema
+});
+/** `/CL` callout leader line — two points (straight) or three (knee-jointed). */
+const CalloutLineSchema = zod.z.union([zod.z.tuple([PdfPointSchema, PdfPointSchema]), zod.z.tuple([
+	PdfPointSchema,
+	PdfPointSchema,
+	PdfPointSchema
+])]);
+/** `/InkList` — an array of strokes, each an array of points. */
+const InkListSchema = zod.z.array(zod.z.array(PdfPointSchema));
+/** A rect's edges are finite, as `isFinitePdfRect` checks them on the page. */
+const PdfRectSchema = zod.z.object({
+	left: zod.z.number().finite(),
+	bottom: zod.z.number().finite(),
+	right: zod.z.number().finite(),
+	top: zod.z.number().finite()
+});
+const PdfSizeSchema = zod.z.object({
+	width: zod.z.number().nonnegative(),
+	height: zod.z.number().nonnegative()
+});
+const PdfQuadSchema = zod.z.object({
+	upperLeft: PdfPointSchema,
+	upperRight: PdfPointSchema,
+	lowerLeft: PdfPointSchema,
+	lowerRight: PdfPointSchema
+});
+const PdfRotationSchema = zod.z.union([
+	zod.z.literal(0),
+	zod.z.literal(90),
+	zod.z.literal(180),
+	zod.z.literal(270)
+]);
+const PagePointSchema = zod.z.object({
+	x: zod.z.number(),
+	y: zod.z.number()
+});
+/** A box is finite, as a rect is (`PdfRectSchema`). */
+const PageBoxSchema = zod.z.object({
+	x: zod.z.number().finite(),
+	y: zod.z.number().finite(),
+	width: zod.z.number().finite().nonnegative(),
+	height: zod.z.number().finite().nonnegative()
+});
+const PageQuadSchema = zod.z.object({
+	upperLeft: PagePointSchema,
+	upperRight: PagePointSchema,
+	lowerLeft: PagePointSchema,
+	lowerRight: PagePointSchema
+});
+//#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 = zod.z.string().regex(/^#[0-9a-fA-F]{6}$/, "expected a color as '#rrggbb'");
+const AnnotationBorderStyleSchema = zod.z.enum([
+	"solid",
+	"dashed",
+	"beveled",
+	"inset"
+]);
+const WidgetBorderStyleSchema = zod.z.enum([
+	"solid",
+	"dashed",
+	"beveled",
+	"inset",
+	"underline"
+]);
+const WidgetCheckStyleSchema = zod.z.enum([
+	"check",
+	"cross",
+	"star",
+	"circle",
+	"square",
+	"diamond"
+]);
+/** What a write takes for a border that isn't a widget's. */
+const DrawnBorderStyleSchema = zod.z.enum(["solid", "dashed"]);
+const LineEndingSchema = zod.z.enum([
+	"none",
+	"square",
+	"circle",
+	"diamond",
+	"open-arrow",
+	"closed-arrow",
+	"butt",
+	"r-open-arrow",
+	"r-closed-arrow",
+	"slash"
+]);
+const LineEndingsSchema = zod.z.object({
+	start: LineEndingSchema,
+	end: LineEndingSchema
+});
+const StandardFontSchema = zod.z.enum(require_format.STANDARD_FONTS);
+const TextAlignmentSchema = zod.z.enum([
+	"left",
+	"center",
+	"right"
+]);
+const FreeTextIntentSchema = zod.z.enum([
+	"free-text",
+	"free-text-callout",
+	"free-text-typewriter"
+]);
+/** The intents a write makes: a typewriter is only sent back as read. */
+const FreeTextIntentWriteSchema = zod.z.enum(["free-text", "free-text-callout"]);
+const VerticalAlignmentSchema = zod.z.enum([
+	"top",
+	"middle",
+	"bottom"
+]);
+const CaretIntentSchema = zod.z.literal("replace");
+const StrikeoutIntentSchema = zod.z.literal("strikeout-text-edit");
+const InkIntentSchema = zod.z.literal("ink-highlight");
+const BlendModeSchema = zod.z.enum([
+	"normal",
+	"multiply",
+	"screen",
+	"overlay",
+	"darken",
+	"lighten",
+	"color-dodge",
+	"color-burn",
+	"hard-light",
+	"soft-light",
+	"difference",
+	"exclusion",
+	"hue",
+	"saturation",
+	"color",
+	"luminosity"
+]);
+const AnnotationRefSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("objectNumber"),
+	page: PageRefSchema,
+	objectNumber: zod.z.number().int().positive()
+}), zod.z.object({
+	kind: zod.z.literal("baseIndex"),
+	page: PageRefSchema,
+	baseIndex: zod.z.number().int().nonnegative()
+})]);
+//#endregion
+//#region src/dto/PdfDestination.schema.ts
+const page = PageRefSchema;
+/** Spec-nullable axis value: absent and `null` both mean "retain current". */
+const axis = zod.z.number().nullable().optional();
+/**
+* Runtime schema for {@link PdfDestination}. Lives beside its DTO in `dto/`
+* so every destination-shaped surface (link targets, action-node payloads,
+* the document `openDestination`) shares one schema without an import cycle
+* through the annotation tree.
+*/
+const PdfDestinationSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("xyz"),
+		page,
+		left: axis,
+		top: axis,
+		zoom: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fit"),
+		page
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitH"),
+		page,
+		top: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitV"),
+		page,
+		left: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitR"),
+		page,
+		left: zod.z.number(),
+		bottom: zod.z.number(),
+		right: zod.z.number(),
+		top: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitB"),
+		page
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitBH"),
+		page,
+		top: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitBV"),
+		page,
+		left: axis
+	})
+]);
+/** A destination in page space: measured from the top-left of its page's visible box. */
+const PageDestinationSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("xyz"),
+		page,
+		x: axis,
+		y: axis,
+		zoom: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fit"),
+		page
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitH"),
+		page,
+		y: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitV"),
+		page,
+		x: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitR"),
+		page,
+		x: zod.z.number(),
+		y: zod.z.number(),
+		width: zod.z.number().nonnegative(),
+		height: zod.z.number().nonnegative()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitB"),
+		page
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitBH"),
+		page,
+		y: axis
+	}),
+	zod.z.object({
+		kind: zod.z.literal("fitBV"),
+		page,
+		x: axis
+	})
+]);
+//#endregion
+//#region src/annotation/kinds/link/values.ts
+/** A link target's two schemas, a read and a write, for destinations of one kind. */
+function linkTargetSchemasFor(destination) {
+	const goto = zod.z.object({
+		kind: zod.z.literal("goto"),
+		destination
+	});
+	const uri = zod.z.object({
+		kind: zod.z.literal("uri"),
+		uri: zod.z.string()
+	});
+	const read = zod.z.discriminatedUnion("kind", [
+		goto,
+		uri,
+		zod.z.object({
+			kind: zod.z.literal("goto-remote"),
+			file: zod.z.string()
+		}),
+		zod.z.object({
+			kind: zod.z.literal("launch"),
+			path: zod.z.string()
+		}),
+		zod.z.object({ kind: zod.z.literal("javascript") }),
+		zod.z.object({
+			kind: zod.z.literal("named"),
+			name: zod.z.string()
+		}),
+		zod.z.object({ kind: zod.z.literal("unsupported") })
+	]);
+	/** Drafts and patches author `goto`, `uri` and the standard named verbs; see {@link PdfLinkTargetWritable}. */
+	const named = zod.z.object({
+		kind: zod.z.literal("named"),
+		name: zod.z.enum([
+			"NextPage",
+			"PrevPage",
+			"FirstPage",
+			"LastPage"
+		])
+	});
+	return {
+		read,
+		write: zod.z.discriminatedUnion("kind", [
+			goto,
+			uri,
+			named
+		])
+	};
+}
+const PAGE_SPACE$1 = linkTargetSchemasFor(PageDestinationSchema);
+const FILE_SPACE = linkTargetSchemasFor(PdfDestinationSchema);
+/** A link's target: a destination in page space. */
+const PdfLinkTargetSchema = PAGE_SPACE$1.read;
+/** What a create or an update may set as a link's target. */
+const PdfLinkTargetWritableSchema = PAGE_SPACE$1.write;
+/** A link's target as the engine reads the file: a destination in the file's coordinates. */
+const FileLinkTargetSchema = FILE_SPACE.read;
+const FileLinkTargetWritableSchema = FILE_SPACE.write;
+//#endregion
+//#region src/dto/PdfAction.schema.ts
+const PdfActionTargetRefSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("name"),
+	name: zod.z.string()
+}), zod.z.object({
+	kind: zod.z.literal("objectNumber"),
+	objectNumber: zod.z.number().int().positive()
+})]);
+const SubmitFormFlagsSchema = zod.z.object({
+	raw: zod.z.number().int().nonnegative(),
+	exclude: zod.z.boolean(),
+	includeNoValueFields: zod.z.boolean(),
+	format: zod.z.enum([
+		"fdf",
+		"html",
+		"xfdf",
+		"pdf"
+	]),
+	method: zod.z.enum(["post", "get"]),
+	submitCoordinates: zod.z.boolean(),
+	includeAppendSaves: zod.z.boolean(),
+	includeAnnotations: zod.z.boolean(),
+	canonicalFormat: zod.z.boolean(),
+	exclNonUserAnnots: zod.z.boolean(),
+	exclFKey: zod.z.boolean(),
+	embedForm: zod.z.boolean()
+});
+/**
+* The action schemas for one kind of destination: in the file's coordinates
+* or in page space. Everything but a `goto`'s destination is the same.
+*/
+function actionSchemasFor(destination) {
+	/** Fields every node arm repeats — zod 3's discriminatedUnion needs plain
+	*  object options, so the recursion (`next`) lives inline per arm and the
+	*  whole union sits behind one `z.lazy`. */
+	const nodeCommon = {
+		subtype: zod.z.string(),
+		next: zod.z.array(zod.z.lazy(() => node))
+	};
+	const arm = (type, shape = {}) => zod.z.object({
+		type: zod.z.literal(type),
+		...nodeCommon,
+		...shape
+	});
+	const arms = [
+		arm("javascript", { script: zod.z.string() }),
+		arm("goto", { destination }),
+		arm("uri", {
+			uri: zod.z.string(),
+			isMap: zod.z.boolean()
+		}),
+		arm("named", { name: zod.z.string() }),
+		arm("hide", {
+			targets: zod.z.array(PdfActionTargetRefSchema),
+			hide: zod.z.boolean()
+		}),
+		arm("reset-form", {
+			fields: zod.z.array(PdfActionTargetRefSchema).nullable(),
+			exclude: zod.z.boolean()
+		}),
+		arm("goto-remote", { filePath: zod.z.string() }),
+		arm("goto-embedded", { filePath: zod.z.string() }),
+		arm("launch", { filePath: zod.z.string() }),
+		arm("rendition", { script: zod.z.string().optional() }),
+		arm("submit-form", { payload: zod.z.object({
+			url: zod.z.string(),
+			fields: zod.z.array(PdfActionTargetRefSchema).nullable(),
+			flags: SubmitFormFlagsSchema,
+			charSet: zod.z.string().optional()
+		}).optional() }),
+		arm("thread"),
+		arm("sound"),
+		arm("movie"),
+		arm("import-data"),
+		arm("set-ocg-state"),
+		arm("transition"),
+		arm("goto-3d-view"),
+		arm("unknown")
+	];
+	const node = zod.z.lazy(() => zod.z.discriminatedUnion("type", [...arms]));
+	const tree = zod.z.object({
+		root: node.nullable(),
+		incomplete: zod.z.boolean(),
+		warningFlags: zod.z.number().int().nonnegative(),
+		warnings: zod.z.array(zod.z.enum([
+			"cycle-dropped",
+			"malformed-next",
+			"incomplete",
+			"payload-dropped"
+		]))
+	});
+	return {
+		arms,
+		node,
+		tree,
+		fieldActions: zod.z.object({
+			keystroke: tree.optional(),
+			format: tree.optional(),
+			validate: tree.optional(),
+			calculate: tree.optional()
+		}),
+		pageActions: zod.z.object({
+			open: tree.optional(),
+			close: tree.optional()
+		}),
+		annotationActions: zod.z.object({
+			activate: tree.optional(),
+			cursorEnter: tree.optional(),
+			cursorExit: tree.optional(),
+			mouseDown: tree.optional(),
+			mouseUp: tree.optional(),
+			focus: tree.optional(),
+			blur: tree.optional(),
+			pageOpen: tree.optional(),
+			pageClose: tree.optional(),
+			pageVisible: tree.optional(),
+			pageInvisible: tree.optional()
+		}),
+		documentActions: zod.z.object({
+			nameTreeScripts: zod.z.array(zod.z.object({
+				name: zod.z.string(),
+				action: tree
+			})),
+			openAction: tree.nullable(),
+			openDestination: destination.nullable().default(null),
+			willClose: tree.optional(),
+			willSave: tree.optional(),
+			didSave: tree.optional(),
+			willPrint: tree.optional(),
+			didPrint: tree.optional()
+		}).superRefine((snapshot, context) => {
+			if (snapshot.openAction !== null && (snapshot.openDestination ?? null) !== null) context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: "openAction and openDestination are mutually exclusive",
+				path: ["openDestination"]
+			});
+		})
+	};
+}
+const PAGE_SPACE = actionSchemasFor(PageDestinationSchema);
+const PDF_SPACE = actionSchemasFor(PdfDestinationSchema);
+/**
+* The write schemas for one kind of destination: an action a write makes,
+* and a widget's actions patch.
+*/
+function actionWriteSchemasFor(destination) {
+	const next = () => ({ next: zod.z.array(zod.z.lazy(() => node)).optional() });
+	const arms = [
+		zod.z.object({
+			type: zod.z.literal("javascript"),
+			script: zod.z.string(),
+			...next()
+		}),
+		zod.z.object({
+			type: zod.z.literal("goto"),
+			destination,
+			...next()
+		}),
+		zod.z.object({
+			type: zod.z.literal("uri"),
+			uri: zod.z.string().min(1),
+			...next()
+		}),
+		zod.z.object({
+			type: zod.z.literal("named"),
+			name: zod.z.string().min(1),
+			...next()
+		}),
+		zod.z.object({
+			type: zod.z.literal("hide"),
+			targets: zod.z.array(PdfActionTargetRefSchema).min(1),
+			hide: zod.z.boolean(),
+			...next()
+		}),
+		zod.z.object({
+			type: zod.z.literal("reset-form"),
+			fields: zod.z.array(PdfActionTargetRefSchema).nullable(),
+			exclude: zod.z.boolean(),
+			...next()
+		}),
+		zod.z.object({
+			type: zod.z.literal("submit-form"),
+			url: zod.z.string().min(1),
+			fields: zod.z.array(PdfActionTargetRefSchema).nullable(),
+			flags: zod.z.number().int().nonnegative().optional(),
+			...next()
+		})
+	];
+	const node = zod.z.lazy(() => zod.z.discriminatedUnion("type", [...arms]));
+	const event = () => node.nullable().optional();
+	return {
+		node,
+		widgetActions: zod.z.object({
+			activate: event(),
+			cursorEnter: event(),
+			cursorExit: event(),
+			mouseDown: event(),
+			mouseUp: event(),
+			focus: event(),
+			blur: event(),
+			pageOpen: event(),
+			pageClose: event(),
+			pageVisible: event(),
+			pageInvisible: event()
+		}).strict()
+	};
+}
+const PAGE_SPACE_WRITES = actionWriteSchemasFor(PageDestinationSchema);
+const PDF_SPACE_WRITES = actionWriteSchemasFor(PdfDestinationSchema);
+/** An action a write makes, its destinations in page space. */
+const PdfActionWriteSchema = PAGE_SPACE_WRITES.node;
+/** A widget's actions to write, by event, their destinations in page space. */
+const WidgetActionsPatchSchema = PAGE_SPACE_WRITES.widgetActions;
+/** A widget's actions to write, as the engine writes the file: destinations in its coordinates. */
+const FileWidgetActionsPatchSchema = PDF_SPACE_WRITES.widgetActions;
+const PdfActionNodeSchema = PAGE_SPACE.node;
+/** The `/S` vocabulary, derived from the union arms so it cannot drift. */
+const PdfActionTypeSchema = zod.z.enum(PAGE_SPACE.arms.map((option) => option.shape.type.value));
+const PdfActionTreeSchema = PAGE_SPACE.tree;
+const PdfFieldActionsSchema = PAGE_SPACE.fieldActions;
+const PdfPageActionsSchema = PAGE_SPACE.pageActions;
+const DocumentActionsSnapshotSchema = PAGE_SPACE.documentActions;
+/** An annotation's actions (`/A`, `/AA`), their destinations in page space. */
+const PdfAnnotationActionsSchema = PAGE_SPACE.annotationActions;
+/** An annotation's actions as the engine reads the file: destinations in the file's coordinates. */
+const FileAnnotationActionsSchema = PDF_SPACE.annotationActions;
+/**
+* A field event's script: JavaScript all through. Any other action type is
+* refused here, at the boundary.
+*/
+const FieldScriptWriteSchema = zod.z.lazy(() => zod.z.object({
+	type: zod.z.literal("javascript"),
+	script: zod.z.string(),
+	next: zod.z.array(FieldScriptWriteSchema).optional()
+}));
+/** A field's scripts to write, by event: a script sets one, `null` removes it. */
+const FieldActionsPatchSchema = zod.z.object({
+	keystroke: FieldScriptWriteSchema.nullable().optional(),
+	format: FieldScriptWriteSchema.nullable().optional(),
+	validate: FieldScriptWriteSchema.nullable().optional(),
+	calculate: FieldScriptWriteSchema.nullable().optional()
+});
+/**
+* Stable public component names for generators that project the action wire
+* model into OpenAPI or another schema format. Keep reusable boundaries here;
+* individual action arms remain owned by `PdfActionNodeSchema`.
+*/
+const PdfActionWireComponents = {
+	PdfActionTargetRef: PdfActionTargetRefSchema,
+	PageDestination: PageDestinationSchema,
+	PdfActionNode: PdfActionNodeSchema,
+	PdfActionTree: PdfActionTreeSchema,
+	PdfFieldActions: PdfFieldActionsSchema,
+	PdfPageActions: PdfPageActionsSchema,
+	PdfAnnotationActions: PdfAnnotationActionsSchema,
+	DocumentActionsSnapshot: DocumentActionsSnapshotSchema,
+	FieldScriptWrite: FieldScriptWriteSchema,
+	FieldActionsPatch: FieldActionsPatchSchema,
+	PdfActionWrite: PdfActionWriteSchema,
+	WidgetActionsPatch: WidgetActionsPatchSchema
+};
+//#endregion
+//#region src/annotation/declaration.ts
+function createField(read, write, traits) {
+	const next = (changed) => createField(read, write, {
+		...traits,
+		...changed
+	});
+	return {
+		read,
+		write,
+		traits,
+		nullable: () => next({
+			readNullable: true,
+			writeNullable: true
+		}),
+		nullableOnRead: () => next({ readNullable: true }),
+		optional: () => next({ required: false }),
+		createOnly: () => next({ createOnly: true }),
+		readBack: () => next({ readBack: true }),
+		space: (space) => next({ space }),
+		writes: (schema) => createField(read, schema, traits)
+	};
+}
+const ownedBy = (owner, required) => ({
+	owner,
+	readNullable: false,
+	writeNullable: false,
+	required,
+	createOnly: false,
+	readBack: false,
+	space: "none"
+});
+/** Field builders for {@link defineKind}. */
+const field = {
+	/** Written by the caller. Required on create until marked `optional()`. */
+	data: (schema) => createField(schema, schema, ownedBy("data", true)),
+	/** Stamped by the engine from the session's identity. */
+	attribution: (schema) => createField(schema, schema, ownedBy("attribution", false)),
+	/** Written only by the engine. */
+	engine: (schema) => createField(schema, schema, ownedBy("engine", false)),
+	/** Read from the PDF and kept in place, but not writable. */
+	preserved: (schema) => createField(schema, schema, ownedBy("preserved", false))
+};
+/**
+* The page-space schema of a field that holds a box or destinations, whose
+* shape differs from the file's: a box is `{ x, y, width, height }`, and a
+* destination is measured from its page's top-left. Every other place has
+* the same shape in both spaces.
+*/
+const PAGE_SPACE_SCHEMAS = {
+	box: {
+		read: PageBoxSchema,
+		write: PageBoxSchema
+	},
+	linkTarget: {
+		read: PdfLinkTargetSchema,
+		write: PdfLinkTargetWritableSchema
+	},
+	actions: {
+		read: PdfAnnotationActionsSchema,
+		write: WidgetActionsPatchSchema
+	}
+};
+/** The zod shapes of a kind's fields, each field's schemas given by `schemasOf`. */
+function shapesOf(subtype, fields, schemasOf) {
+	const read = { subtype: zod.z.literal(subtype) };
+	const create = { subtype: zod.z.literal(subtype) };
+	const update = { subtype: zod.z.literal(subtype).optional() };
+	const readBackWrites = {};
+	for (const [name, spec] of Object.entries(fields)) {
+		const { owner, readNullable, writeNullable, required, readBack } = spec.traits;
+		const schemas = schemasOf(spec);
+		read[name] = readNullable ? schemas.read.nullable() : schemas.read;
+		if (owner === "data") {
+			const write = writeNullable ? schemas.write.nullable() : schemas.write;
+			create[name] = required ? write : write.optional();
+			const readBackUpdate = schemas.read === schemas.write ? readNullable || writeNullable ? schemas.write.nullable() : schemas.write : zod.z.union([write, read[name]]);
+			update[name] = (readBack ? readBackUpdate : write).optional();
+			if (readBack) readBackWrites[name] = write;
+		} else {
+			create[name] = readBack ? read[name].optional() : zod.z.unknown().optional();
+			update[name] = readBack ? read[name].optional() : zod.z.unknown().optional();
+			if (readBack) readBackWrites[name] = null;
+		}
+	}
+	return {
+		read,
+		create,
+		update,
+		readBackWrites
+	};
+}
+/**
+* Declares an annotation kind from its fields and the resources it takes
+* beside its data. Fields are declared as the file holds them; the page-space
+* schemas follow from what each field holds (`space`).
+*/
+function defineKind(subtype, fields, resources = {}) {
+	const file = shapesOf(subtype, fields, (spec) => spec);
+	const page = shapesOf(subtype, fields, (spec) => PAGE_SPACE_SCHEMAS[spec.traits.space] ?? spec);
+	return {
+		subtype,
+		fields,
+		resources,
+		readSchema: zod.z.object(page.read),
+		createSchema: zod.z.object(page.create).strict(),
+		updateSchema: zod.z.object(page.update).strict(),
+		fileSchemas: {
+			read: zod.z.object(file.read),
+			create: zod.z.object(file.create).strict(),
+			update: zod.z.object(file.update).strict()
+		},
+		readBackWrites: file.readBackWrites,
+		shapes: {
+			read: page.read,
+			create: page.create,
+			update: page.update
+		}
+	};
+}
+//#endregion
+//#region src/dto/IsoDateTime.schema.ts
+/** ISO 8601 with an offset (`Z` or `±HH:mm`) or without one. */
+const IsoDateTimeSchema = zod.z.string().datetime({
+	offset: true,
+	local: true
+});
+/**
+* A moment in a write. JSON carries the string; a `Date` only ever arrives
+* in-process (the local engine), and becomes that string on the wire.
+*/
+const DateInputSchema = zod.z.union([IsoDateTimeSchema, zod.z.date()]);
+//#endregion
+//#region src/dto/Measure.schema.ts
+const float = zod.z.number().finite().refine((n) => Number.isFinite(Math.fround(n)), "Outside PDF float range");
+const point = zod.z.object({
+	x: float,
+	y: float
+}).strict();
+const positive = float.refine((n) => Math.fround(n) > 0, "Must be positive in PDF float precision");
+const PdfNumberFormatSchema = zod.z.object({
+	unit: zod.z.string(),
+	conversion: float.optional(),
+	fraction: zod.z.enum([
+		"decimal",
+		"fraction",
+		"round",
+		"truncate"
+	]).optional(),
+	precision: zod.z.number().int().optional(),
+	fixed: zod.z.boolean().optional(),
+	thousands: zod.z.string().optional(),
+	decimal: zod.z.string().optional(),
+	prefixSpacing: zod.z.string().optional(),
+	suffixSpacing: zod.z.string().optional(),
+	labelPosition: zod.z.enum(["suffix", "prefix"]).optional()
+});
+const PdfMeasureSchema = zod.z.object({
+	subtype: zod.z.literal("rectilinear"),
+	ratio: zod.z.string().optional(),
+	x: zod.z.array(PdfNumberFormatSchema),
+	y: zod.z.array(PdfNumberFormatSchema).optional(),
+	distance: zod.z.array(PdfNumberFormatSchema),
+	area: zod.z.array(PdfNumberFormatSchema),
+	angle: zod.z.array(PdfNumberFormatSchema).optional(),
+	slope: zod.z.array(PdfNumberFormatSchema).optional(),
+	origin: point.optional(),
+	cyx: float.optional()
+});
+const writableFormat = PdfNumberFormatSchema.extend({
+	conversion: positive,
+	precision: zod.z.number().int().min(1).max(2147483647).optional()
+}).refine(require_format.validNumberFormat, "Invalid number format precision");
+const PdfMeasureWriteSchema = PdfMeasureSchema.extend({
+	x: zod.z.array(writableFormat),
+	y: zod.z.array(writableFormat).optional(),
+	distance: zod.z.array(writableFormat),
+	area: zod.z.array(writableFormat),
+	angle: zod.z.array(writableFormat).optional(),
+	slope: zod.z.array(writableFormat).optional(),
+	cyx: positive.optional()
+});
+const geoMeasure = zod.z.object({ subtype: zod.z.literal("geospatial") });
+const unknownMeasure = zod.z.object({ subtype: zod.z.literal("unknown") });
+const PdfForeignMeasureSchema = zod.z.union([geoMeasure, unknownMeasure]);
+const PageScaleInputSchema = zod.z.object({ measure: PdfMeasureWriteSchema.nullable() });
+const PdfMeasurementSchema = zod.z.discriminatedUnion("subtype", [
+	PdfMeasureSchema,
+	geoMeasure,
+	unknownMeasure
+]);
+const PageMeasurementViewportSchema = zod.z.object({
+	bbox: PageBoxSchema,
+	name: zod.z.string().nullable(),
+	measure: PdfMeasurementSchema.nullable(),
+	owned: zod.z.boolean()
+});
+/** See `PageMeasurementViewportList`. */
+const PageMeasurementViewportListSchema = zod.z.object({ viewports: zod.z.array(PageMeasurementViewportSchema) });
+const LineIntentSchema = zod.z.enum(["line-arrow", "line-dimension"]);
+const PolygonIntentSchema = zod.z.enum(["polygon-cloud", "polygon-dimension"]);
+const PolylineIntentSchema = zod.z.literal("polyline-dimension");
+const offset = zod.z.object({
+	along: float,
+	perpendicular: float
+}).strict();
+const LineDimensionCaptionSchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	position: zod.z.enum(["inline", "top"]).optional(),
+	offset: offset.optional()
+}).strict();
+const ShapeDimensionCaptionSchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	center: point.optional()
+}).strict();
+const LineCaptionPatchSchema = zod.z.object({
+	enabled: zod.z.boolean().optional(),
+	position: zod.z.enum(["inline", "top"]).nullable().optional(),
+	offset: offset.nullable().optional()
+}).strict();
+const ShapeCaptionPatchSchema = zod.z.object({
+	enabled: zod.z.boolean().optional(),
+	center: point.nullable().optional()
+}).strict();
+const LineLeaderSchema = zod.z.object({
+	length: float,
+	extension: float.refine((n) => n >= 0).optional(),
+	offset: float.refine((n) => n >= 0).optional()
+}).strict();
+//#endregion
+//#region src/annotation/kinds/shared-fields.ts
+/** `/IRT` and `/RT`: the annotation this one replies to, and how it relates to it. */
+const AnnotationReplySchema = zod.z.object({
+	to: AnnotationRefSchema,
+	type: zod.z.enum(["reply", "group"])
+});
+/** A write may leave out `type`: an absent `/RT` means `'reply'` (ISO 32000-2 §12.5.6.2). */
+const AnnotationReplyWriteSchema = zod.z.object({
+	to: AnnotationRefSchema,
+	type: zod.z.enum(["reply", "group"]).optional()
+});
+/** A standard font name or a registered font key; the writer resolves which. */
+const FontNameSchema = zod.z.string().min(1);
+/** One `/F` bit (ISO 32000-2 §12.5.3); every bit defaults to off. */
+const flag = () => field.data(zod.z.boolean()).optional();
+/** Fields every annotation kind has. */
+const annotationBaseFields = {
+	ref: field.engine(AnnotationRefSchema),
+	page: field.engine(PageRefSchema),
+	/**
+	* Whether the file holds its appearance (`/AP /N`). Without one, every
+	* viewer draws the annotation from its fields: the engine in memory, never
+	* written.
+	*/
+	hasAppearance: field.engine(zod.z.boolean()),
+	/**
+	* `/AS`: which state of its appearance the annotation shows, when the
+	* appearance has states (a check box's `Off` and its on state); `null`
+	* when it names none. The appearance images are labelled with the same
+	* names, so this picks the one to show.
+	*/
+	appearanceState: field.engine(zod.z.string()).nullable(),
+	nm: field.data(zod.z.string()).nullable().optional().createOnly(),
+	rect: field.data(PdfRectSchema).space("box"),
+	contents: field.data(zod.z.string()).nullable().optional(),
+	subject: field.data(zod.z.string()).nullable().optional(),
+	blendMode: field.data(BlendModeSchema).optional(),
+	invisible: flag(),
+	hidden: flag(),
+	print: flag(),
+	noZoom: flag(),
+	noRotate: flag(),
+	noView: flag(),
+	readOnly: flag(),
+	locked: flag(),
+	toggleNoView: flag(),
+	lockedContents: flag(),
+	reply: field.data(AnnotationReplySchema).writes(AnnotationReplyWriteSchema).nullable().optional(),
+	/** `/Popup`, kept in sync by the engine from the popup's `parent`. */
+	popup: field.engine(AnnotationRefSchema).nullable(),
+	/** `/EMBD_Metadata/GroupID`: the group that owns the annotation. */
+	groupId: field.data(zod.z.string().min(1)).nullable().optional(),
+	author: field.attribution(zod.z.string()).nullable(),
+	/** `/CreationDate`. */
+	createdAt: field.attribution(IsoDateTimeSchema).writes(DateInputSchema).nullable(),
+	/** `/M`. */
+	modifiedAt: field.attribution(IsoDateTimeSchema).writes(DateInputSchema).nullable(),
+	userId: field.attribution(zod.z.string()).nullable(),
+	createdBy: field.attribution(zod.z.string()).nullable(),
+	/** `/EMBD_Metadata/UpdatedBy`. */
+	modifiedBy: field.attribution(zod.z.string()).nullable(),
+	/** The session that restored this annotation's attribution in an import. */
+	importedBy: field.engine(zod.z.string()).nullable(),
+	/** `/A` and `/AA`. */
+	actions: field.preserved(FileAnnotationActionsSchema).nullable().space("actions")
+};
+const colorStyleFields = {
+	color: field.data(ColorSchema).optional(),
+	opacity: field.data(zod.z.number().min(0).max(1)).optional()
+};
+const geometryStyleFields = {
+	...colorStyleFields,
+	strokeWidth: field.data(zod.z.number().nonnegative()).optional(),
+	/** `beveled` and `inset` are read from other apps' files and kept; only widgets draw them. */
+	borderStyle: field.data(AnnotationBorderStyleSchema).writes(DrawnBorderStyleSchema).readBack().optional(),
+	dashArray: field.data(zod.z.array(zod.z.number().nonnegative())).nullable().optional()
+};
+const filledStyleFields = {
+	...geometryStyleFields,
+	interiorColor: field.data(ColorSchema).nullable().optional()
+};
+/**
+* `rect` where another field gives the shape (a box, points, quads): where
+* the annotation sits on the page, the upright box around all it draws. The
+* engine works it out from the shape, so a create's `rect` is worked out
+* again. An update's `rect` other than the one read puts the shape there
+* (`shapeForRect`); the rect read, sent back, changes nothing.
+*/
+const drawnRectFields = { rect: field.engine(PdfRectSchema).readBack().space("box") };
+/**
+* The turn of a kind drawn from points (line, polyline, polygon, ink): the
+* points are upright, and the turn takes them about the middle of their box,
+* as a square turns about its box.
+*/
+const pointsTurnFields = { 
+/** Degrees clockwise, about the middle of the points' box. */
+rotation: field.data(zod.z.number()).nullable().optional() };
+/**
+* A kind drawn about a box that can turn: square, circle, free text, stamp
+* and caret. The caller gives the box and the turn; `rect` takes in the
+* turned box and what the drawing adds around it (a cloudy border's bumps, a
+* callout's line and arrow).
+*
+* A create gives `box`, or `rect` with a quarter turn: where the turned box
+* stands on the page, which pins the box down (`pdfQuarterTurnBox`). At any
+* other angle many boxes share one rect, so a create by `rect` is refused.
+*/
+const boxFields = {
+	...drawnRectFields,
+	/** The shape's own box, before any turn: a callout's text box. */
+	box: field.data(PdfRectSchema).space("box").optional(),
+	/** Degrees clockwise, about the middle of `box`. */
+	rotation: field.data(zod.z.number()).nullable().optional()
+};
+/**
+* A widget's frame and its turn: the box its contents are laid out in, and
+* a quarter turn (`/MK /R`, which the file holds counterclockwise), so every
+* viewer can lay an upright editor over it. `rect` is where the widget
+* stands on the page, the box turned. A create gives `box` or `rect`, as a
+* box kind's does.
+*/
+const widgetBoxFields = {
+	...drawnRectFields,
+	/** The box the contents are laid out in, before the turn: `rect` with its sides swapped under 90 and 270. */
+	box: field.data(PdfRectSchema).space("box").optional(),
+	/** Degrees clockwise, a quarter turn, about the middle of `box`; `null` upright. */
+	rotation: field.data(PdfRotationSchema).nullable().optional()
+};
+const textMarkupFields = {
+	...annotationBaseFields,
+	...colorStyleFields,
+	/** The box around the quads. */
+	...drawnRectFields,
+	quadPoints: field.data(zod.z.array(PdfQuadSchema).min(1)).space("quads")
+};
+const shapeFields = {
+	...annotationBaseFields,
+	...filledStyleFields,
+	...boxFields,
+	cloudyIntensity: field.data(zod.z.number().positive()).nullable().optional()
+};
+const vertexFields = {
+	...annotationBaseFields,
+	...filledStyleFields,
+	...drawnRectFields,
+	vertices: field.data(zod.z.array(PdfPointSchema)).space("points"),
+	...pointsTurnFields
+};
+/**
+* `/Measure`. A write takes a rectilinear scale, or sends back the marker a read
+* returned for a scale the engine can't model.
+*/
+const measureField = field.data(PdfMeasurementSchema).writes(zod.z.union([PdfMeasureWriteSchema, PdfForeignMeasureSchema])).nullable().optional().space("measure");
+/** Our caption on a polygon or polyline measurement; `null` when the shape has no caption flag. */
+const shapeCaptionFields = {
+	captionEnabled: field.data(zod.z.boolean()).nullable().optional(),
+	/** `null` places the caption automatically. */
+	captionCenter: field.data(PdfPointSchema).nullable().optional().space("point")
+};
+//#endregion
+//#region src/annotation/kinds/caret/declaration.ts
+const CaretDeclaration = defineKind("caret", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	...boxFields,
+	intent: field.data(CaretIntentSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/caret/index.ts
+const CaretDTOSchema = CaretDeclaration.readSchema;
+const CaretDraftSchema = CaretDeclaration.createSchema;
+const CaretPatchSchema = CaretDeclaration.updateSchema;
+const CaretKind = {
+	subtype: "caret",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.CARET,
+	dtoSchema: CaretDTOSchema,
+	draftSchema: CaretDraftSchema,
+	patchSchema: CaretPatchSchema,
+	readBackWrites: CaretDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/circle/declaration.ts
+const CircleDeclaration = defineKind("circle", shapeFields);
+//#endregion
+//#region src/annotation/kinds/circle/index.ts
+const CircleDTOSchema = CircleDeclaration.readSchema;
+const CircleDraftSchema = CircleDeclaration.createSchema;
+const CirclePatchSchema = CircleDeclaration.updateSchema;
+const CircleKind = {
+	subtype: "circle",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.CIRCLE,
+	dtoSchema: CircleDTOSchema,
+	draftSchema: CircleDraftSchema,
+	patchSchema: CirclePatchSchema,
+	readBackWrites: CircleDeclaration.readBackWrites
+};
+//#endregion
+//#region src/wire/resourceKeys.ts
+/**
+* A multipart message carries each file as a part `resource:<key>`, and its
+* JSON names the file by role: `resources: { <role>: <key> }`, on the
+* object the files belong to. These are those objects, one per set of roles.
+*/
+/** A file's key: the `<key>` of its `resource:<key>` part. */
+const ResourceKeySchema = zod.z.string().min(1);
+/** An annotation write's files: its drawing and its attached file. */
+const AnnotationResourceKeysSchema = zod.z.object({
+	appearance: ResourceKeySchema.optional(),
+	file: ResourceKeySchema.optional()
+}).strict();
+/** A drawn appearance: a signature's mark, as a one-page PDF or an image. */
+const AppearanceResourceKeysSchema = zod.z.object({ appearance: ResourceKeySchema }).strict();
+/** An attachment's file. */
+const FileResourceKeysSchema = zod.z.object({ file: ResourceKeySchema }).strict();
+/** The PDF whose pages an insert copies in. */
+const SourceResourceKeysSchema = zod.z.object({ source: ResourceKeySchema }).strict();
+/** An answer's picture. */
+const ImageResourceKeysSchema = zod.z.object({ image: ResourceKeySchema }).strict();
+//#endregion
+//#region src/dto/Attachment.schema.ts
+/**
+* Wire schemas for the attachment vocabulary (see `Attachment.ts`). The
+* write-side `AttachmentFileSource` carries bytes and never appears on the
+* wire; `WireAttachmentFile` is its form there.
+*/
+const WireAttachmentFileSchema = zod.z.object({
+	resources: FileResourceKeysSchema,
+	name: zod.z.string().min(1),
+	mimeType: zod.z.string().optional(),
+	description: zod.z.string().optional()
+});
+const AttachmentFileInfoSchema = zod.z.object({
+	name: zod.z.string(),
+	mimeType: zod.z.string().nullable(),
+	description: zod.z.string().nullable(),
+	size: zod.z.number().int().nonnegative().nullable(),
+	checksum: zod.z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	modifiedAt: IsoDateTimeSchema.nullable()
+});
+const AttachmentRefSchema = zod.z.object({
+	kind: zod.z.literal("key"),
+	key: zod.z.string().min(1)
+});
+const AttachmentSchema = zod.z.object({
+	ref: zod.z.object({
+		kind: zod.z.literal("key"),
+		key: zod.z.string()
+	}),
+	name: zod.z.string(),
+	mimeType: zod.z.string().nullable(),
+	description: zod.z.string().nullable(),
+	size: zod.z.number().int().nonnegative().nullable(),
+	checksum: zod.z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	modifiedAt: IsoDateTimeSchema.nullable(),
+	index: zod.z.number().int().nonnegative()
+});
+//#endregion
+//#region src/annotation/kinds/file-attachment/values.ts
+const FileAttachmentIconSchema = zod.z.enum([
+	"push-pin",
+	"paperclip",
+	"graph",
+	"tag"
+]);
+//#endregion
+//#region src/annotation/kinds/file-attachment/declaration.ts
+/**
+* The file's metadata; its bytes travel as the `file` resource. What a read
+* adds (size, checksum, creation date) comes from the bytes and is ignored.
+* A create may leave it out when the resource is a `File`, which brings its
+* name and type.
+*/
+const AttachmentFileWriteSchema = zod.z.object({
+	name: zod.z.string().min(1),
+	mimeType: zod.z.string().nullable().optional(),
+	description: zod.z.string().nullable().optional()
+});
+/** A file on the page: its icon fills `rect`, 20×20 at the usual size. */
+const FileAttachmentDeclaration = defineKind("file-attachment", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	icon: field.data(FileAttachmentIconSchema).optional(),
+	/**
+	* `null` when the file specification has no embedded file. A write takes
+	* what a read returns, so a read can be copied: on a create `null` is the
+	* same as leaving it out, and an update that sends back the `null` a read
+	* returned changes nothing (a file can't be removed).
+	*/
+	file: field.data(AttachmentFileInfoSchema).writes(AttachmentFileWriteSchema).nullable().optional()
+}, { file: "required" });
+//#endregion
+//#region src/annotation/kinds/file-attachment/index.ts
+const FileAttachmentDTOSchema = FileAttachmentDeclaration.readSchema;
+const FileAttachmentDraftSchema = FileAttachmentDeclaration.createSchema;
+const FileAttachmentPatchSchema = FileAttachmentDeclaration.updateSchema;
+const FileAttachmentKind = {
+	subtype: "file-attachment",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.FILEATTACHMENT,
+	dtoSchema: FileAttachmentDTOSchema,
+	draftSchema: FileAttachmentDraftSchema,
+	patchSchema: FileAttachmentPatchSchema,
+	readBackWrites: FileAttachmentDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/free-text/values.ts
+/** How a paragraph's lines line up: a free text's `textAlign` too. */
+const RichTextAlignSchema = zod.z.enum([
+	"left",
+	"center",
+	"right",
+	"justify"
+]);
+const RichTextRunStyleShape = {
+	family: zod.z.string().min(1),
+	weight: zod.z.number().int().min(100).max(900),
+	italic: zod.z.boolean(),
+	size: zod.z.number().nonnegative(),
+	color: ColorSchema,
+	decoration: zod.z.array(zod.z.enum([
+		"underline",
+		"line-through",
+		"word"
+	])),
+	script: zod.z.enum([
+		"normal",
+		"sub",
+		"super"
+	]),
+	letterSpacing: zod.z.number(),
+	horizontalScale: zod.z.number().positive(),
+	unknown: zod.z.string().optional()
+};
+const RichTextParagraphPropsShape = {
+	align: RichTextAlignSchema,
+	dir: zod.z.enum(["ltr", "rtl"]),
+	lineHeight: zod.z.number().positive().optional(),
+	margins: zod.z.object({
+		top: zod.z.number(),
+		bottom: zod.z.number(),
+		left: zod.z.number(),
+		right: zod.z.number()
+	}).optional(),
+	textIndent: zod.z.number().optional(),
+	unknown: zod.z.string().optional()
+};
+const RichTextRunStyleDeltaSchema = zod.z.object(RichTextRunStyleShape).partial();
+const RichTextParagraphSchema = zod.z.object({
+	...RichTextParagraphPropsShape,
+	runs: zod.z.array(zod.z.object({
+		text: zod.z.string(),
+		style: RichTextRunStyleDeltaSchema.optional()
+	}))
+}).partial({
+	align: true,
+	dir: true
+});
+const RichTextDocumentSchema = zod.z.object({
+	body: zod.z.object({
+		...RichTextRunStyleShape,
+		...RichTextParagraphPropsShape
+	}),
+	paragraphs: zod.z.array(RichTextParagraphSchema)
+});
+const RichTextDocumentInputSchema = zod.z.object({
+	body: zod.z.object({
+		...RichTextRunStyleShape,
+		...RichTextParagraphPropsShape
+	}).partial().optional(),
+	paragraphs: zod.z.array(RichTextParagraphSchema)
+});
+//#endregion
+//#region src/annotation/kinds/free-text/declaration.ts
+const FreeTextDeclaration = defineKind("free-text", {
+	...annotationBaseFields,
+	...boxFields,
+	/**
+	* A create without it is a callout when it has a `calloutLine`, else a
+	* plain box. A typewriter another app made is kept as it is.
+	*/
+	intent: field.data(FreeTextIntentSchema).writes(FreeTextIntentWriteSchema).readBack().optional(),
+	/** The text's font: the rich text body's. Helvetica when a create leaves it out. */
+	fontFamily: field.data(FontNameSchema).optional(),
+	/** The body's size in points: 12 when a create leaves it out. */
+	fontSize: field.data(zod.z.number().positive()).optional(),
+	/** The body's alignment: left when a create leaves it out. */
+	textAlign: field.data(RichTextAlignSchema).optional(),
+	/** Where the lines sit in the box: top when a create leaves it out. */
+	verticalAlign: field.data(VerticalAlignmentSchema).optional(),
+	richText: field.data(RichTextDocumentSchema).writes(RichTextDocumentInputSchema).optional().space("length"),
+	/** The border's color, and a callout line's. */
+	color: field.data(ColorSchema).optional(),
+	/** The text's color: the rich text body's. Black when a create leaves it out. */
+	fontColor: field.data(ColorSchema).optional(),
+	interiorColor: field.data(ColorSchema).nullable().optional(),
+	opacity: field.data(zod.z.number().min(0).max(1)).optional(),
+	strokeWidth: field.data(zod.z.number().nonnegative()).optional(),
+	borderStyle: field.data(AnnotationBorderStyleSchema).writes(DrawnBorderStyleSchema).readBack().optional(),
+	dashArray: field.data(zod.z.array(zod.z.number().nonnegative())).nullable().optional(),
+	cloudyIntensity: field.data(zod.z.number().positive()).nullable().optional(),
+	calloutLine: field.data(CalloutLineSchema).nullable().optional().space("calloutLine"),
+	lineEnding: field.data(LineEndingSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/free-text/index.ts
+const FreeTextDTOSchema = FreeTextDeclaration.readSchema;
+const FreeTextDraftSchema = FreeTextDeclaration.createSchema;
+const FreeTextPatchSchema = FreeTextDeclaration.updateSchema;
+const FreeTextKind = {
+	subtype: "free-text",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.FREETEXT,
+	dtoSchema: FreeTextDTOSchema,
+	draftSchema: FreeTextDraftSchema,
+	patchSchema: FreeTextPatchSchema,
+	readBackWrites: FreeTextDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/highlight/declaration.ts
+const HighlightDeclaration = defineKind("highlight", textMarkupFields);
+//#endregion
+//#region src/annotation/kinds/highlight/index.ts
+const HighlightDTOSchema = HighlightDeclaration.readSchema;
+const HighlightDraftSchema = HighlightDeclaration.createSchema;
+const HighlightPatchSchema = HighlightDeclaration.updateSchema;
+const HighlightKind = {
+	subtype: "highlight",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.HIGHLIGHT,
+	dtoSchema: HighlightDTOSchema,
+	draftSchema: HighlightDraftSchema,
+	patchSchema: HighlightPatchSchema,
+	readBackWrites: HighlightDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/ink/declaration.ts
+const InkDeclaration = defineKind("ink", {
+	...annotationBaseFields,
+	...geometryStyleFields,
+	/** More than 0 on a write: ink has no fill, so a line of 0 draws nothing. */
+	strokeWidth: field.data(zod.z.number().nonnegative()).writes(zod.z.number().positive()).readBack().optional(),
+	...drawnRectFields,
+	/** At least one stroke on a write, and no stroke without points. */
+	inkList: field.data(InkListSchema).writes(zod.z.array(zod.z.array(PdfPointSchema).min(1)).min(1)).readBack().space("strokes"),
+	intent: field.data(InkIntentSchema).nullable().optional(),
+	...pointsTurnFields
+});
+//#endregion
+//#region src/annotation/kinds/ink/index.ts
+const InkDTOSchema = InkDeclaration.readSchema;
+const InkDraftSchema = InkDeclaration.createSchema;
+const InkPatchSchema = InkDeclaration.updateSchema;
+const InkKind = {
+	subtype: "ink",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.INK,
+	dtoSchema: InkDTOSchema,
+	draftSchema: InkDraftSchema,
+	patchSchema: InkPatchSchema,
+	readBackWrites: InkDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/line/declaration.ts
+const LineDeclaration = defineKind("line", {
+	...annotationBaseFields,
+	...filledStyleFields,
+	...drawnRectFields,
+	linePoints: field.data(LinePointsSchema).space("linePoints"),
+	lineEndings: field.data(LineEndingsSchema).optional(),
+	...pointsTurnFields,
+	intent: field.data(LineIntentSchema).nullable().optional(),
+	measure: measureField,
+	/** `/Cap`: paint `/Contents` on the line. */
+	captionEnabled: field.data(zod.z.boolean()).nullable().optional(),
+	/** `/CP`. */
+	captionPosition: field.data(zod.z.enum(["inline", "top"])).optional(),
+	/** `/CO`, along the line and its normal; `null` is the normal position. */
+	captionOffset: field.data(zod.z.object({
+		along: zod.z.number(),
+		perpendicular: zod.z.number()
+	})).nullable().optional(),
+	/** `/LL`, `/LLE` and `/LLO`. */
+	leader: field.data(LineLeaderSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/line/index.ts
+const LineDTOSchema = LineDeclaration.readSchema;
+const LineDraftSchema = LineDeclaration.createSchema;
+const LinePatchSchema = LineDeclaration.updateSchema;
+const LineKind = {
+	subtype: "line",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.LINE,
+	dtoSchema: LineDTOSchema,
+	draftSchema: LineDraftSchema,
+	patchSchema: LinePatchSchema,
+	readBackWrites: LineDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/link/declaration.ts
+const LinkDeclaration = defineKind("link", {
+	...annotationBaseFields,
+	target: field.data(FileLinkTargetSchema).writes(FileLinkTargetWritableSchema).nullable().readBack().space("linkTarget")
+});
+//#endregion
+//#region src/annotation/kinds/link/index.ts
+const LinkDTOSchema = LinkDeclaration.readSchema;
+const LinkDraftSchema = LinkDeclaration.createSchema;
+const LinkPatchSchema = LinkDeclaration.updateSchema;
+const LinkKind = {
+	subtype: "link",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.LINK,
+	dtoSchema: LinkDTOSchema,
+	draftSchema: LinkDraftSchema,
+	patchSchema: LinkPatchSchema,
+	readBackWrites: LinkDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/polygon/declaration.ts
+const PolygonDeclaration = defineKind("polygon", {
+	...vertexFields,
+	/** At least three points on a write; fewer enclose nothing. */
+	vertices: field.data(zod.z.array(PdfPointSchema)).writes(zod.z.array(PdfPointSchema).min(3)).readBack().space("points"),
+	...shapeCaptionFields,
+	intent: field.data(PolygonIntentSchema).nullable().optional(),
+	measure: measureField,
+	cloudyIntensity: field.data(zod.z.number().positive()).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/polygon/index.ts
+const PolygonDTOSchema = PolygonDeclaration.readSchema;
+const PolygonDraftSchema = PolygonDeclaration.createSchema;
+const PolygonPatchSchema = PolygonDeclaration.updateSchema;
+const PolygonKind = {
+	subtype: "polygon",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.POLYGON,
+	dtoSchema: PolygonDTOSchema,
+	draftSchema: PolygonDraftSchema,
+	patchSchema: PolygonPatchSchema,
+	readBackWrites: PolygonDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/polyline/declaration.ts
+const PolylineDeclaration = defineKind("polyline", {
+	...vertexFields,
+	/** At least two points on a write; fewer draw nothing. */
+	vertices: field.data(zod.z.array(PdfPointSchema)).writes(zod.z.array(PdfPointSchema).min(2)).readBack().space("points"),
+	...shapeCaptionFields,
+	intent: field.data(PolylineIntentSchema).nullable().optional(),
+	measure: measureField,
+	lineEndings: field.data(LineEndingsSchema).optional()
+});
+//#endregion
+//#region src/annotation/kinds/polyline/index.ts
+const PolylineDTOSchema = PolylineDeclaration.readSchema;
+const PolylineDraftSchema = PolylineDeclaration.createSchema;
+const PolylinePatchSchema = PolylineDeclaration.updateSchema;
+const PolylineKind = {
+	subtype: "polyline",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.POLYLINE,
+	dtoSchema: PolylineDTOSchema,
+	draftSchema: PolylineDraftSchema,
+	patchSchema: PolylinePatchSchema,
+	readBackWrites: PolylineDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/popup/declaration.ts
+/** The window that shows its parent annotation's text. */
+const PopupDeclaration = defineKind("popup", {
+	...annotationBaseFields,
+	/**
+	* `/Parent`: the annotation this popup shows. Required on create; `null`
+	* on a read of a popup whose PDF names none, which an update may send
+	* back unchanged.
+	*/
+	parent: field.data(AnnotationRefSchema).nullableOnRead().readBack(),
+	/** `/Open`: whether the window is shown open. `false` when the PDF doesn't say. */
+	open: field.data(zod.z.boolean()).optional()
+});
+//#endregion
+//#region src/annotation/kinds/popup/index.ts
+const PopupDTOSchema = PopupDeclaration.readSchema;
+const PopupDraftSchema = PopupDeclaration.createSchema;
+const PopupPatchSchema = PopupDeclaration.updateSchema;
+const PopupKind = {
+	subtype: "popup",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.POPUP,
+	dtoSchema: PopupDTOSchema,
+	draftSchema: PopupDraftSchema,
+	patchSchema: PopupPatchSchema,
+	readBackWrites: PopupDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/redact/declaration.ts
+const RedactDeclaration = defineKind("redact", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	/** Worked out from the quads when a create gives quads and no `rect`. */
+	rect: field.data(PdfRectSchema).optional().space("box"),
+	quadPoints: field.data(zod.z.array(PdfQuadSchema)).optional().space("quads"),
+	interiorColor: field.data(ColorSchema).nullable().optional(),
+	overlayText: field.data(zod.z.string()).nullable().optional(),
+	repeat: field.data(zod.z.boolean()).optional(),
+	/** A standard font or a registered key, as on free text. */
+	fontFamily: field.data(FontNameSchema).optional(),
+	/** `0` fits the label to the region. */
+	fontSize: field.data(zod.z.number().nonnegative()).optional(),
+	fontColor: field.data(ColorSchema).optional(),
+	textAlign: field.data(TextAlignmentSchema).optional()
+});
+//#endregion
+//#region src/annotation/kinds/redact/index.ts
+const RedactDTOSchema = RedactDeclaration.readSchema;
+const RedactDraftSchema = RedactDeclaration.createSchema;
+const RedactPatchSchema = RedactDeclaration.updateSchema;
+const RedactKind = {
+	subtype: "redact",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.REDACT,
+	dtoSchema: RedactDTOSchema,
+	draftSchema: RedactDraftSchema,
+	patchSchema: RedactPatchSchema,
+	readBackWrites: RedactDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/square/declaration.ts
+const SquareDeclaration = defineKind("square", shapeFields);
+//#endregion
+//#region src/annotation/kinds/square/index.ts
+const SquareDTOSchema = SquareDeclaration.readSchema;
+const SquareDraftSchema = SquareDeclaration.createSchema;
+const SquarePatchSchema = SquareDeclaration.updateSchema;
+const SquareKind = {
+	subtype: "square",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.SQUARE,
+	dtoSchema: SquareDTOSchema,
+	draftSchema: SquareDraftSchema,
+	patchSchema: SquarePatchSchema,
+	readBackWrites: SquareDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/squiggly/declaration.ts
+const SquigglyDeclaration = defineKind("squiggly", textMarkupFields);
+//#endregion
+//#region src/annotation/kinds/squiggly/index.ts
+const SquigglyDTOSchema = SquigglyDeclaration.readSchema;
+const SquigglyDraftSchema = SquigglyDeclaration.createSchema;
+const SquigglyPatchSchema = SquigglyDeclaration.updateSchema;
+const SquigglyKind = {
+	subtype: "squiggly",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.SQUIGGLY,
+	dtoSchema: SquigglyDTOSchema,
+	draftSchema: SquigglyDraftSchema,
+	patchSchema: SquigglyPatchSchema,
+	readBackWrites: SquigglyDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/stamp/values.ts
+const StampFitSchema = zod.z.enum([
+	"contain",
+	"cover",
+	"fill"
+]);
+//#endregion
+//#region src/annotation/kinds/stamp/declaration.ts
+const StampDeclaration = defineKind("stamp", {
+	...annotationBaseFields,
+	...boxFields,
+	/** `/Name`: the stamp's label, such as `Approved`. */
+	name: field.data(zod.z.string()).nullable().optional(),
+	/**
+	* How the drawing is scaled into the box, and re-fit when the box changes
+	* (`/EMBD_Metadata/AppearanceFit`). `null` when the PDF doesn't record it,
+	* as for a stamp another tool made; the engine then fits with `'fill'`,
+	* the way a PDF places any appearance in its `/Rect`. A create without it
+	* fits with `'contain'` and records that.
+	*/
+	fit: field.data(StampFitSchema).nullable().optional(),
+	/** `/CA`, painted once over the whole drawing. */
+	opacity: field.data(zod.z.number().min(0).max(1)).optional()
+}, { appearance: "required" });
+//#endregion
+//#region src/annotation/kinds/stamp/index.ts
+const StampDTOSchema = StampDeclaration.readSchema;
+const StampDraftSchema = StampDeclaration.createSchema;
+const StampPatchSchema = StampDeclaration.updateSchema;
+const StampKind = {
+	subtype: "stamp",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.STAMP,
+	dtoSchema: StampDTOSchema,
+	draftSchema: StampDraftSchema,
+	patchSchema: StampPatchSchema,
+	readBackWrites: StampDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/strikeout/declaration.ts
+const StrikeoutDeclaration = defineKind("strikeout", {
+	...textMarkupFields,
+	intent: field.data(StrikeoutIntentSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/strikeout/index.ts
+const StrikeoutDTOSchema = StrikeoutDeclaration.readSchema;
+const StrikeoutDraftSchema = StrikeoutDeclaration.createSchema;
+const StrikeoutPatchSchema = StrikeoutDeclaration.updateSchema;
+const StrikeoutKind = {
+	subtype: "strikeout",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.STRIKEOUT,
+	dtoSchema: StrikeoutDTOSchema,
+	draftSchema: StrikeoutDraftSchema,
+	patchSchema: StrikeoutPatchSchema,
+	readBackWrites: StrikeoutDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/text/values.ts
+const NoteIconSchema = zod.z.enum([
+	"comment",
+	"key",
+	"note",
+	"help",
+	"new-paragraph",
+	"paragraph",
+	"insert"
+]);
+//#endregion
+//#region src/annotation/kinds/text/declaration.ts
+/** A note: its icon fills `rect`, 20×20 at the usual size. */
+const TextDeclaration = defineKind("text", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	icon: field.data(NoteIconSchema).optional(),
+	/**
+	* `/Open`: whether the note's window shows open. Kept equal to its
+	* popup's `open`: a write sets both. `false` when the PDF doesn't say.
+	*/
+	open: field.data(zod.z.boolean()).optional(),
+	/** `/State`: standard states in lowercase, custom ones as written. */
+	state: field.data(zod.z.string().min(1)).nullable().optional(),
+	stateModel: field.data(zod.z.string().min(1)).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/text/index.ts
+const TextDTOSchema = TextDeclaration.readSchema;
+const TextDraftSchema = TextDeclaration.createSchema;
+const TextPatchSchema = TextDeclaration.updateSchema;
+const TextKind = {
+	subtype: "text",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.TEXT,
+	dtoSchema: TextDTOSchema,
+	draftSchema: TextDraftSchema,
+	patchSchema: TextPatchSchema,
+	readBackWrites: TextDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/underline/declaration.ts
+const UnderlineDeclaration = defineKind("underline", textMarkupFields);
+//#endregion
+//#region src/annotation/kinds/underline/index.ts
+const UnderlineDTOSchema = UnderlineDeclaration.readSchema;
+const UnderlineDraftSchema = UnderlineDeclaration.createSchema;
+const UnderlinePatchSchema = UnderlineDeclaration.updateSchema;
+const UnderlineKind = {
+	subtype: "underline",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.UNDERLINE,
+	dtoSchema: UnderlineDTOSchema,
+	draftSchema: UnderlineDraftSchema,
+	patchSchema: UnderlinePatchSchema,
+	readBackWrites: UnderlineDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/unsupported/declaration.ts
+/** An annotation of a type the engine doesn't model: only the shared fields are read. */
+const UnsupportedDeclaration = defineKind("unsupported", {
+	...annotationBaseFields,
+	rawSubtypeCode: field.engine(zod.z.number().int()),
+	rawSubtypeName: field.engine(zod.z.string()).nullable()
+});
+//#endregion
+//#region src/annotation/kinds/unsupported/index.ts
+const UnsupportedDTOSchema = UnsupportedDeclaration.readSchema;
+const UnsupportedDraftSchema = zod.z.never();
+const UnsupportedPatchSchema = zod.z.never();
+const UnsupportedKind = {
+	subtype: "unsupported",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.UNKNOWN,
+	dtoSchema: UnsupportedDTOSchema,
+	draftSchema: UnsupportedDraftSchema,
+	patchSchema: UnsupportedPatchSchema,
+	readBackWrites: UnsupportedDeclaration.readBackWrites
+};
+//#endregion
+//#region src/identity/FormFieldRef.schema.ts
+/** Wire form of `FormFieldRef` — see the type. */
+const FormFieldRefSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("objectNumber"),
+	objectNumber: zod.z.number().int().positive()
+}), zod.z.object({
+	kind: zod.z.literal("fqn"),
+	name: zod.z.string().min(1)
+})]);
+//#endregion
+//#region src/annotation/kinds/widget/declaration.ts
+const WidgetDeclaration = defineKind("widget", {
+	...annotationBaseFields,
+	...widgetBoxFields,
+	color: field.data(ColorSchema).nullable().optional(),
+	interiorColor: field.data(ColorSchema).nullable().optional(),
+	strokeWidth: field.data(zod.z.number().nonnegative()).optional(),
+	borderStyle: field.data(WidgetBorderStyleSchema).optional(),
+	/** The border's dash pattern (`/BS /D`), for a dashed border; `null` for the default (3 on, 3 off). */
+	dashArray: field.data(zod.z.array(zod.z.number().nonnegative())).nullable().optional(),
+	/**
+	* The font `/DA` names, as a free text names its font: a standard font's
+	* name, a registered font's key, or the family of a font the document has.
+	* `null` when `/DA` names none. A write takes a standard name or a key.
+	*/
+	fontFamily: field.data(FontNameSchema).nullable().optional(),
+	fontSize: field.data(zod.z.number().nonnegative()).nullable().optional(),
+	fontColor: field.data(ColorSchema).nullable().optional(),
+	textAlign: field.data(TextAlignmentSchema).optional(),
+	/**
+	* A push button's caption (`/MK /CA`), drawn centred on the button.
+	* `null` for every other widget, whose `/MK /CA` is no caption (a
+	* checkbox's is its symbol); a caption written to one is refused.
+	*/
+	caption: field.data(zod.z.string()).nullable().optional(),
+	/**
+	* The symbol a checkbox's or radio button's widget shows while it's on
+	* (`/MK /CA`); `null` shows its family's own, a checkbox's check and a
+	* radio button's circle. Always `null` for other widgets, and one written
+	* to another widget is refused.
+	*/
+	checkStyle: field.data(WidgetCheckStyleSchema).nullable().optional(),
+	/**
+	* `/A` and `/AA`: what the widget does when clicked, entered, focused and
+	* so on. A write sets an event's action, `null` removes it, an event left
+	* out keeps what it has; `null` for the whole removes them all. The
+	* actions a read returns, sent back unchanged, are kept.
+	*/
+	actions: field.data(FileAnnotationActionsSchema).writes(FileWidgetActionsPatchSchema).readBack().nullable().optional().space("actions"),
+	/** The field the widget belongs to, or `null` when it's in none. */
+	field: field.engine(FormFieldRefSchema).nullable(),
+	/** Its field's family, so a widget reads as what it is without the form. */
+	fieldFamily: field.engine(zod.z.enum([
+		"text",
+		"checkbox",
+		"radio",
+		"combobox",
+		"listbox",
+		"pushbutton",
+		"signature",
+		"unknown"
+	]))
+});
+//#endregion
+//#region src/annotation/kinds/widget/index.ts
+const WidgetDTOSchema = WidgetDeclaration.readSchema;
+const WidgetDraftSchema = WidgetDeclaration.createSchema;
+const WidgetPatchSchema = WidgetDeclaration.updateSchema;
+const WidgetKind = {
+	subtype: "widget",
+	pdfSubtypeCode: require_subtype.PdfAnnotationSubtypeCode.WIDGET,
+	dtoSchema: WidgetDTOSchema,
+	draftSchema: WidgetDraftSchema,
+	patchSchema: WidgetPatchSchema,
+	readBackWrites: WidgetDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/declarations.ts
+/** Every annotation kind's declaration, in the engine's catalog order. */
+const ANNOTATION_DECLARATIONS = [
+	HighlightDeclaration,
+	UnderlineDeclaration,
+	SquigglyDeclaration,
+	StrikeoutDeclaration,
+	CircleDeclaration,
+	SquareDeclaration,
+	PolygonDeclaration,
+	PolylineDeclaration,
+	LineDeclaration,
+	LinkDeclaration,
+	InkDeclaration,
+	FreeTextDeclaration,
+	CaretDeclaration,
+	TextDeclaration,
+	StampDeclaration,
+	FileAttachmentDeclaration,
+	WidgetDeclaration,
+	RedactDeclaration,
+	PopupDeclaration,
+	UnsupportedDeclaration
+];
+/** Looks up a kind's declaration by its `subtype`. */
+function declarationOf(subtype) {
+	return ANNOTATION_DECLARATIONS.find((declaration) => declaration.subtype === subtype) ?? null;
+}
+/** The style fields' schemas, as a widget annotation's update takes them. */
+const WIDGET_STYLE_SHAPE = Object.fromEntries([
+	"color",
+	"interiorColor",
+	"strokeWidth",
+	"borderStyle",
+	"dashArray",
+	"fontFamily",
+	"fontSize",
+	"fontColor",
+	"textAlign",
+	"caption",
+	"checkStyle"
+].map((name) => [name, WidgetDeclaration.shapes.update[name]]));
+const WidgetAppearanceSchema = zod.z.object(WIDGET_STYLE_SHAPE).strict();
+//#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>/` with its
+* `declaration.ts` and `index.ts`, and one entry in this tuple and in
+* `declarations.ts`. 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,
+	PopupKind,
+	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 AnnotationSchema = zod.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,
+	PopupKind.dtoSchema,
+	UnsupportedKind.dtoSchema
+]);
+/** Validates a create's data against its kind. */
+const AnnotationDraftSchema = zod.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,
+	PopupKind.draftSchema
+]);
+/**
+* Validates a patch against every kind. A
+* patch may leave out its `subtype`, so this only checks that the patch fits
+* some kind; {@link annotationPatchSchemaOf} checks it against its target.
+*/
+const AnnotationPatchSchema = zod.z.union(ANNOTATION_KINDS.filter((kind) => kind.subtype !== "unsupported").map((kind) => kind.patchSchema));
+/** The patch schema of one kind: how an update of an annotation of that kind is checked. */
+function annotationPatchSchemaOf(subtype) {
+	return KIND_BY_SUBTYPE[subtype].patchSchema;
+}
+/**
+* A create's data in the file's coordinates, checked against its kind: the
+* engine's own check, after the worker converted the data from page space.
+*/
+const FileAnnotationDraftSchema = zod.z.discriminatedUnion("subtype", ANNOTATION_DECLARATIONS.filter((declaration) => declaration.subtype !== "unsupported").map((declaration) => declaration.fileSchemas.create));
+/** An update's data in the file's coordinates, checked against the kind it changes. */
+function fileAnnotationPatchSchemaOf(subtype) {
+	return declarationOf(subtype).fileSchemas.update;
+}
+//#endregion
+//#region src/forms/schema.ts
+const FormWidgetShape = {
+	ref: AnnotationRefSchema.nullable(),
+	objectNumber: zod.z.number().int().nonnegative(),
+	page: PageRefSchema.nullable()
+};
+const FormWidgetSchema = zod.z.object(FormWidgetShape);
+const FormFieldWidgetSchema = FormWidgetSchema;
+const ToggleFieldWidgetSchema = zod.z.object({
+	...FormWidgetShape,
+	onState: zod.z.string(),
+	exportValue: zod.z.string(),
+	checked: zod.z.boolean()
+});
+const FormFieldOptionSchema = zod.z.object({
+	label: zod.z.string(),
+	value: zod.z.string(),
+	selected: zod.z.boolean()
+});
+const FormValueEntrySchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({ kind: zod.z.literal("none") }),
+	zod.z.object({
+		kind: zod.z.literal("scalar"),
+		value: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("array"),
+		values: zod.z.array(zod.z.string())
+	}),
+	zod.z.object({ kind: zod.z.literal("unsupported") })
+]);
+const FormFieldBaseShape = {
+	ref: FormFieldRefSchema,
+	name: zod.z.string(),
+	origin: zod.z.enum(["acroform", "recovered"]),
+	readOnly: zod.z.boolean(),
+	required: zod.z.boolean(),
+	noExport: zod.z.boolean(),
+	alternateName: zod.z.string().nullable(),
+	mappingName: zod.z.string().nullable(),
+	valueEntry: FormValueEntrySchema,
+	defaultValueEntry: FormValueEntrySchema,
+	actions: PdfFieldActionsSchema.optional(),
+	groupId: zod.z.string().nullable(),
+	createdBy: zod.z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	filledBy: zod.z.string().nullable(),
+	filledByName: zod.z.string().nullable(),
+	filledAt: IsoDateTimeSchema.nullable(),
+	importedBy: zod.z.string().nullable(),
+	widgets: zod.z.array(FormFieldWidgetSchema)
+};
+const FormFieldDTOSchema = zod.z.discriminatedUnion("family", [
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("text"),
+		value: zod.z.string(),
+		defaultValue: zod.z.string(),
+		maxLength: zod.z.number().int().positive().nullable(),
+		multiline: zod.z.boolean(),
+		password: zod.z.boolean(),
+		comb: zod.z.boolean()
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("checkbox"),
+		checked: zod.z.boolean(),
+		exportValue: zod.z.string(),
+		widgets: zod.z.array(ToggleFieldWidgetSchema)
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("radio"),
+		value: zod.z.string(),
+		radiosInUnison: zod.z.boolean(),
+		noToggleToOff: zod.z.boolean(),
+		widgets: zod.z.array(ToggleFieldWidgetSchema)
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("combobox"),
+		value: zod.z.string(),
+		defaultValue: zod.z.string(),
+		edit: zod.z.boolean(),
+		options: zod.z.array(FormFieldOptionSchema)
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("listbox"),
+		selectedValues: zod.z.array(zod.z.string()),
+		defaultValue: zod.z.array(zod.z.string()),
+		multiSelect: zod.z.boolean(),
+		options: zod.z.array(FormFieldOptionSchema),
+		topIndex: zod.z.number().int().nonnegative()
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("pushbutton")
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("signature")
+	}),
+	zod.z.object({
+		...FormFieldBaseShape,
+		family: zod.z.literal("unknown"),
+		rawValue: zod.z.string()
+	})
+]);
+const FormKindSchema = zod.z.enum([
+	"none",
+	"acroform",
+	"xfa"
+]);
+const FormSnapshotSchema = zod.z.object({
+	formKind: FormKindSchema,
+	needsAppearances: zod.z.boolean(),
+	fields: zod.z.array(FormFieldDTOSchema),
+	widgets: zod.z.array(WidgetDTOSchema),
+	calculationOrder: zod.z.array(FormFieldRefSchema.nullable())
+});
+/**
+* `{ value }`, `{ checked }` or `{ selectedValues }`: one object with exactly
+* one of the three, so the wire has no untagged union (the API reference
+* labels variants by a discriminating literal, and a value has none to add).
+*/
+const FormFieldValueSchema = zod.z.object({
+	value: zod.z.string().nullable().optional(),
+	checked: zod.z.boolean().optional(),
+	selectedValues: zod.z.array(zod.z.string()).optional()
+}).strict().refine((value) => [
+	value.value,
+	value.checked,
+	value.selectedValues
+].filter((set) => set !== void 0).length === 1, { message: "exactly one of value, checked or selectedValues" });
+const WidgetPlacementSchema = zod.z.object({
+	page: PageRefSchema,
+	rect: PageBoxSchema.optional(),
+	box: PageBoxSchema.optional(),
+	rotation: PdfRotationSchema.optional(),
+	exportValue: zod.z.string().min(1).optional(),
+	actions: WidgetActionsPatchSchema.optional(),
+	...WIDGET_STYLE_SHAPE
+}).strict();
+const FormFieldOptionInputSchema = zod.z.object({
+	label: zod.z.string(),
+	value: zod.z.string()
+});
+const FormFieldDraftBaseShape = {
+	name: zod.z.string().min(1),
+	readOnly: zod.z.boolean().optional(),
+	required: zod.z.boolean().optional(),
+	noExport: zod.z.boolean().optional(),
+	alternateName: zod.z.string().optional(),
+	mappingName: zod.z.string().optional(),
+	groupId: zod.z.string().min(1).max(256).optional(),
+	actions: FieldActionsPatchSchema.optional(),
+	widgets: zod.z.array(WidgetPlacementSchema).optional()
+};
+/** A draft that names a member its family doesn't have is refused, not trimmed. */
+const FormFieldDraftSchema = zod.z.discriminatedUnion("family", [
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("text"),
+		defaultValue: zod.z.string().optional(),
+		maxLength: zod.z.number().int().positive().optional(),
+		multiline: zod.z.boolean().optional(),
+		password: zod.z.boolean().optional(),
+		comb: zod.z.boolean().optional()
+	}).strict(),
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("checkbox")
+	}).strict(),
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("radio"),
+		radiosInUnison: zod.z.boolean().optional(),
+		noToggleToOff: zod.z.boolean().optional()
+	}).strict(),
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("combobox"),
+		edit: zod.z.boolean().optional(),
+		options: zod.z.array(FormFieldOptionInputSchema).optional(),
+		defaultValue: zod.z.string().optional()
+	}).strict(),
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("listbox"),
+		multiSelect: zod.z.boolean().optional(),
+		options: zod.z.array(FormFieldOptionInputSchema).optional(),
+		defaultValue: zod.z.array(zod.z.string()).optional()
+	}).strict(),
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("pushbutton")
+	}).strict(),
+	zod.z.object({
+		...FormFieldDraftBaseShape,
+		family: zod.z.literal("signature")
+	}).strict()
+]);
+const FormFieldPatchBaseShape = {
+	name: zod.z.string().min(1).optional(),
+	readOnly: zod.z.boolean().optional(),
+	required: zod.z.boolean().optional(),
+	noExport: zod.z.boolean().optional(),
+	alternateName: zod.z.string().nullable().optional(),
+	mappingName: zod.z.string().nullable().optional(),
+	groupId: zod.z.string().min(1).max(256).optional(),
+	actions: FieldActionsPatchSchema.optional()
+};
+/**
+* One object on the wire: the family is optional (the engine knows it from
+* the ref), so there is no discriminator, and the engine refuses members
+* the field's family doesn't have.
+*/
+const FormFieldPatchSchema = zod.z.object({
+	...FormFieldPatchBaseShape,
+	family: zod.z.enum([
+		"text",
+		"checkbox",
+		"radio",
+		"combobox",
+		"listbox",
+		"pushbutton",
+		"signature"
+	]).optional(),
+	defaultValue: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).nullable().optional(),
+	maxLength: zod.z.number().int().positive().nullable().optional(),
+	multiline: zod.z.boolean().optional(),
+	password: zod.z.boolean().optional(),
+	comb: zod.z.boolean().optional(),
+	radiosInUnison: zod.z.boolean().optional(),
+	noToggleToOff: zod.z.boolean().optional(),
+	edit: zod.z.boolean().optional(),
+	multiSelect: zod.z.boolean().optional(),
+	options: zod.z.array(FormFieldOptionInputSchema).optional()
+}).strict();
+//#endregion
+Object.defineProperty(exports, "ANNOTATION_KINDS", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_KINDS;
+	}
+});
+Object.defineProperty(exports, "AnnotationBorderStyleSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationBorderStyleSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationDraftSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationPatchSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationRefSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationRefSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationResourceKeysSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationResourceKeysSchema;
+	}
+});
+Object.defineProperty(exports, "AnnotationSchema", {
+	enumerable: true,
+	get: function() {
+		return AnnotationSchema;
+	}
+});
+Object.defineProperty(exports, "AppearanceResourceKeysSchema", {
+	enumerable: true,
+	get: function() {
+		return AppearanceResourceKeysSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentFileInfoSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentFileInfoSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentRefSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentRefSchema;
+	}
+});
+Object.defineProperty(exports, "AttachmentSchema", {
+	enumerable: true,
+	get: function() {
+		return AttachmentSchema;
+	}
+});
+Object.defineProperty(exports, "BlendModeSchema", {
+	enumerable: true,
+	get: function() {
+		return BlendModeSchema;
+	}
+});
+Object.defineProperty(exports, "CalloutLineSchema", {
+	enumerable: true,
+	get: function() {
+		return CalloutLineSchema;
+	}
+});
+Object.defineProperty(exports, "CaretDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return CaretDTOSchema;
+	}
+});
+Object.defineProperty(exports, "CaretDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return CaretDraftSchema;
+	}
+});
+Object.defineProperty(exports, "CaretIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return CaretIntentSchema;
+	}
+});
+Object.defineProperty(exports, "CaretPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return CaretPatchSchema;
+	}
+});
+Object.defineProperty(exports, "CircleDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return CircleDTOSchema;
+	}
+});
+Object.defineProperty(exports, "CircleDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return CircleDraftSchema;
+	}
+});
+Object.defineProperty(exports, "CirclePatchSchema", {
+	enumerable: true,
+	get: function() {
+		return CirclePatchSchema;
+	}
+});
+Object.defineProperty(exports, "ColorSchema", {
+	enumerable: true,
+	get: function() {
+		return ColorSchema;
+	}
+});
+Object.defineProperty(exports, "DateInputSchema", {
+	enumerable: true,
+	get: function() {
+		return DateInputSchema;
+	}
+});
+Object.defineProperty(exports, "DocumentActionsSnapshotSchema", {
+	enumerable: true,
+	get: function() {
+		return DocumentActionsSnapshotSchema;
+	}
+});
+Object.defineProperty(exports, "DrawnBorderStyleSchema", {
+	enumerable: true,
+	get: function() {
+		return DrawnBorderStyleSchema;
+	}
+});
+Object.defineProperty(exports, "FieldActionsPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return FieldActionsPatchSchema;
+	}
+});
+Object.defineProperty(exports, "FieldScriptWriteSchema", {
+	enumerable: true,
+	get: function() {
+		return FieldScriptWriteSchema;
+	}
+});
+Object.defineProperty(exports, "FileAnnotationDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return FileAnnotationDraftSchema;
+	}
+});
+Object.defineProperty(exports, "FileAttachmentDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return FileAttachmentDTOSchema;
+	}
+});
+Object.defineProperty(exports, "FileAttachmentDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return FileAttachmentDraftSchema;
+	}
+});
+Object.defineProperty(exports, "FileAttachmentIconSchema", {
+	enumerable: true,
+	get: function() {
+		return FileAttachmentIconSchema;
+	}
+});
+Object.defineProperty(exports, "FileAttachmentPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return FileAttachmentPatchSchema;
+	}
+});
+Object.defineProperty(exports, "FileResourceKeysSchema", {
+	enumerable: true,
+	get: function() {
+		return FileResourceKeysSchema;
+	}
+});
+Object.defineProperty(exports, "FileWidgetActionsPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return FileWidgetActionsPatchSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldDTOSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldDraftSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldOptionInputSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldOptionInputSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldOptionSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldOptionSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldPatchSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldRefSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldRefSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldValueSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldValueSchema;
+	}
+});
+Object.defineProperty(exports, "FormFieldWidgetSchema", {
+	enumerable: true,
+	get: function() {
+		return FormFieldWidgetSchema;
+	}
+});
+Object.defineProperty(exports, "FormKindSchema", {
+	enumerable: true,
+	get: function() {
+		return FormKindSchema;
+	}
+});
+Object.defineProperty(exports, "FormSnapshotSchema", {
+	enumerable: true,
+	get: function() {
+		return FormSnapshotSchema;
+	}
+});
+Object.defineProperty(exports, "FormValueEntrySchema", {
+	enumerable: true,
+	get: function() {
+		return FormValueEntrySchema;
+	}
+});
+Object.defineProperty(exports, "FormWidgetSchema", {
+	enumerable: true,
+	get: function() {
+		return FormWidgetSchema;
+	}
+});
+Object.defineProperty(exports, "FreeTextDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return FreeTextDTOSchema;
+	}
+});
+Object.defineProperty(exports, "FreeTextDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return FreeTextDraftSchema;
+	}
+});
+Object.defineProperty(exports, "FreeTextIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return FreeTextIntentSchema;
+	}
+});
+Object.defineProperty(exports, "FreeTextIntentWriteSchema", {
+	enumerable: true,
+	get: function() {
+		return FreeTextIntentWriteSchema;
+	}
+});
+Object.defineProperty(exports, "FreeTextPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return FreeTextPatchSchema;
+	}
+});
+Object.defineProperty(exports, "HighlightDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return HighlightDTOSchema;
+	}
+});
+Object.defineProperty(exports, "HighlightDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return HighlightDraftSchema;
+	}
+});
+Object.defineProperty(exports, "HighlightPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return HighlightPatchSchema;
+	}
+});
+Object.defineProperty(exports, "ImageResourceKeysSchema", {
+	enumerable: true,
+	get: function() {
+		return ImageResourceKeysSchema;
+	}
+});
+Object.defineProperty(exports, "InkDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return InkDTOSchema;
+	}
+});
+Object.defineProperty(exports, "InkDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return InkDraftSchema;
+	}
+});
+Object.defineProperty(exports, "InkIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return InkIntentSchema;
+	}
+});
+Object.defineProperty(exports, "InkListSchema", {
+	enumerable: true,
+	get: function() {
+		return InkListSchema;
+	}
+});
+Object.defineProperty(exports, "InkPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return InkPatchSchema;
+	}
+});
+Object.defineProperty(exports, "IsoDateTimeSchema", {
+	enumerable: true,
+	get: function() {
+		return IsoDateTimeSchema;
+	}
+});
+Object.defineProperty(exports, "KIND_BY_SUBTYPE", {
+	enumerable: true,
+	get: function() {
+		return KIND_BY_SUBTYPE;
+	}
+});
+Object.defineProperty(exports, "LineCaptionPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return LineCaptionPatchSchema;
+	}
+});
+Object.defineProperty(exports, "LineDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return LineDTOSchema;
+	}
+});
+Object.defineProperty(exports, "LineDimensionCaptionSchema", {
+	enumerable: true,
+	get: function() {
+		return LineDimensionCaptionSchema;
+	}
+});
+Object.defineProperty(exports, "LineDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return LineDraftSchema;
+	}
+});
+Object.defineProperty(exports, "LineEndingSchema", {
+	enumerable: true,
+	get: function() {
+		return LineEndingSchema;
+	}
+});
+Object.defineProperty(exports, "LineEndingsSchema", {
+	enumerable: true,
+	get: function() {
+		return LineEndingsSchema;
+	}
+});
+Object.defineProperty(exports, "LineIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return LineIntentSchema;
+	}
+});
+Object.defineProperty(exports, "LineLeaderSchema", {
+	enumerable: true,
+	get: function() {
+		return LineLeaderSchema;
+	}
+});
+Object.defineProperty(exports, "LinePatchSchema", {
+	enumerable: true,
+	get: function() {
+		return LinePatchSchema;
+	}
+});
+Object.defineProperty(exports, "LinePointsSchema", {
+	enumerable: true,
+	get: function() {
+		return LinePointsSchema;
+	}
+});
+Object.defineProperty(exports, "LinkDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return LinkDTOSchema;
+	}
+});
+Object.defineProperty(exports, "LinkDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return LinkDraftSchema;
+	}
+});
+Object.defineProperty(exports, "LinkPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return LinkPatchSchema;
+	}
+});
+Object.defineProperty(exports, "NoteIconSchema", {
+	enumerable: true,
+	get: function() {
+		return NoteIconSchema;
+	}
+});
+Object.defineProperty(exports, "PageBoxSchema", {
+	enumerable: true,
+	get: function() {
+		return PageBoxSchema;
+	}
+});
+Object.defineProperty(exports, "PageMeasurementViewportListSchema", {
+	enumerable: true,
+	get: function() {
+		return PageMeasurementViewportListSchema;
+	}
+});
+Object.defineProperty(exports, "PageMeasurementViewportSchema", {
+	enumerable: true,
+	get: function() {
+		return PageMeasurementViewportSchema;
+	}
+});
+Object.defineProperty(exports, "PagePointSchema", {
+	enumerable: true,
+	get: function() {
+		return PagePointSchema;
+	}
+});
+Object.defineProperty(exports, "PageQuadSchema", {
+	enumerable: true,
+	get: function() {
+		return PageQuadSchema;
+	}
+});
+Object.defineProperty(exports, "PageRefSchema", {
+	enumerable: true,
+	get: function() {
+		return PageRefSchema;
+	}
+});
+Object.defineProperty(exports, "PageScaleInputSchema", {
+	enumerable: true,
+	get: function() {
+		return PageScaleInputSchema;
+	}
+});
+Object.defineProperty(exports, "PdfActionNodeSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfActionNodeSchema;
+	}
+});
+Object.defineProperty(exports, "PdfActionTargetRefSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfActionTargetRefSchema;
+	}
+});
+Object.defineProperty(exports, "PdfActionTreeSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfActionTreeSchema;
+	}
+});
+Object.defineProperty(exports, "PdfActionTypeSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfActionTypeSchema;
+	}
+});
+Object.defineProperty(exports, "PdfActionWireComponents", {
+	enumerable: true,
+	get: function() {
+		return PdfActionWireComponents;
+	}
+});
+Object.defineProperty(exports, "PdfActionWriteSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfActionWriteSchema;
+	}
+});
+Object.defineProperty(exports, "PdfAnnotationActionsSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfAnnotationActionsSchema;
+	}
+});
+Object.defineProperty(exports, "PdfDestinationSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfDestinationSchema;
+	}
+});
+Object.defineProperty(exports, "PdfFieldActionsSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfFieldActionsSchema;
+	}
+});
+Object.defineProperty(exports, "PdfForeignMeasureSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfForeignMeasureSchema;
+	}
+});
+Object.defineProperty(exports, "PdfLinkTargetSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfLinkTargetSchema;
+	}
+});
+Object.defineProperty(exports, "PdfLinkTargetWritableSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfLinkTargetWritableSchema;
+	}
+});
+Object.defineProperty(exports, "PdfMeasureSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfMeasureSchema;
+	}
+});
+Object.defineProperty(exports, "PdfMeasureWriteSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfMeasureWriteSchema;
+	}
+});
+Object.defineProperty(exports, "PdfMeasurementSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfMeasurementSchema;
+	}
+});
+Object.defineProperty(exports, "PdfNumberFormatSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfNumberFormatSchema;
+	}
+});
+Object.defineProperty(exports, "PdfPageActionsSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfPageActionsSchema;
+	}
+});
+Object.defineProperty(exports, "PdfPointSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfPointSchema;
+	}
+});
+Object.defineProperty(exports, "PdfQuadSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfQuadSchema;
+	}
+});
+Object.defineProperty(exports, "PdfRectSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfRectSchema;
+	}
+});
+Object.defineProperty(exports, "PdfRotationSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfRotationSchema;
+	}
+});
+Object.defineProperty(exports, "PdfSizeSchema", {
+	enumerable: true,
+	get: function() {
+		return PdfSizeSchema;
+	}
+});
+Object.defineProperty(exports, "PointSchema", {
+	enumerable: true,
+	get: function() {
+		return PointSchema;
+	}
+});
+Object.defineProperty(exports, "PolygonDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return PolygonDTOSchema;
+	}
+});
+Object.defineProperty(exports, "PolygonDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return PolygonDraftSchema;
+	}
+});
+Object.defineProperty(exports, "PolygonIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return PolygonIntentSchema;
+	}
+});
+Object.defineProperty(exports, "PolygonPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return PolygonPatchSchema;
+	}
+});
+Object.defineProperty(exports, "PolylineDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return PolylineDTOSchema;
+	}
+});
+Object.defineProperty(exports, "PolylineDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return PolylineDraftSchema;
+	}
+});
+Object.defineProperty(exports, "PolylineIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return PolylineIntentSchema;
+	}
+});
+Object.defineProperty(exports, "PolylinePatchSchema", {
+	enumerable: true,
+	get: function() {
+		return PolylinePatchSchema;
+	}
+});
+Object.defineProperty(exports, "PopupDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return PopupDTOSchema;
+	}
+});
+Object.defineProperty(exports, "PopupDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return PopupDraftSchema;
+	}
+});
+Object.defineProperty(exports, "PopupPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return PopupPatchSchema;
+	}
+});
+Object.defineProperty(exports, "RectSchema", {
+	enumerable: true,
+	get: function() {
+		return RectSchema;
+	}
+});
+Object.defineProperty(exports, "ResourceKeySchema", {
+	enumerable: true,
+	get: function() {
+		return ResourceKeySchema;
+	}
+});
+Object.defineProperty(exports, "ShapeCaptionPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return ShapeCaptionPatchSchema;
+	}
+});
+Object.defineProperty(exports, "ShapeDimensionCaptionSchema", {
+	enumerable: true,
+	get: function() {
+		return ShapeDimensionCaptionSchema;
+	}
+});
+Object.defineProperty(exports, "SourceResourceKeysSchema", {
+	enumerable: true,
+	get: function() {
+		return SourceResourceKeysSchema;
+	}
+});
+Object.defineProperty(exports, "SquareDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return SquareDTOSchema;
+	}
+});
+Object.defineProperty(exports, "SquareDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return SquareDraftSchema;
+	}
+});
+Object.defineProperty(exports, "SquarePatchSchema", {
+	enumerable: true,
+	get: function() {
+		return SquarePatchSchema;
+	}
+});
+Object.defineProperty(exports, "SquigglyDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return SquigglyDTOSchema;
+	}
+});
+Object.defineProperty(exports, "SquigglyDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return SquigglyDraftSchema;
+	}
+});
+Object.defineProperty(exports, "SquigglyPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return SquigglyPatchSchema;
+	}
+});
+Object.defineProperty(exports, "StampDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return StampDTOSchema;
+	}
+});
+Object.defineProperty(exports, "StampDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return StampDraftSchema;
+	}
+});
+Object.defineProperty(exports, "StampFitSchema", {
+	enumerable: true,
+	get: function() {
+		return StampFitSchema;
+	}
+});
+Object.defineProperty(exports, "StampPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return StampPatchSchema;
+	}
+});
+Object.defineProperty(exports, "StandardFontSchema", {
+	enumerable: true,
+	get: function() {
+		return StandardFontSchema;
+	}
+});
+Object.defineProperty(exports, "StrikeoutDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return StrikeoutDTOSchema;
+	}
+});
+Object.defineProperty(exports, "StrikeoutDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return StrikeoutDraftSchema;
+	}
+});
+Object.defineProperty(exports, "StrikeoutIntentSchema", {
+	enumerable: true,
+	get: function() {
+		return StrikeoutIntentSchema;
+	}
+});
+Object.defineProperty(exports, "StrikeoutPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return StrikeoutPatchSchema;
+	}
+});
+Object.defineProperty(exports, "TextAlignmentSchema", {
+	enumerable: true,
+	get: function() {
+		return TextAlignmentSchema;
+	}
+});
+Object.defineProperty(exports, "TextDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return TextDTOSchema;
+	}
+});
+Object.defineProperty(exports, "TextDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return TextDraftSchema;
+	}
+});
+Object.defineProperty(exports, "TextPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return TextPatchSchema;
+	}
+});
+Object.defineProperty(exports, "ToggleFieldWidgetSchema", {
+	enumerable: true,
+	get: function() {
+		return ToggleFieldWidgetSchema;
+	}
+});
+Object.defineProperty(exports, "UnderlineDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return UnderlineDTOSchema;
+	}
+});
+Object.defineProperty(exports, "UnderlineDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return UnderlineDraftSchema;
+	}
+});
+Object.defineProperty(exports, "UnderlinePatchSchema", {
+	enumerable: true,
+	get: function() {
+		return UnderlinePatchSchema;
+	}
+});
+Object.defineProperty(exports, "UnsupportedDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return UnsupportedDTOSchema;
+	}
+});
+Object.defineProperty(exports, "UnsupportedDraftSchema", {
+	enumerable: true,
+	get: function() {
+		return UnsupportedDraftSchema;
+	}
+});
+Object.defineProperty(exports, "UnsupportedPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return UnsupportedPatchSchema;
+	}
+});
+Object.defineProperty(exports, "VerticalAlignmentSchema", {
+	enumerable: true,
+	get: function() {
+		return VerticalAlignmentSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetActionsPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetActionsPatchSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetAppearanceSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetAppearanceSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetBorderStyleSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetBorderStyleSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetCheckStyleSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetCheckStyleSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetDTOSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetDTOSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetPatchSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetPatchSchema;
+	}
+});
+Object.defineProperty(exports, "WidgetPlacementSchema", {
+	enumerable: true,
+	get: function() {
+		return WidgetPlacementSchema;
+	}
+});
+Object.defineProperty(exports, "WireAttachmentFileSchema", {
+	enumerable: true,
+	get: function() {
+		return WireAttachmentFileSchema;
+	}
+});
+Object.defineProperty(exports, "annotationPatchSchemaOf", {
+	enumerable: true,
+	get: function() {
+		return annotationPatchSchemaOf;
+	}
+});
+Object.defineProperty(exports, "declarationOf", {
+	enumerable: true,
+	get: function() {
+		return declarationOf;
+	}
+});
+Object.defineProperty(exports, "fileAnnotationPatchSchemaOf", {
+	enumerable: true,
+	get: function() {
+		return fileAnnotationPatchSchemaOf;
+	}
+});
+
+//# sourceMappingURL=schema-C-gU4vj7.cjs.map