ochre-sdk 0.22.22 → 0.22.23

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import * as z from "zod";
+import * as v from "valibot";
 import { parseISO, set } from "date-fns";
 import { UTCDate } from "@date-fns/utc";
 import { deepEqual } from "fast-equals";
@@ -48,7 +48,7 @@ function parseEmail(string) {
 		const index = string.indexOf(cleanString);
 		const before = string.slice(0, index);
 		const after = string.slice(index + cleanString.length);
-		if (emailSchema.safeParse(cleanString).success) {
+		if (v.safeParse(emailSchema, cleanString).success) {
 			returnSplitString.push(`${before}<ExternalLink href="mailto:${cleanString}">${cleanString}</ExternalLink>${after}`);
 			continue;
 		}
@@ -66,12 +66,12 @@ function parseEmail(string) {
 */
 function parseRenderOptions(contentString, renderString) {
 	let returnString = contentString;
-	const result = renderOptionsSchema.safeParse(renderString);
+	const result = v.safeParse(renderOptionsSchema, renderString);
 	if (!result.success) {
 		console.warn(`Invalid render options string provided: “${renderString}”`);
 		return contentString;
 	}
-	for (const option of result.data) switch (option) {
+	for (const option of result.output) switch (option) {
 		case "bold":
 			returnString = `**${returnString}**`;
 			break;
@@ -94,12 +94,12 @@ function parseRenderOptions(contentString, renderString) {
 */
 function parseWhitespace(contentString, whitespace) {
 	let returnString = contentString;
-	const result = whitespaceSchema.safeParse(whitespace);
+	const result = v.safeParse(whitespaceSchema, whitespace);
 	if (!result.success) {
 		console.warn(`Invalid whitespace string provided: “${whitespace}”`);
 		return contentString;
 	}
-	for (const option of result.data) switch (option) {
+	for (const option of result.output) switch (option) {
 		case "newline":
 			if (returnString.trim() === "***") returnString = `${returnString}\n`;
 			else returnString = `<br />\n${returnString}`;
@@ -447,7 +447,7 @@ const PSEUDO_UUID_REGEX = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i;
 * @internal
 */
 function getItemCategory(keys) {
-	const categoryFound = keys.find((key) => categorySchema.safeParse(key).success);
+	const categoryFound = keys.find((key) => v.safeParse(categorySchema, key).success);
 	if (!categoryFound) {
 		const unknownKey = keys.find((key) => ![
 			"uuid",
@@ -459,7 +459,7 @@ function getItemCategory(keys) {
 		].includes(key));
 		throw new Error(`Invalid OCHRE data; found unexpected "${unknownKey}" key`);
 	}
-	return categorySchema.parse(categoryFound);
+	return v.parse(categorySchema, categoryFound);
 }
 /**
 * Get the categories of items from the OCHRE API response
@@ -468,9 +468,9 @@ function getItemCategory(keys) {
 * @internal
 */
 function getItemCategories(keys) {
-	const categories = keys.map((key) => categorySchema.safeParse(key));
-	if (categories.some((result) => !result.success)) throw new Error(`Invalid OCHRE data; found unexpected keys: ${categories.filter((result) => !result.success).map((result) => result.error.message).join(", ")}`);
-	return categories.filter((result) => result.success).map((result) => result.data);
+	const categories = keys.map((key) => v.safeParse(categorySchema, key));
+	if (categories.some((result) => !result.success)) throw new Error(`Invalid OCHRE data; found unexpected keys: ${categories.filter((result) => !result.success).flatMap((result) => result.issues.map((issue) => issue.message)).join(", ")}`);
+	return categories.filter((result) => result.success).map((result) => result.output);
 }
 /**
 * Validates a pseudo-UUID string
@@ -601,54 +601,58 @@ function flattenItemProperties(item) {
 }
 //#endregion
 //#region src/schemas.ts
+const positiveNumber = (message) => v.pipe(v.number(), v.minValue(1, message));
+const defaultString = (value) => v.optional(v.string(), value);
+const defaultBoolean = (value) => v.optional(v.boolean(), value);
+const sortDirectionSchema = v.optional(v.picklist(["asc", "desc"]), "asc");
 /**
 * Schema for validating UUIDs
 * @internal
 */
-const uuidSchema = z.string().refine(isPseudoUuid, { error: "Invalid pseudo-UUID" });
-const fakeStringSchema = z.union([
-	z.string(),
-	z.number(),
-	z.boolean()
+const uuidSchema = v.pipe(v.string(), v.check(isPseudoUuid, "Invalid pseudo-UUID"));
+const fakeStringSchema = v.union([
+	v.string(),
+	v.number(),
+	v.boolean()
 ]);
-const richTextStringContentSchema = z.union([fakeStringSchema, z.object({
-	content: fakeStringSchema.optional(),
-	rend: z.string().optional(),
-	whitespace: z.string().optional()
+const richTextStringContentSchema = v.union([fakeStringSchema, v.object({
+	content: v.optional(fakeStringSchema),
+	rend: v.optional(v.string()),
+	whitespace: v.optional(v.string())
 })]);
 /**
 * Schema for validating rich text string content
 * @internal
 */
-const richTextStringSchema = z.object({
-	string: z.union([
+const richTextStringSchema = v.object({
+	string: v.union([
 		fakeStringSchema,
 		richTextStringContentSchema,
-		z.array(richTextStringContentSchema)
+		v.array(richTextStringContentSchema)
 	]),
-	lang: z.string().optional()
+	lang: v.optional(v.string())
 });
-z.object({
-	label: z.object({ content: z.union([richTextStringSchema, z.array(richTextStringSchema)]) }),
-	abbreviation: z.object({ content: z.union([richTextStringSchema, z.array(richTextStringSchema)]).optional() }),
-	code: z.string().optional()
+v.object({
+	label: v.object({ content: v.union([richTextStringSchema, v.array(richTextStringSchema)]) }),
+	abbreviation: v.object({ content: v.optional(v.union([richTextStringSchema, v.array(richTextStringSchema)])) }),
+	code: v.optional(v.string())
 });
-z.string().optional();
-z.object({
-	filter: z.string().optional().default(""),
-	start: z.number().positive({ error: "Start must be positive" }).optional().default(1),
-	limit: z.number().positive({ error: "Limit must be positive" }).optional().default(40)
-}).optional().default({
+v.optional(v.string());
+v.optional(v.object({
+	filter: defaultString(""),
+	start: v.optional(positiveNumber("Start must be positive"), 1),
+	limit: v.optional(positiveNumber("Limit must be positive"), 40)
+}), {
 	filter: "",
 	start: 1,
 	limit: 40
 });
-const apiVersionSuffixSchema = z.enum(["-v1", "-v2"]).transform((suffix) => Number.parseInt(suffix.replace("-v", ""), 10));
+const apiVersionSuffixSchema = v.pipe(v.picklist(["-v1", "-v2"]), v.transform((suffix) => Number.parseInt(suffix.replace("-v", ""), 10)));
 /**
 * Valid component types for web elements
 * @internal
 */
-const componentSchema = z.enum([
+const componentSchema = v.picklist([
 	"3d-viewer",
 	"advanced-search",
 	"annotated-document",
@@ -670,12 +674,12 @@ const componentSchema = z.enum([
 	"text",
 	"timeline",
 	"video"
-], { error: "Invalid component" });
+], "Invalid component");
 /**
 * Schema for validating data categories
 * @internal
 */
-const categorySchema = z.enum([
+const categorySchema = v.picklist([
 	"resource",
 	"spatialUnit",
 	"concept",
@@ -692,7 +696,7 @@ const categorySchema = z.enum([
 * Schema for validating property value content types
 * @internal
 */
-const propertyValueContentTypeSchema = z.enum([
+const propertyValueContentTypeSchema = v.picklist([
 	"string",
 	"integer",
 	"decimal",
@@ -707,7 +711,7 @@ const propertyValueContentTypeSchema = z.enum([
 * Schema for validating and parsing render options
 * @internal
 */
-const renderOptionsSchema = z.string().transform((str) => str.split(" ")).pipe(z.array(z.enum([
+const renderOptionsSchema = v.pipe(v.string(), v.transform((str) => str.split(" ")), v.array(v.picklist([
 	"bold",
 	"italic",
 	"underline"
@@ -716,7 +720,7 @@ const renderOptionsSchema = z.string().transform((str) => str.split(" ")).pipe(z
 * Schema for validating and parsing whitespace options
 * @internal
 */
-const whitespaceSchema = z.string().transform((str) => str.split(" ")).pipe(z.array(z.enum([
+const whitespaceSchema = v.pipe(v.string(), v.transform((str) => str.split(" ")), v.array(v.picklist([
 	"newline",
 	"trailing",
 	"leading"
@@ -725,42 +729,41 @@ const whitespaceSchema = z.string().transform((str) => str.split(" ")).pipe(z.ar
 * Schema for validating email addresses
 * @internal
 */
-const emailSchema = z.email({ error: "Invalid email" });
+const emailSchema = v.pipe(v.string(), v.email("Invalid email"));
 /**
 * Schema for parsing and validating a string in the format "[[number, number], [number, number]]"
 * into an array with exactly two bounds
 * @internal
 */
-const boundsSchema = z.string().transform((str, ctx) => {
-	const trimmed = str.trim();
+const boundsSchema = v.pipe(v.string(), v.rawTransform(({ dataset, addIssue, NEVER }) => {
+	const trimmed = dataset.value.trim();
 	if (!trimmed.startsWith("[[") || !trimmed.endsWith("]]")) {
-		ctx.addIssue({
-			code: "invalid_format",
-			format: "string",
-			message: "String must start with '[[' and end with ']]'"
-		});
-		return z.NEVER;
+		addIssue({ message: "String must start with '[[' and end with ']]'" });
+		return NEVER;
 	}
 	try {
 		return JSON.parse(trimmed);
 	} catch {
-		ctx.addIssue({
-			code: "invalid_format",
-			format: "string",
-			message: "Invalid JSON format"
-		});
-		return z.NEVER;
+		addIssue({ message: "Invalid JSON format" });
+		return NEVER;
 	}
-}).pipe(z.tuple([z.tuple([z.number(), z.number()]), z.tuple([z.number(), z.number()])], { message: "Must contain exactly 2 coordinate pairs" }));
+}), v.tuple([v.tuple([v.number(), v.number()]), v.tuple([v.number(), v.number()])], "Must contain exactly 2 coordinate pairs"));
+const dateDataTypeSchema = v.picklist(["date", "dateTime"]);
+const standardQueryFields = {
+	matchMode: v.picklist(["includes", "exact"]),
+	isCaseSensitive: v.boolean(),
+	language: defaultString("eng"),
+	isNegated: defaultBoolean(false)
+};
 /**
 * Shared schema for Set queries
 * @internal
 */
-const setQueryLeafSchema = z.union([
-	z.object({
-		target: z.literal("property"),
-		propertyVariable: uuidSchema.optional(),
-		dataType: z.enum([
+const setQueryLeafSchema = v.union([
+	v.pipe(v.strictObject({
+		target: v.literal("property"),
+		propertyVariable: v.optional(uuidSchema),
+		dataType: v.picklist([
 			"string",
 			"integer",
 			"decimal",
@@ -768,73 +771,50 @@ const setQueryLeafSchema = z.union([
 			"time",
 			"IDREF"
 		]),
-		value: z.string().optional(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict().superRefine((value, ctx) => {
-		if (value.propertyVariable == null && value.value == null) ctx.addIssue({
-			code: "custom",
-			message: "Property queries must include at least one propertyVariable or value"
-		});
-	}),
-	z.object({
-		target: z.literal("property"),
+		value: v.optional(v.string()),
+		...standardQueryFields
+	}), v.check((value) => value.propertyVariable != null || value.value != null, "Property queries must include at least one propertyVariable or value")),
+	v.strictObject({
+		target: v.literal("property"),
 		propertyVariable: uuidSchema,
-		dataType: z.enum(["date", "dateTime"]),
-		value: z.string(),
-		from: z.never().optional(),
-		to: z.never().optional(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
-	z.object({
-		target: z.literal("property"),
+		dataType: dateDataTypeSchema,
+		value: v.string(),
+		from: v.optional(v.never()),
+		to: v.optional(v.never()),
+		...standardQueryFields
+	}),
+	v.strictObject({
+		target: v.literal("property"),
 		propertyVariable: uuidSchema,
-		dataType: z.enum(["date", "dateTime"]),
-		value: z.never().optional(),
-		from: z.string(),
-		to: z.string().optional(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
-	z.object({
-		target: z.literal("property"),
+		dataType: dateDataTypeSchema,
+		value: v.optional(v.never()),
+		from: v.string(),
+		to: v.optional(v.string()),
+		...standardQueryFields
+	}),
+	v.strictObject({
+		target: v.literal("property"),
 		propertyVariable: uuidSchema,
-		dataType: z.enum(["date", "dateTime"]),
-		value: z.never().optional(),
-		from: z.string().optional(),
-		to: z.string(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
-	z.object({
-		target: z.literal("property"),
-		propertyVariable: uuidSchema.optional(),
-		dataType: z.literal("all"),
-		value: z.string(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
-	z.object({
-		target: z.literal("string"),
-		value: z.string(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
-	z.object({
-		target: z.enum([
+		dataType: dateDataTypeSchema,
+		value: v.optional(v.never()),
+		from: v.optional(v.string()),
+		to: v.string(),
+		...standardQueryFields
+	}),
+	v.strictObject({
+		target: v.literal("property"),
+		propertyVariable: v.optional(uuidSchema),
+		dataType: v.literal("all"),
+		value: v.string(),
+		...standardQueryFields
+	}),
+	v.strictObject({
+		target: v.literal("string"),
+		value: v.string(),
+		...standardQueryFields
+	}),
+	v.strictObject({
+		target: v.picklist([
 			"title",
 			"description",
 			"image",
@@ -842,30 +822,27 @@ const setQueryLeafSchema = z.union([
 			"bibliography",
 			"notes"
 		]),
-		value: z.string(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict()
+		value: v.string(),
+		...standardQueryFields
+	})
 ]);
-const setQuerySchema = z.lazy(() => z.union([
+const setQuerySchema = v.lazy(() => v.union([
 	setQueryLeafSchema,
-	z.object({ and: z.array(setQuerySchema).min(1, "AND groups must contain at least one query") }).strict(),
-	z.object({ or: z.array(setQuerySchema).min(1, "OR groups must contain at least one query") }).strict()
+	v.strictObject({ and: v.pipe(v.array(setQuerySchema), v.minLength(1, "AND groups must contain at least one query")) }),
+	v.strictObject({ or: v.pipe(v.array(setQuerySchema), v.minLength(1, "OR groups must contain at least one query")) })
 ]));
-const setQueriesSchema = setQuerySchema.nullable().default(null);
-const setItemsSortSchema = z.discriminatedUnion("target", [
-	z.object({ target: z.literal("none") }).strict(),
-	z.object({
-		target: z.literal("title"),
-		direction: z.enum(["asc", "desc"]).default("asc"),
-		language: z.string().default("eng")
-	}).strict(),
-	z.object({
-		target: z.literal("propertyValue"),
+const setQueriesSchema = v.optional(v.nullable(setQuerySchema), null);
+const setItemsSortSchema = v.optional(v.variant("target", [
+	v.strictObject({ target: v.literal("none") }),
+	v.strictObject({
+		target: v.literal("title"),
+		direction: sortDirectionSchema,
+		language: defaultString("eng")
+	}),
+	v.strictObject({
+		target: v.literal("propertyValue"),
 		propertyVariableUuid: uuidSchema,
-		dataType: z.enum([
+		dataType: v.picklist([
 			"string",
 			"integer",
 			"decimal",
@@ -875,34 +852,34 @@ const setItemsSortSchema = z.discriminatedUnion("target", [
 			"time",
 			"IDREF"
 		]),
-		direction: z.enum(["asc", "desc"]).default("asc"),
-		language: z.string().default("eng")
-	}).strict()
-]).default({ target: "none" });
+		direction: sortDirectionSchema,
+		language: defaultString("eng")
+	})
+]), { target: "none" });
 /**
 * Schema for validating the parameters for the Set property values fetching function
 * @internal
 */
-const setPropertyValuesParamsSchema = z.object({
-	setScopeUuids: z.array(uuidSchema).min(1, "At least one set scope UUID is required"),
-	belongsToCollectionScopeUuids: z.array(uuidSchema).default([]),
+const setPropertyValuesParamsSchema = v.object({
+	setScopeUuids: v.pipe(v.array(uuidSchema), v.minLength(1, "At least one set scope UUID is required")),
+	belongsToCollectionScopeUuids: v.optional(v.array(uuidSchema), []),
 	queries: setQueriesSchema,
-	attributes: z.object({
-		bibliographies: z.boolean().default(false),
-		periods: z.boolean().default(false)
-	}).default({
+	attributes: v.optional(v.object({
+		bibliographies: defaultBoolean(false),
+		periods: defaultBoolean(false)
+	}), {
 		bibliographies: false,
 		periods: false
 	}),
-	isLimitedToLeafPropertyValues: z.boolean().default(false)
+	isLimitedToLeafPropertyValues: defaultBoolean(false)
 });
-const setItemsParamsSchema = z.object({
-	setScopeUuids: z.array(uuidSchema).min(1, "At least one set scope UUID is required"),
-	belongsToCollectionScopeUuids: z.array(uuidSchema).default([]),
+const setItemsParamsSchema = v.object({
+	setScopeUuids: v.pipe(v.array(uuidSchema), v.minLength(1, "At least one set scope UUID is required")),
+	belongsToCollectionScopeUuids: v.optional(v.array(uuidSchema), []),
 	queries: setQueriesSchema,
 	sort: setItemsSortSchema,
-	page: z.number().min(1, "Page must be positive").default(1),
-	pageSize: z.number().min(1, "Page size must be positive").default(48)
+	page: v.optional(positiveNumber("Page must be positive"), 1),
+	pageSize: v.optional(positiveNumber("Page size must be positive"), 48)
 });
 //#endregion
 //#region src/utils/parse/index.ts
@@ -1352,9 +1329,9 @@ function parseProperty(property, language = "eng") {
 		} else {
 			let parsedType = "string";
 			if (value.dataType != null) {
-				const { data, error } = propertyValueContentTypeSchema.safeParse(value.dataType);
-				if (error) throw new Error(`Invalid property value content type: "${value.dataType}"`);
-				parsedType = data;
+				const result = v.safeParse(propertyValueContentTypeSchema, value.dataType);
+				if (!result.success) throw new Error(`Invalid property value content type: "${value.dataType}"`);
+				parsedType = result.output;
 			}
 			switch (parsedType) {
 				case "integer":
@@ -1984,11 +1961,11 @@ function parseConcepts(concepts) {
 /**
 * Schema for validating gallery parameters
 */
-const galleryParamsSchema = z.object({
+const galleryParamsSchema = v.object({
 	uuid: uuidSchema,
-	filter: z.string().optional(),
-	page: z.number().positive({ error: "Page must be positive" }),
-	pageSize: z.number().positive({ error: "Page size must be positive" })
+	filter: v.optional(v.string()),
+	page: v.pipe(v.number(), v.minValue(1, "Page must be positive")),
+	pageSize: v.pipe(v.number(), v.minValue(1, "Page size must be positive"))
 });
 /**
 * Fetches and parses a gallery from the OCHRE API
@@ -2006,7 +1983,7 @@ const galleryParamsSchema = z.object({
 async function fetchGallery(params, options) {
 	try {
 		const version = options?.version ?? 2;
-		const { uuid, filter, page, pageSize } = galleryParamsSchema.parse(params);
+		const { uuid, filter, page, pageSize } = v.parse(galleryParamsSchema, params);
 		const response = await (options?.fetch ?? fetch)(`${version === 2 ? "https://ochre.lib.uchicago.edu/ochre/v2/ochre.php" : "https://ochre.lib.uchicago.edu/ochre"}?xquery=${encodeURIComponent(`<ochre>{
         for $q in ${version === 2 ? "doc()" : "input()"}/ochre[@uuid='${uuid}']
         let $filtered := $q//items/resource[contains(lower-case(identification/label), lower-case('${filter}'))]
@@ -2142,7 +2119,7 @@ async function fetchItemLinks(uuid, category, itemCategories, options) {
 async function fetchByUuid(uuid, options) {
 	try {
 		const version = options?.version ?? 2;
-		const parsedUuid = uuidSchema.parse(uuid);
+		const parsedUuid = v.parse(uuidSchema, uuid);
 		const response = await (options?.fetch ?? fetch)(version === 2 ? `https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?uuid=${parsedUuid}&format=json&lang="*"` : `https://ochre.lib.uchicago.edu/ochre?uuid=${parsedUuid}&format=json&lang="*"`);
 		if (!response.ok) throw new Error("Failed to fetch OCHRE data");
 		const dataRaw = await response.json();
@@ -3244,7 +3221,7 @@ ${itemsClause}
 async function fetchSetItems(params, itemCategories, options) {
 	try {
 		if (options?.version != null && options.version !== 2) throw new Error("Set item queries only support API version 2");
-		const { setScopeUuids, belongsToCollectionScopeUuids, queries, sort, page, pageSize } = setItemsParamsSchema.parse(params);
+		const { setScopeUuids, belongsToCollectionScopeUuids, queries, sort, page, pageSize } = v.parse(setItemsParamsSchema, params);
 		const xquery = buildXQuery$1({
 			setScopeUuids,
 			belongsToCollectionScopeUuids,
@@ -3360,11 +3337,11 @@ function sortAttributeValues(values) {
 		return a.content.localeCompare(b.content);
 	});
 }
-const countSchema = z.union([z.number(), z.string()]).optional().transform((val) => {
-	if (val == null || val === "") return 1;
+const countSchema = v.pipe(v.optional(v.union([v.number(), v.string()]), 1), v.transform((val) => {
+	if (val === "") return 1;
 	const count = Number(val);
 	return Number.isFinite(count) ? count : 1;
-});
+}));
 function getPropertyVariableUuidsFromQueries(queries) {
 	const propertyVariableUuids = /* @__PURE__ */ new Set();
 	if (queries == null) return [];
@@ -3399,20 +3376,20 @@ function getItemFilterQueriesFromPropertyValueQueries(queries) {
 /**
 * Schema for a single property value query item in the OCHRE API response
 */
-const propertyValueQueryItemSchema = z.object({
-	uuid: z.string(),
-	scope: z.enum(["global", "variable"]).default("global"),
-	variableUuid: z.string().optional(),
+const propertyValueQueryItemSchema = v.pipe(v.object({
+	uuid: v.string(),
+	scope: v.optional(v.picklist(["global", "variable"]), "global"),
+	variableUuid: v.optional(v.string()),
 	count: countSchema,
-	globalCount: countSchema.nullish(),
-	dataType: z.string(),
-	rawValue: fakeStringSchema.optional(),
-	content: z.union([
+	globalCount: v.nullish(countSchema),
+	dataType: v.string(),
+	rawValue: v.optional(fakeStringSchema),
+	content: v.optional(v.union([
 		fakeStringSchema,
 		richTextStringSchema,
-		z.array(richTextStringSchema)
-	]).optional()
-}).transform((val) => {
+		v.array(richTextStringSchema)
+	]))
+}), v.transform((val) => {
 	const returnValue = {
 		scope: val.scope,
 		variableUuid: val.variableUuid != null && val.variableUuid !== "" ? val.variableUuid : null,
@@ -3446,23 +3423,23 @@ const propertyValueQueryItemSchema = z.object({
 			break;
 	}
 	return returnValue;
-});
-const attributeValueQueryItemSchema = z.object({
-	attributeType: z.enum(["bibliographies", "periods"]),
+}));
+const attributeValueQueryItemSchema = v.pipe(v.object({
+	attributeType: v.picklist(["bibliographies", "periods"]),
 	count: countSchema,
-	content: z.string().optional()
-}).transform((val) => ({
+	content: v.optional(v.string())
+}), v.transform((val) => ({
 	attributeType: val.attributeType,
 	count: val.count,
 	content: val.content != null && val.content !== "" ? val.content : null
-}));
+})));
 /**
 * Schema for the property values OCHRE API response
 */
-const responseSchema = z.object({ result: z.union([z.object({ ochre: z.object({
-	propertyValue: z.union([propertyValueQueryItemSchema, z.array(propertyValueQueryItemSchema)]).optional(),
-	attributeValue: z.union([attributeValueQueryItemSchema, z.array(attributeValueQueryItemSchema)]).optional()
-}) }), z.array(z.unknown()).length(0)]) });
+const responseSchema = v.object({ result: v.union([v.object({ ochre: v.object({
+	propertyValue: v.optional(v.union([propertyValueQueryItemSchema, v.array(propertyValueQueryItemSchema)])),
+	attributeValue: v.optional(v.union([attributeValueQueryItemSchema, v.array(attributeValueQueryItemSchema)]))
+}) }), v.pipe(v.array(v.unknown()), v.length(0))]) });
 /**
 * Build an XQuery string to fetch property values from the OCHRE API
 * @param params - The parameters for the fetch
@@ -3701,7 +3678,7 @@ return (${returnedSequences.join(", ")})
 async function fetchSetPropertyValues(params, options) {
 	try {
 		if (options?.version != null && options.version !== 2) throw new Error("Set property value queries only support API version 2");
-		const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = setPropertyValuesParamsSchema.parse(params);
+		const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = v.parse(setPropertyValuesParamsSchema, params);
 		const propertyVariableUuids = getPropertyVariableUuidsFromQueries(queries);
 		if (propertyVariableUuids.length === 0 && !attributes.bibliographies && !attributes.periods) return {
 			propertyValues: [],
@@ -3727,7 +3704,7 @@ async function fetchSetPropertyValues(params, options) {
 		});
 		if (!response.ok) throw new Error(`OCHRE API responded with status: ${response.status}`);
 		const data = await response.json();
-		const parsedResultRaw = responseSchema.parse(data);
+		const parsedResultRaw = v.parse(responseSchema, data);
 		const parsedPropertyValues = [];
 		const parsedAttributeValues = [];
 		if (!Array.isArray(parsedResultRaw.result)) {
@@ -4196,9 +4173,9 @@ function parseResponsiveCssStyles(properties) {
 * @returns Parsed bounds object
 */
 function parseBounds(bounds) {
-	const result = boundsSchema.safeParse(bounds);
-	if (!result.success) throw new Error(`Invalid bounds: ${result.error.message}`);
-	return result.data;
+	const result = v.safeParse(boundsSchema, bounds);
+	if (!result.success) throw new Error(`Invalid bounds: ${result.issues.map((issue) => issue.message).join(", ")}`);
+	return result.output;
 }
 /**
 * Parses all context option arrays from an options object.
@@ -4274,7 +4251,8 @@ function parseStylesheets(styles) {
 */
 function parseWebElementProperties(componentProperty, elementResource) {
 	const unparsedComponentName = componentProperty.values[0].content;
-	const { data: componentName } = componentSchema.safeParse(unparsedComponentName);
+	const componentNameResult = v.safeParse(componentSchema, unparsedComponentName);
+	const componentName = componentNameResult.success ? componentNameResult.output : void 0;
 	let properties = null;
 	const links = elementResource.links ? parseLinks(ensureArray(elementResource.links)) : [];
 	switch (componentName) {
@@ -5529,11 +5507,11 @@ function parseApiVersionSuffix(abbreviation) {
 		abbreviation,
 		version: 2
 	};
-	const result = apiVersionSuffixSchema.safeParse(abbreviation.slice(-3));
+	const result = v.safeParse(apiVersionSuffixSchema, abbreviation.slice(-3));
 	if (!result.success) throw new Error("Invalid API version suffix");
 	return {
-		abbreviation: abbreviation.replace(`-v${result.data}`, ""),
-		version: result.data
+		abbreviation: abbreviation.replace(`-v${result.output}`, ""),
+		version: result.output
 	};
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "0.22.22",
+  "version": "0.22.23",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",
@@ -46,13 +46,13 @@
     "@date-fns/utc": "^2.1.1",
     "date-fns": "^4.1.0",
     "fast-equals": "^6.0.0",
-    "zod": "^4.4.1"
+    "valibot": "^1.3.1"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^8.2.0",
     "@types/node": "^24.12.2",
     "bumpp": "^11.0.1",
-    "eslint": "^10.2.1",
+    "eslint": "^10.3.0",
     "prettier": "^3.8.3",
     "tsdown": "^0.21.10",
     "typescript": "^6.0.3",