ochre-sdk 1.0.79 → 1.1.1

package/dist/parsers/index.mjs

@@ -1,8 +1,12 @@
-import { DEFAULT_LANGUAGES } from "../constants.mjs";
-import { MultilingualString } from "./multilingual.mjs";
+import { CONTEXT_CATEGORY_ALIASES, ITEM_CATEGORY_BY_ALIAS, ITEM_CATEGORY_FACTS, SET_ITEM_CATEGORIES, isHeadingItemCategory, normalizeItemCategory } from "../categories.mjs";
+import { readEntries, readProperty } from "../reflection.mjs";
 import { getXMLSourceIndex } from "../xml/metadata.mjs";
+import { MultilingualString } from "./multilingual.mjs";
+import { readPropertyValueText } from "./property-token.mjs";
 import { parseXMLString, transformPermanentIdentificationUrl } from "./string.mjs";
 import { getParserOptions, multilingualFromText, parseContentLike, parseContentLikeText, parseLicense, parseRequiredContentLike, parseStringLike } from "./helpers.mjs";
+import { parseMetadataLanguages, resolveDefaultLanguage, resolveLanguages } from "./languages.mjs";
+import * as v from "valibot";
 //#region src/parsers/index.ts
 function isXMLContextGroup(context) {
 	return "context" in context;
@@ -10,68 +14,82 @@ function isXMLContextGroup(context) {
 function isXMLContextItem(context) {
 	return "project" in context;
 }
-const SET_ITEM_CATEGORIES = ["tree", ...[
-	"bibliography",
-	"concept",
-	"spatialUnit",
-	"period",
-	"person",
-	"propertyVariable",
-	"propertyValue",
-	"resource",
-	"text",
-	"set"
-]];
-const HEADING_ITEM_CATEGORIES = [
-	"person",
-	"propertyVariable",
-	"propertyValue",
-	"resource",
-	"text",
-	"set"
-];
-const CONTEXT_CATEGORY_MAPPINGS = [
-	{
-		raw: "bibliography",
-		parsed: "bibliography"
+const ITEM_CATEGORIES = {
+	tree: {
+		parseEmbedded: (item, options) => parseTree(item, {
+			...options,
+			containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
+		}),
+		parseSetItem: (item, options) => parseSetTree(item, options),
+		parseLink: (item, options) => parseTreeItemLink(item, options)
+	},
+	bibliography: {
+		parseEmbedded: (item, options) => parseBibliography(item, options),
+		parseSetItem: (item, options) => parseSetBibliography(item, options),
+		parseLink: (item, options) => parseBibliographyItemLink(item, options)
+	},
+	concept: {
+		parseEmbedded: (item, options) => parseConcept(item, options),
+		parseSetItem: (item, options) => parseSetConcept(item, options),
+		parseLink: (item, options) => parseConceptItemLink(item, options)
+	},
+	spatialUnit: {
+		parseEmbedded: (item, options) => parseSpatialUnit(item, options),
+		parseSetItem: (item, options) => parseSetSpatialUnit(item, options),
+		parseLink: (item, options) => parseSpatialUnitItemLink(item, options)
 	},
-	{
-		raw: "concept",
-		parsed: "concept"
+	period: {
+		parseEmbedded: (item, options) => parsePeriod(item, options),
+		parseSetItem: (item, options) => parseSetPeriod(item, options),
+		parseLink: (item, options) => parsePeriodItemLink(item, options)
 	},
-	{
-		raw: "spatialUnit",
-		parsed: "spatialUnit"
+	person: {
+		parseEmbedded: (item, options) => parsePerson(item, options),
+		parseSetItem: (item, options) => {
+			const person = item;
+			return withSetItemProperties(parsePerson(person, options), person.properties, options);
+		},
+		parseLink: (item, options) => parsePersonItemLink(item, options)
 	},
-	{
-		raw: "period",
-		parsed: "period"
+	propertyVariable: {
+		parseEmbedded: (item, options) => parsePropertyVariable(item, options),
+		parseSetItem: (item, options) => parsePropertyVariable(item, options),
+		parseLink: (item, options) => parsePropertyVariableItemLink(item, options)
 	},
-	{
-		raw: "propertyVariable",
-		parsed: "propertyVariable"
+	propertyValue: {
+		parseEmbedded: (item, options) => parsePropertyValue(item, options),
+		parseSetItem: (item, options) => {
+			const propertyValue = item;
+			return withSetItemProperties(parsePropertyValue(propertyValue, options), propertyValue.properties, options);
+		},
+		parseLink: (item, options) => parsePropertyValueItemLink(item, options)
 	},
-	{
-		raw: "variable",
-		parsed: "propertyVariable"
+	resource: {
+		parseEmbedded: (item, options) => parseResource(item, options),
+		parseSetItem: (item, options) => parseSetResource(item, options),
+		parseLink: (item, options) => parseResourceItemLink(item, options)
 	},
-	{
-		raw: "propertyValue",
-		parsed: "propertyValue"
+	text: {
+		parseEmbedded: (item, options) => parseText(item, options),
+		parseSetItem: (item, options) => parseText(item, options),
+		parseLink: (item, options) => parseTextItemLink(item, options)
 	},
-	{
-		raw: "value",
-		parsed: "propertyValue"
+	set: {
+		parseEmbedded: (item, options) => parseSet(item, options),
+		parseSetItem: (item, options) => parseSetSet(item, options),
+		parseLink: (item, options) => parseSetItemLink(item, options)
 	},
-	{
-		raw: "resource",
-		parsed: "resource"
+	dictionaryUnit: {
+		parseEmbedded: null,
+		parseSetItem: null,
+		parseLink: (item, options) => parseDictionaryUnitItemLink(item, options)
 	},
-	{
-		raw: "text",
-		parsed: "text"
+	heading: {
+		parseEmbedded: null,
+		parseSetItem: null,
+		parseLink: null
 	}
-];
+};
 const PROPERTY_DATA_TYPES = [
 	"string",
 	"coordinate",
@@ -128,12 +146,12 @@ function parseContextNode(rawContextItem) {
 	};
 	const headings = rawContextItem.heading ?? [];
 	for (const heading of headings) node.heading.push(parseContextItem(heading));
-	for (const { raw, parsed } of CONTEXT_CATEGORY_MAPPINGS) {
-		const contextValues = rawContextItem[raw] ?? [];
+	for (const { alias, category } of CONTEXT_CATEGORY_ALIASES) {
+		const contextValues = rawContextItem[alias] ?? [];
 		for (const contextValue of contextValues) {
-			const parsedItems = node[parsed] ?? [];
+			const parsedItems = node[category] ?? [];
 			parsedItems.push(parseContextItem(contextValue));
-			node[parsed] = parsedItems;
+			node[category] = parsedItems;
 		}
 	}
 	return node;
@@ -176,7 +194,7 @@ function parseEvent(rawEvent, options) {
 		location: parseEventReference(rawEvent.location, options),
 		other: rawEvent.other == null ? null : {
 			uuid: rawEvent.other.uuid ?? null,
-			category: normalizeCategory(rawEvent.other.category),
+			category: normalizeItemCategory(rawEvent.other.category),
 			label: parseRequiredContentLike(rawEvent.other, options)
 		}
 	};
@@ -202,44 +220,26 @@ function parseBaseItem(category, rawItem, options) {
 		events
 	};
 }
-function normalizeCategory(category) {
-	if (category == null) return null;
-	if (category === "variable") return "propertyVariable";
-	if (category === "value") return "propertyValue";
-	for (const knownCategory of SET_ITEM_CATEGORIES) if (category === knownCategory) return knownCategory;
-	return null;
-}
-function isHeadingItemCategory(category) {
-	return HEADING_ITEM_CATEGORIES.includes(category);
-}
 function pushCategory(categories, category) {
 	if (!categories.includes(category)) categories.push(category);
 }
 function getHierarchyEntryCategory(key) {
-	switch (key) {
-		case "heading":
-		case "tree":
-		case "bibliography":
-		case "concept":
-		case "spatialUnit":
-		case "period":
-		case "person":
-		case "resource":
-		case "text":
-		case "set":
-		case "dictionaryUnit": return key;
-		case "propertyVariable":
-		case "variable": return "propertyVariable";
-		case "propertyValue":
-		case "value": return "propertyValue";
-		default: return null;
-	}
-}
-function isRecord(value) {
-	return typeof value === "object" && value != null;
-}
+	return ITEM_CATEGORY_BY_ALIAS.get(key) ?? null;
+}
+/**
+* A group element wrapping child resources rather than being one itself
+*
+* A schema rather than a hand-written predicate: `v.is` narrows to exactly what
+* it checked, and a wrapper is distinguished from a resource by carrying no
+* `uuid`, which the `undefined` entry states rather than leaving to a
+* `!("uuid" in value)` test whose false branch means nothing in particular.
+*/
+const resourceWrapperSchema = v.looseObject({
+	uuid: v.undefined(),
+	resource: v.array(v.unknown())
+});
 function isResourceWrapper(value) {
-	return isRecord(value) && !("uuid" in value) && Array.isArray(value.resource);
+	return v.is(resourceWrapperSchema, value);
 }
 function sourceOrderSort(left, right) {
 	const leftIndex = getXMLSourceIndex(left.item);
@@ -249,9 +249,8 @@ function sourceOrderSort(left, right) {
 }
 function collectHierarchyEntries(hierarchy, categories) {
 	const entries = [];
-	if (hierarchy == null) return entries;
 	let fallbackIndex = 0;
-	for (const [key, values] of Object.entries(hierarchy)) {
+	for (const [key, values] of readEntries(hierarchy)) {
 		const category = getHierarchyEntryCategory(key);
 		if (category == null || !(categories == null || categories.includes(category))) continue;
 		if (!Array.isArray(values)) continue;
@@ -458,8 +457,7 @@ function parsePropertyDataType(dataType) {
 function parsePropertyValueContent(value, options) {
 	const dataType = parsePropertyDataType(value.dataType);
 	const rawLabel = value.content != null ? parseRequiredContentLike(value, options) : value.payload != null && value.payload !== "" ? multilingualFromText(value.payload, options) : null;
-	const displayText = rawLabel?.getText() ?? value.payload ?? value.slug ?? "";
-	const contentText = value.rawValue ?? value.payload ?? displayText;
+	const contentText = readPropertyValueText(value, () => rawLabel?.getText() ?? null);
 	const common = {
 		hierarchy: {
 			isLeaf: value.inherited == null || !value.inherited,
@@ -563,24 +561,8 @@ function withoutItems(item) {
 	return itemWithoutItems;
 }
 function parseEmbeddedItemEntry(entry, options) {
-	switch (entry.category) {
-		case "tree": return parseTree(entry.item, {
-			...options,
-			containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
-		});
-		case "bibliography": return parseBibliography(entry.item, options);
-		case "concept": return parseConcept(entry.item, options);
-		case "spatialUnit": return parseSpatialUnit(entry.item, options);
-		case "period": return parsePeriod(entry.item, options);
-		case "person": return parsePerson(entry.item, options);
-		case "propertyVariable": return parsePropertyVariable(entry.item, options);
-		case "propertyValue": return parsePropertyValue(entry.item, options);
-		case "resource": return parseResource(entry.item, options);
-		case "text": return parseText(entry.item, options);
-		case "set": return parseSet(entry.item, options);
-		case "dictionaryUnit":
-		case "heading": return null;
-	}
+	const parse = ITEM_CATEGORIES[entry.category].parseEmbedded;
+	return parse == null ? null : parse(entry.item, options);
 }
 function parseItemHierarchy(hierarchy, options, categories) {
 	const items = [];
@@ -594,52 +576,19 @@ function parseItemHierarchy(hierarchy, options, categories) {
 function parseSetItemHierarchy(hierarchy, options, categories) {
 	const items = [];
 	if (hierarchy == null) return items;
-	for (const entry of collectHierarchyEntries(hierarchy, categories)) switch (entry.category) {
-		case "tree":
-			items.push(parseSetTree(entry.item, options));
-			break;
-		case "bibliography":
-			items.push(parseSetBibliography(entry.item, options));
-			break;
-		case "concept":
-			items.push(parseSetConcept(entry.item, options));
-			break;
-		case "spatialUnit":
-			items.push(parseSetSpatialUnit(entry.item, options));
-			break;
-		case "period":
-			items.push(parseSetPeriod(entry.item, options));
-			break;
-		case "person": {
-			const person = entry.item;
-			items.push(withSetItemProperties(parsePerson(person, options), person.properties, options));
-			break;
-		}
-		case "propertyVariable":
-			items.push(parsePropertyVariable(entry.item, options));
-			break;
-		case "propertyValue": {
-			const propertyValue = entry.item;
-			items.push(withSetItemProperties(parsePropertyValue(propertyValue, options), propertyValue.properties, options));
-			break;
-		}
-		case "resource":
-			items.push(parseSetResource(entry.item, options));
-			break;
-		case "text":
-			items.push(parseText(entry.item, options));
-			break;
-		case "set": items.push(parseSetSet(entry.item, options));
+	for (const entry of collectHierarchyEntries(hierarchy, categories)) {
+		const parse = ITEM_CATEGORIES[entry.category].parseSetItem;
+		if (parse != null) items.push(parse(entry.item, options));
 	}
 	return items;
 }
 function normalizeTreeLinkItemsCategory(type) {
-	const category = normalizeCategory(type);
+	const category = normalizeItemCategory(type);
 	if (category === "tree" || category == null) return null;
 	return category;
 }
 function normalizeSetLinkItemsCategory(type) {
-	const category = normalizeCategory(type);
+	const category = normalizeItemCategory(type);
 	return category == null ? null : [category];
 }
 function parseBaseItemLink(category, rawItem, options) {
@@ -794,41 +743,9 @@ function parseLinks(rawLinks, options) {
 	const links = [];
 	if (rawLinks == null) return links;
 	const hierarchy = rawLinks;
-	for (const entry of collectHierarchyEntries(hierarchy)) switch (entry.category) {
-		case "tree":
-			links.push(parseTreeItemLink(entry.item, options));
-			break;
-		case "bibliography":
-			links.push(parseBibliographyItemLink(entry.item, options));
-			break;
-		case "concept":
-			links.push(parseConceptItemLink(entry.item, options));
-			break;
-		case "spatialUnit":
-			links.push(parseSpatialUnitItemLink(entry.item, options));
-			break;
-		case "period":
-			links.push(parsePeriodItemLink(entry.item, options));
-			break;
-		case "person":
-			links.push(parsePersonItemLink(entry.item, options));
-			break;
-		case "propertyVariable":
-			links.push(parsePropertyVariableItemLink(entry.item, options));
-			break;
-		case "propertyValue":
-			links.push(parsePropertyValueItemLink(entry.item, options));
-			break;
-		case "resource":
-			links.push(parseResourceItemLink(entry.item, options));
-			break;
-		case "text":
-			links.push(parseTextItemLink(entry.item, options));
-			break;
-		case "set":
-			links.push(parseSetItemLink(entry.item, options));
-			break;
-		case "dictionaryUnit": links.push(parseDictionaryUnitItemLink(entry.item, options));
+	for (const entry of collectHierarchyEntries(hierarchy)) {
+		const parse = ITEM_CATEGORIES[entry.category].parseLink;
+		if (parse != null) links.push(parse(entry.item, options));
 	}
 	return links;
 }
@@ -1149,37 +1066,6 @@ function parseText(rawText, options) {
 		editions
 	};
 }
-function parseMetadataLanguages(rawOchre) {
-	const languages = [];
-	const metadataLanguages = rawOchre.metadata.language ?? [];
-	for (const language of metadataLanguages) {
-		const parsedLanguage = parseStringLike(language);
-		if (parsedLanguage != null) languages.push(parsedLanguage);
-	}
-	if (languages.length > 0) return languages;
-	if (rawOchre.languages != null) {
-		for (const language of rawOchre.languages.split(";")) if (language !== "") languages.push(language);
-	}
-	return languages.length > 0 ? languages : [...DEFAULT_LANGUAGES];
-}
-function resolveLanguages(requestedLanguages, metadataLanguages) {
-	if (requestedLanguages == null || requestedLanguages.length === 0) return metadataLanguages;
-	const unsupportedLanguages = [];
-	for (const requestedLanguage of requestedLanguages) if (!metadataLanguages.some((metadataLanguage) => metadataLanguage.toLocaleLowerCase("en-US") === requestedLanguage.toLocaleLowerCase("en-US"))) unsupportedLanguages.push(requestedLanguage);
-	if (unsupportedLanguages.length > 0) throw new Error(`The following language(s) are not supported by the dataset: ${unsupportedLanguages.toSorted((a, b) => a.localeCompare(b, "en-US")).join(", ")}. Available languages: ${metadataLanguages.toSorted((a, b) => a.localeCompare(b, "en-US")).join(", ")}`, { cause: unsupportedLanguages });
-	return requestedLanguages;
-}
-function resolveDefaultLanguage(rawOchre, languages) {
-	const metadataLanguages = rawOchre.metadata.language ?? [];
-	for (const language of metadataLanguages) {
-		const parsedLanguage = parseStringLike(language);
-		if (parsedLanguage != null && language.default === "true" && languages.includes(parsedLanguage)) return parsedLanguage;
-	}
-	for (const language of languages) if (language === DEFAULT_LANGUAGES[0]) return language;
-	const firstLanguage = languages[0];
-	if (firstLanguage == null) throw new Error("Default language not found", { cause: languages });
-	return firstLanguage;
-}
 function parseMetadataPublisher(rawPublisher) {
 	const publisher = Array.isArray(rawPublisher) ? rawPublisher[0] : rawPublisher;
 	return parseStringLike(publisher) ?? "";
@@ -1211,7 +1097,7 @@ function parseMetadata(rawOchre, options, defaultLanguage) {
 		},
 		item: rawMetadata.item == null ? null : {
 			identification: parseIdentification(rawMetadata.item.identification, metadataOptions),
-			category: normalizeCategory(rawMetadata.item.category) ?? rawMetadata.item.category,
+			category: normalizeItemCategory(rawMetadata.item.category) ?? rawMetadata.item.category,
 			type: rawMetadata.item.type,
 			maxLength: rawMetadata.item.maxLength ?? null
 		},
@@ -1231,45 +1117,17 @@ function getSingleTopLevelRawItem(items, category) {
 	return items[0];
 }
 function parseTopLevelItem(rawOchre, category, options) {
-	const rawItems = rawOchre;
-	let parsedItem;
-	switch (category) {
-		case "tree":
-			parsedItem = parseTree(getSingleTopLevelRawItem(rawItems.tree, "tree"), {
-				...options,
-				containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
-			});
-			break;
-		case "bibliography":
-			parsedItem = parseBibliography(getSingleTopLevelRawItem(rawItems.bibliography, "bibliography"), options);
-			break;
-		case "concept":
-			parsedItem = parseConcept(getSingleTopLevelRawItem(rawItems.concept, "concept"), options);
-			break;
-		case "spatialUnit":
-			parsedItem = parseSpatialUnit(getSingleTopLevelRawItem(rawItems.spatialUnit, "spatial unit"), options);
-			break;
-		case "period":
-			parsedItem = parsePeriod(getSingleTopLevelRawItem(rawItems.period, "period"), options);
-			break;
-		case "person":
-			parsedItem = parsePerson(getSingleTopLevelRawItem(rawItems.person, "person"), options);
-			break;
-		case "propertyVariable":
-			parsedItem = parsePropertyVariable(getSingleTopLevelRawItem(rawItems.propertyVariable ?? rawItems.variable, "property variable"), options);
+	const entry = ITEM_CATEGORIES[category];
+	const facts = ITEM_CATEGORY_FACTS[category];
+	let rawCategoryItems;
+	for (const alias of facts.aliases) {
+		const aliasItems = readProperty(rawOchre, alias);
+		if (Array.isArray(aliasItems)) {
+			rawCategoryItems = aliasItems;
 			break;
-		case "propertyValue":
-			parsedItem = parsePropertyValue(getSingleTopLevelRawItem(rawItems.propertyValue ?? rawItems.value, "property value"), options);
-			break;
-		case "resource":
-			parsedItem = parseResource(getSingleTopLevelRawItem(rawItems.resource, "resource"), options);
-			break;
-		case "text":
-			parsedItem = parseText(getSingleTopLevelRawItem(rawItems.text, "text"), options);
-			break;
-		case "set": parsedItem = parseSet(getSingleTopLevelRawItem(rawItems.set, "set"), options);
+		}
 	}
-	return parsedItem;
+	return entry.parseEmbedded(getSingleTopLevelRawItem(rawCategoryItems, facts.label), options);
 }
 function parseLinkedItems(rawItems, options) {
 	const parserOptions = {
@@ -1300,11 +1158,13 @@ function parseItem(rawData, options) {
 	const rawOchre = rawData.result.ochre;
 	const metadataLanguages = parseMetadataLanguages(rawOchre);
 	const languagesToUse = resolveLanguages(options.languages, metadataLanguages);
+	const defaultLanguage = resolveDefaultLanguage(rawOchre, languagesToUse);
 	const parserOptions = {
 		languages: languagesToUse,
+		defaultLanguage,
 		containedItemCategory: options.containedItemCategory
 	};
-	const inferredCategory = normalizeCategory(rawOchre.metadata.item?.category) ?? inferTopLevelCategory(rawOchre);
+	const inferredCategory = normalizeItemCategory(rawOchre.metadata.item?.category) ?? inferTopLevelCategory(rawOchre);
 	let category = inferredCategory;
 	if (options.category != null) {
 		if (typeof options.category === "string") category = options.category;
@@ -1313,7 +1173,6 @@ function parseItem(rawData, options) {
 			categories: options.category
 		} });
 	}
-	const defaultLanguage = resolveDefaultLanguage(rawOchre, languagesToUse);
 	const belongsTo = {
 		uuid: rawOchre.uuidBelongsTo,
 		abbreviation: rawOchre.belongsTo
@@ -1342,4 +1201,4 @@ function parseItem(rawData, options) {
 	};
 }
 //#endregion
-export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };
+export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike };

package/dist/parsers/languages.d.mts

@@ -0,0 +1,72 @@
+import { XMLMetadata } from "../xml/types.mjs";
+//#region src/parsers/languages.d.ts
+/**
+ * Validate language codes while preserving literal tuple inference
+ * @param languages - The language codes to validate
+ * @returns The same tuple, with its literal types intact
+ * @internal
+ */
+export declare function parseLanguages<const T extends ReadonlyArray<string>>(languages: T): T;
+/**
+ * Define a reusable languages tuple with validation and literal type inference
+ *
+ * Inline arrays can be passed directly to a fetcher
+ * (`fetchItem(uuid, { languages: ["eng", "spa"] })`); use this when the
+ * language set is stored separately.
+ * @param languages - The language codes to validate
+ * @returns The same tuple, with its literal types intact
+ */
+export declare function defineLanguages<const TLanguages extends ReadonlyArray<string>>(...languages: TLanguages): TLanguages;
+/**
+ * Validate an optional caller-supplied language tuple
+ * @param languages - The language codes to validate, or undefined
+ * @returns The validated codes, or an empty array when none were requested
+ * @internal
+ */
+export declare function parseRequestedLanguages(languages: ReadonlyArray<string> | undefined): ReadonlyArray<string>;
+/**
+ * Resolve which languages to parse from the content of a payload
+ *
+ * Requested languages win. Otherwise every `content/@xml:lang` found anywhere
+ * beneath the node is used, falling back to {@link DEFAULT_LANGUAGES} when the
+ * payload carries no tagged content at all.
+ * @param node - The payload node to walk
+ * @param requestedLanguages - The languages the caller asked for
+ * @returns The languages to parse
+ * @internal
+ */
+export declare function resolveContentLanguages(node: unknown, requestedLanguages: ReadonlyArray<string>): ReadonlyArray<string>;
+/**
+ * Read the languages a dataset declares in its metadata
+ * @param rawOchre - The raw OCHRE payload root
+ * @param rawOchre.metadata - The payload metadata declaring the languages
+ * @param rawOchre.languages - The semicolon-separated fallback language list
+ * @returns The declared languages, falling back to {@link DEFAULT_LANGUAGES}
+ * @internal
+ */
+export declare function parseMetadataLanguages(rawOchre: {
+  metadata: XMLMetadata;
+  languages?: string;
+}): Array<string>;
+/**
+ * Reconcile requested languages against the ones a dataset declares
+ * @param requestedLanguages - The languages the caller asked for
+ * @param metadataLanguages - The languages the dataset declares
+ * @returns The languages to parse
+ * @throws When a requested language is not offered by the dataset
+ * @internal
+ */
+export declare function resolveLanguages<T extends ReadonlyArray<string>>(requestedLanguages: T | undefined, metadataLanguages: Array<string>): T;
+/**
+ * Pick the language a dataset treats as its default
+ * @param rawOchre - The raw OCHRE payload root
+ * @param rawOchre.metadata - The payload metadata declaring the default
+ * @param languages - The languages being parsed
+ * @returns The default language
+ * @throws When `languages` is empty
+ * @internal
+ */
+export declare function resolveDefaultLanguage<T extends ReadonlyArray<string>>(rawOchre: {
+  metadata: XMLMetadata;
+}, languages: T): T[number];
+//#endregion