ochre-sdk 1.3.11 → 1.3.13

package/README.md

@@ -66,10 +66,7 @@ present and `error` is `null`; on failure, the parsed value is `null` and
   style, collection, and item-page configuration.
 - `fetchSetItems(params, containedItemCategories, options)` fetches paginated
   Set search results with typed query and sort support.
-- `fetchSetItemLocations(params, options)` fetches the identification,
-  coordinates and chosen property values of every Set item matching a query,
-  without paging, for drawing all results on a map while a list pages through
-  them.
+- `fetchItemLocations(params, options)` fetches the identification, coordinates, and chosen property values of every Set or Tree item matching a query without paging. You can pass `setScopeUuids`, `treeScopeUuids`, or both. Each item lists the scope Sets and Trees it belongs to; this allows a map to draw one layer per Set or Tree while a list pages through the same query.
 - `fetchTreeItems(params, containedItemCategories, options)` is the same for a
   Tree, and is how to read a Tree too large to fetch whole. Items nested under
   headings come back flat, in document order.

package/dist/constants.mjs

@@ -40,7 +40,10 @@ const XML_ARRAY_TAGS = [
 	"scope",
 	"level",
 	"style",
+	"styleLabel",
 	"itemLocation",
+	"mapSource",
+	"mapLayer",
 	"flattenContexts",
 	"suppressContexts",
 	"filterContexts",

package/dist/fetchers/item-locations.d.mts

@@ -0,0 +1,41 @@
+import { ItemLocation, Query } from "../types/index.mjs";
+import { FetchBaseOptions, FetchLanguages } from "../parsers/helpers.mjs";
+//#region src/fetchers/item-locations.d.ts
+/**
+ * Fetches the location of every Set or Tree item that matches a query, without paging
+ *
+ * Each item carries only its identification, the scope Sets and Trees it
+ * belongs to, its publication date, its coordinates, optionally its map
+ * polygons, and the values of the requested property variables (inherited
+ * values included), which is what a map needs to draw, color and group every
+ * match into layers while a list pages through the same query with
+ * {@link fetchSetItems} or {@link fetchTreeItems}.
+ *
+ * @param parameters - The parameters for the fetch
+ * @param parameters.setScopeUuids - The Set scope UUIDs to search within
+ * @param parameters.treeScopeUuids - The Tree scope UUIDs to search within
+ * @param parameters.queries - Recursive query tree used to filter matching items
+ * @param parameters.propertyVariableUuids - The property variables whose values each item should carry
+ * @param parameters.isMapDataIncluded - Whether each item should carry its map polygons
+ * @param options - Options for the fetch
+ * @param options.fetch - The fetch function to use
+ * @returns The item locations, or an error if the fetch/parse fails
+ */
+export declare function fetchItemLocations<const TLanguages extends ReadonlyArray<string> | undefined = undefined>(parameters: {
+  setScopeUuids?: Array<string>;
+  treeScopeUuids?: Array<string>;
+  queries?: Query | null;
+  propertyVariableUuids?: Array<string>;
+  isMapDataIncluded?: boolean;
+}, options?: FetchBaseOptions<TLanguages>): Promise<{
+  totalCount: number;
+  items: Array<ItemLocation<FetchLanguages<TLanguages>>>;
+  error: null;
+  detailedError: null;
+} | {
+  totalCount: null;
+  items: null;
+  error: string;
+  detailedError: string;
+}>;
+//#endregion

package/dist/fetchers/item-locations.mjs

@@ -0,0 +1,99 @@
+import { normalizeItemCategory } from "../categories.mjs";
+import { getErrorOutput } from "../errors.mjs";
+import { requestOchre } from "./request.mjs";
+import { itemLocationsParametersSchema } from "../schemas.mjs";
+import { parseRequiredContentLike } from "../parsers/helpers.mjs";
+import { parseRequestedLanguages, resolveContentLanguages } from "../parsers/languages.mjs";
+import { parseCoordinates, parseIdentification, parseSpatialUnitMapData } from "../parsers/index.mjs";
+import { XMLItemLocationsData } from "../xml/schemas.mjs";
+import { getContentLanguage, stringLiteral } from "../xquery.mjs";
+import { compileContainerItemsQuery } from "../query.mjs";
+import * as v from "valibot";
+//#region src/fetchers/item-locations.ts
+async function fetchItemLocations(parameters, options) {
+	try {
+		const { setScopeUuids, treeScopeUuids, belongsToCollectionScopeUuids, queries, propertyVariableUuids, isMapDataIncluded } = v.parse(itemLocationsParametersSchema, parameters);
+		const scopes = [{
+			container: "set",
+			scopeUuids: setScopeUuids
+		}, {
+			container: "tree",
+			scopeUuids: treeScopeUuids
+		}].filter(({ scopeUuids }) => scopeUuids.length > 0);
+		const outputs = await Promise.all(scopes.map(async ({ container, scopeUuids }) => requestOchre({
+			xquery: compileContainerItemsQuery({
+				container,
+				scopeUuids,
+				belongsToCollectionScopeUuids,
+				queries,
+				contentLanguage: getContentLanguage(options),
+				body: ({ items }) => `  let $propertyVariableUuids := (${Array.from(propertyVariableUuids, (uuid) => stringLiteral(uuid)).join(", ")})
+
+  return <items totalCount="{count(${items})}">{
+    for $item in ${items}
+    return <itemLocation uuid="{$item/@uuid}" category="{local-name($item)}" scopeUuid="{$item/ancestor::${container}[1]/@uuid}">{
+      ${container === "tree" ? "($item/@publicationDateTime, $item/ancestor::tree[1]/@publicationDateTime)[1]" : "$item/@publicationDateTime"},
+      $item/identification,
+      $item/coordinates,${isMapDataIncluded ? "\n      $item/mapData," : ""}
+      for $value in $item//properties//property[label/@uuid = $propertyVariableUuids]/value[@uuid]
+      return <value variable="{$value/../label/@uuid}" uuid="{$value/@uuid}">{$value/content}</value>
+    }</itemLocation>
+  }</items>`
+			}),
+			schema: XMLItemLocationsData,
+			label: `OCHRE ${container === "set" ? "Set" : "Tree"} item locations`,
+			options
+		})));
+		const languages = resolveContentLanguages(outputs.map((output) => output.result.ochre.items), parseRequestedLanguages(options?.languages));
+		let totalCount = 0;
+		for (const output of outputs) totalCount += output.result.ochre.items.totalCount;
+		const itemsByUuid = /* @__PURE__ */ new Map();
+		const itemLocations = outputs.flatMap((output) => output.result.ochre.items.itemLocation ?? []);
+		for (const itemLocation of itemLocations) {
+			const category = normalizeItemCategory(itemLocation.category);
+			const existing = itemsByUuid.get(itemLocation.uuid);
+			if (existing != null) {
+				if (!existing.scopeUuids.includes(itemLocation.scopeUuid)) existing.scopeUuids.push(itemLocation.scopeUuid);
+				continue;
+			}
+			if (category == null) continue;
+			const propertyValues = [];
+			const seenPropertyValues = /* @__PURE__ */ new Set();
+			const values = itemLocation.value ?? [];
+			for (const value of values) {
+				const key = `${value.variable}:${value.uuid}`;
+				if (seenPropertyValues.has(key)) continue;
+				seenPropertyValues.add(key);
+				propertyValues.push({
+					variableUuid: value.variable,
+					valueUuid: value.uuid,
+					label: parseRequiredContentLike(value, { languages })
+				});
+			}
+			itemsByUuid.set(itemLocation.uuid, {
+				uuid: itemLocation.uuid,
+				category,
+				scopeUuids: [itemLocation.scopeUuid],
+				publicationDateTime: itemLocation.publicationDateTime ?? null,
+				identification: parseIdentification(itemLocation.identification, { languages }),
+				coordinates: parseCoordinates(itemLocation.coordinates, { languages }),
+				mapData: parseSpatialUnitMapData(itemLocation.mapData),
+				propertyValues
+			});
+		}
+		return {
+			totalCount,
+			items: itemsByUuid.values().toArray(),
+			error: null,
+			detailedError: null
+		};
+	} catch (error) {
+		return {
+			totalCount: null,
+			items: null,
+			...getErrorOutput(error, "Failed to fetch item locations")
+		};
+	}
+}
+//#endregion
+export { fetchItemLocations };

package/dist/fetchers/map-layers.d.mts

@@ -0,0 +1,30 @@
+import { MapLayer } from "../types/index.mjs";
+import { FetchBaseOptions, FetchLanguages } from "../parsers/helpers.mjs";
+//#region src/fetchers/map-layers.d.ts
+/**
+ * Fetches the layers a map draws from the Sets and Trees it links to
+ *
+ * A linked Set holding only Sets, Trees and Resources is a layer list: each
+ * linked Set or Tree becomes an OCHRE layer and each webpage Resource whose
+ * href points at a geospatial web service becomes a service layer. Any other
+ * linked Set or Tree is drawn as one OCHRE layer itself. The variant is
+ * `"arcgis"` when any service layer is present, else `"maplibre-gl"`.
+ *
+ * @param uuids - The UUIDs of the Sets and Trees the map links to, in order
+ * @param options - Options for the fetch
+ * @param options.languages - Language codes to parse
+ * @param options.fetch - The fetch function to use
+ * @returns The map variant and layers, or an error if the fetch/parse fails
+ */
+export declare function fetchMapLayers<const TLanguages extends ReadonlyArray<string> | undefined = undefined>(uuids: Array<string>, options?: FetchBaseOptions<TLanguages>): Promise<{
+  variant: "maplibre-gl" | "arcgis";
+  layers: Array<MapLayer<FetchLanguages<TLanguages>>>;
+  error: null;
+  detailedError: null;
+} | {
+  variant: null;
+  layers: null;
+  error: string;
+  detailedError: string;
+}>;
+//#endregion

package/dist/fetchers/map-layers.mjs

@@ -0,0 +1,161 @@
+import { getErrorOutput } from "../errors.mjs";
+import { requestOchre } from "./request.mjs";
+import { uuidSchema } from "../schemas.mjs";
+import { parseRequestedLanguages, resolveContentLanguages } from "../parsers/languages.mjs";
+import { parseIdentification } from "../parsers/index.mjs";
+import { XMLMapSourcesData } from "../xml/schemas.mjs";
+import { OCHRE_RESPONSE_PADDING, compileOchreQuery, getContentLanguage, stringLiteral } from "../xquery.mjs";
+import * as v from "valibot";
+//#region src/fetchers/map-layers.ts
+const REGEX_TILE_TEMPLATE_LEVEL = /\{(?:level|z)\}/i;
+const REGEX_TILE_TEMPLATE_ROW = /\{(?:row|y)\}/i;
+const REGEX_TILE_TEMPLATE_COLUMN = /\{(?:col|x)\}/i;
+const REGEX_UNSUPPORTED_HOST = /(?:^|\.)google\.[a-z.]+$/i;
+const REGEX_PORTAL_ITEM_PATH = /\/home\/(?:item|webmap\/viewer)\.html$/i;
+const REGEX_PORTAL_ITEM_ID = /^[\da-f]{32}$/i;
+const REGEX_WMTS_CAPABILITIES = /\/WMTSCapabilities\.xml$/i;
+const REGEX_WMS_PATH = /\/wms(?:\/|$)/i;
+const REGEX_FEATURE_SERVER = /\/FeatureServer(?:\/\d+)?\/?$/i;
+const REGEX_MAP_SERVER = /\/MapServer(?:\/\d+)?\/?$/i;
+const REGEX_IMAGE_SERVER = /\/ImageServer\/?$/i;
+const REGEX_TRAILING_SLASH = /\/$/;
+const REGEX_ARCGIS_SOAP_SERVICES = /\/arcgis\/services\//i;
+/**
+* Classify the href of a webpage Resource as a geospatial web service
+* @param href - The Resource href
+* @returns The service layer, or null when the href names no supported service
+*/
+function parseServiceLayer(href) {
+	const trimmedHref = href.trim();
+	const url = URL.parse(trimmedHref);
+	if (url == null || REGEX_UNSUPPORTED_HOST.test(url.hostname)) return null;
+	if (REGEX_TILE_TEMPLATE_LEVEL.test(trimmedHref) && REGEX_TILE_TEMPLATE_ROW.test(trimmedHref) && REGEX_TILE_TEMPLATE_COLUMN.test(trimmedHref)) return {
+		type: "web-tile",
+		url: trimmedHref
+	};
+	let service = null;
+	for (const [key, value] of url.searchParams) if (key.toLowerCase() === "service") service = value.toLowerCase();
+	const itemId = url.searchParams.get("webmap") ?? (REGEX_PORTAL_ITEM_PATH.test(url.pathname) ? url.searchParams.get("id") : null);
+	if (itemId != null && REGEX_PORTAL_ITEM_ID.test(itemId)) return {
+		type: "arcgis-item",
+		itemId,
+		portalUrl: url.origin
+	};
+	const baseUrl = `${url.origin}${url.pathname.replace(REGEX_TRAILING_SLASH, "")}`;
+	const restUrl = baseUrl.replace(REGEX_ARCGIS_SOAP_SERVICES, "/arcgis/rest/services/");
+	if (service === "wmts") return {
+		type: "wmts",
+		url: baseUrl
+	};
+	if (REGEX_WMTS_CAPABILITIES.test(url.pathname)) return {
+		type: "wmts",
+		url: trimmedHref
+	};
+	if (service === "wms" || REGEX_WMS_PATH.test(url.pathname)) return {
+		type: "wms",
+		url: baseUrl
+	};
+	if (REGEX_FEATURE_SERVER.test(url.pathname)) return {
+		type: "arcgis-feature",
+		url: restUrl
+	};
+	if (REGEX_MAP_SERVER.test(url.pathname)) return {
+		type: "arcgis-map",
+		url: restUrl
+	};
+	if (REGEX_IMAGE_SERVER.test(url.pathname)) return {
+		type: "arcgis-image",
+		url: restUrl
+	};
+	return null;
+}
+/**
+* Build the layer a Set, Tree or Resource of a map's layer list stands for
+* @param member - The linked Set, Tree or Resource
+* @param languages - The languages to parse
+* @returns The layer, or null when a Resource names no supported service
+*/
+function parseMapLayer(member, languages) {
+	const { label } = parseIdentification(member.identification, { languages });
+	if (member.category === "set" || member.category === "tree") return {
+		type: member.category === "set" ? "ochre-set" : "ochre-tree",
+		uuid: member.uuid,
+		label,
+		wkid: member.WKID ?? null
+	};
+	const service = "href" in member && member.href != null ? parseServiceLayer(member.href) : null;
+	return service == null ? null : {
+		...service,
+		uuid: member.uuid,
+		label
+	};
+}
+async function fetchMapLayers(uuids, options) {
+	try {
+		const parsedUuids = v.parse(v.pipe(v.array(uuidSchema), v.minLength(1, "At least one map link UUID is required")), uuids);
+		const output = await requestOchre({
+			xquery: compileOchreQuery({
+				contentLanguage: getContentLanguage(options),
+				body: () => `<ochre>${OCHRE_RESPONSE_PADDING}<mapSources>{
+  for $uuid in (${parsedUuids.map((uuid) => stringLiteral(uuid)).join(", ")})
+  let $set := fn:collection("ochre/set")/ochre[@uuid = $uuid]/set
+  let $source := if (exists($set)) then $set else fn:collection("ochre/tree")/ochre[@uuid = $uuid]/tree
+  let $members := $set/items/*
+  let $layers := $members[self::set or self::tree or self::resource]
+  where exists($source)
+  return <mapSource uuid="{$uuid}" category="{local-name($source[1])}">{
+    $source[1]/@WKID,
+    $source[1]/identification,
+    if (exists($members) and count($layers) = count($members))
+    then
+      for $layer in $layers
+      let $layerUuid := $layer/@uuid/string()
+      return <mapLayer uuid="{$layerUuid}" category="{local-name($layer)}">{
+        $layer/@type,
+        $layer/@href,
+        if (local-name($layer) = "set")
+        then fn:collection("ochre/set")/ochre[@uuid = $layerUuid]/set[1]/@WKID
+        else (),
+        $layer/identification
+      }</mapLayer>
+    else ()
+  }</mapSource>
+}</mapSources></ochre>`
+			}),
+			schema: XMLMapSourcesData,
+			label: "OCHRE map layers",
+			options
+		});
+		const languages = resolveContentLanguages(output.result.ochre.mapSources, parseRequestedLanguages(options?.languages));
+		const layers = [];
+		const layerUuids = /* @__PURE__ */ new Set();
+		const sources = output.result.ochre.mapSources.mapSource ?? [];
+		for (const source of sources) {
+			const sourceLayers = [];
+			const members = source.mapLayer ?? [source];
+			for (const member of members) {
+				const layer = parseMapLayer(member, languages);
+				if (layer != null) sourceLayers.push(layer);
+			}
+			const mapServerUrls = sourceLayers.flatMap((layer) => layer.type === "arcgis-map" ? [`${layer.url}/`] : []);
+			for (const layer of sourceLayers) if (!(layer.type === "wmts" && mapServerUrls.some((url) => layer.url.startsWith(url))) && !layerUuids.has(layer.uuid)) {
+				layerUuids.add(layer.uuid);
+				layers.push(layer);
+			}
+		}
+		return {
+			variant: layers.some((layer) => layer.type !== "ochre-set" && layer.type !== "ochre-tree") ? "arcgis" : "maplibre-gl",
+			layers,
+			error: null,
+			detailedError: null
+		};
+	} catch (error) {
+		return {
+			variant: null,
+			layers: null,
+			...getErrorOutput(error, "Failed to fetch map layers")
+		};
+	}
+}
+//#endregion
+export { fetchMapLayers };

package/dist/fetchers/website.mjs

@@ -29,7 +29,16 @@ function buildXQuery(abbreviation) {
 	return compileOchreQuery({ body: ({ omitSupplemental }) => `let $ochre := collection("ochre/tree")/ochre[tree/identification/abbreviation/content/string = ${stringLiteral(abbreviation)}][1]
 return
   if (empty($ochre)) then <ochre>${OCHRE_RESPONSE_PADDING}</ochre>
-  else element ochre { $ochre/@*, ${omitSupplemental("$ochre/node()")} }` });
+  else element ochre {
+    $ochre/@*,
+    ${omitSupplemental("$ochre/node()")},
+    <styleLabels>{
+      for $style in $ochre/tree/styleOptions/style[@valueUuid]
+      let $value := (doc()/ochre[@uuidBelongsTo = $ochre/@uuidBelongsTo]//property[label/@uuid = $style/@variableUuid]/value[@uuid = $style/@valueUuid][content])[1]
+      where exists($value)
+      return <styleLabel valueUuid="{$style/@valueUuid}">{$value/content}</styleLabel>
+    }</styleLabels>
+  }` });
 }
 /**
 * Fetches and parses a website configuration from the OCHRE API.

package/dist/index.d.mts

@@ -1,13 +1,14 @@
 import { MultilingualOptions, MultilingualString, MultilingualStringEntries, MultilingualStringEntry, MultilingualStringInput, MultilingualStringJSON, MultilingualStringObject, MultilingualStringText } from "./parsers/multilingual.mjs";
 import { AccordionWebBlock, ContextTree, ContextTreeFilterLevel, ContextTreeFilterVariant, ContextTreeLevel, ContextTreeLevelItem, ProtectedWebsite, ResponsiveStyles, Scope, Style, StylesheetCategory, StylesheetItem, WebAccordionItem, WebBlock, WebBlockByLayout, WebBlockItem, WebBlockLayout, WebElement, WebElementComponent, WebElementComponentName, WebElementComponentOf, WebElementOf, WebIiifViewer, WebImage, WebLoadingVariant, WebOptions, WebRelationVariant, WebSectionDisplay, WebSectionVariant, WebSidebar, WebTitle, Webpage, Website, WebsiteMetadata, WebsitePrivacy, WebsitePropertyQuery, WebsitePropertyQueryNode, WebsiteSegment, WebsiteType } from "./types/website.mjs";
-import { AnyBibliography, AnyConcept, AnyItem, AnyPeriod, AnyPerson, AnyPropertyValue, AnyPropertyVariable, AnyResource, AnySet, AnySpatialUnit, AnyText, AnyTree, BaseItem, BaseItemLink, BelongsTo, Bibliography, BibliographyEntryInfo, BibliographyItemLink, BibliographySourceDocument, Concept, ConceptItemLink, ContainedItemCategory, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Context, ContextItem, ContextItemCategory, ContextNode, Coordinates, CoordinatesSource, DictionaryUnitItemLink, EmbeddedBibliography, EmbeddedConcept, EmbeddedItem, EmbeddedPeriod, EmbeddedPerson, EmbeddedPropertyValue, EmbeddedPropertyVariable, EmbeddedResource, EmbeddedSet, EmbeddedSpatialUnit, EmbeddedText, EmbeddedTree, Event, Gallery, Heading, HeadingItemCategory, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemCategoryWithEmbeddedItems, ItemContainerCategory, ItemLink, ItemLinkCategory, ItemLinks, ItemPayloadKind, ItemProperty, ItemWithoutEmbeddedItems, LanguageCodes, License, Metadata, Note, Observation, OcrString, Period, PeriodItemLink, Person, PersonItemLink, Property, PropertyLike, PropertyRelation, PropertyValue, PropertyValueContent, PropertyValueDataType, PropertyValueItemLink, PropertyValueQueryItem, PropertyVariable, PropertyVariableItemLink, Query, QueryGroup, QueryLeaf, QueryablePropertyValueDataType, RecursiveItemCategory, Resource, ResourceItemLink, Section, Set, SetAttributeValueQueryItem, SetBibliography, SetConcept, SetItem, SetItemCategory, SetItemLink, SetItemLocation, SetItemProperty, SetItemSimplifiedProperty, SetItemsSort, SetItemsSortDirection, SetPeriod, SetResource, SetSpatialUnit, SetStyle, SetStyleProperty, SetTree, SimplifiedProperty, SpatialUnit, SpatialUnitItemLink, Text, TextItemLink, TopLevelItem, Tree, TreeItemCategory, TreeItemLink } from "./types/index.mjs";
+import { AnyBibliography, AnyConcept, AnyItem, AnyPeriod, AnyPerson, AnyPropertyValue, AnyPropertyVariable, AnyResource, AnySet, AnySpatialUnit, AnyText, AnyTree, BaseItem, BaseItemLink, BelongsTo, Bibliography, BibliographyEntryInfo, BibliographyItemLink, BibliographySourceDocument, Concept, ConceptItemLink, ContainedItemCategory, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Context, ContextItem, ContextItemCategory, ContextNode, Coordinates, CoordinatesSource, DictionaryUnitItemLink, EmbeddedBibliography, EmbeddedConcept, EmbeddedItem, EmbeddedPeriod, EmbeddedPerson, EmbeddedPropertyValue, EmbeddedPropertyVariable, EmbeddedResource, EmbeddedSet, EmbeddedSpatialUnit, EmbeddedText, EmbeddedTree, Event, Gallery, Heading, HeadingItemCategory, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemCategoryWithEmbeddedItems, ItemContainerCategory, ItemLink, ItemLinkCategory, ItemLinks, ItemLocation, ItemPayloadKind, ItemProperty, ItemWithoutEmbeddedItems, LanguageCodes, License, MapLayer, Metadata, Note, Observation, OcrString, Period, PeriodItemLink, Person, PersonItemLink, Property, PropertyLike, PropertyRelation, PropertyValue, PropertyValueContent, PropertyValueDataType, PropertyValueItemLink, PropertyValueQueryItem, PropertyVariable, PropertyVariableItemLink, Query, QueryGroup, QueryLeaf, QueryablePropertyValueDataType, RecursiveItemCategory, Resource, ResourceItemLink, Section, Set, SetAttributeValueQueryItem, SetBibliography, SetConcept, SetItem, SetItemCategory, SetItemLink, SetItemProperty, SetItemSimplifiedProperty, SetItemsSort, SetItemsSortDirection, SetPeriod, SetResource, SetSpatialUnit, SetStyle, SetStyleProperty, SetTree, SimplifiedProperty, SpatialUnit, SpatialUnitItemLink, Text, TextItemLink, TopLevelItem, Tree, TreeItemCategory, TreeItemLink } from "./types/index.mjs";
 import { DEFAULT_PAGE_SIZE } from "./constants.mjs";
 import { fetchGallery } from "./fetchers/gallery.mjs";
 import { fetchItemChildren } from "./fetchers/item-children.mjs";
 import { fetchItemLinks } from "./fetchers/item-links.mjs";
+import { fetchItemLocations } from "./fetchers/item-locations.mjs";
 import { fetchItemOcrData } from "./fetchers/item-ocr-data.mjs";
 import { fetchItem } from "./fetchers/item.mjs";
-import { fetchSetItemLocations } from "./fetchers/set/item-locations.mjs";
+import { fetchMapLayers } from "./fetchers/map-layers.mjs";
 import { fetchSetItems } from "./fetchers/set/items.mjs";
 import { fetchSetPropertyValues } from "./fetchers/set/property-values.mjs";
 import { fetchTreeItems } from "./fetchers/tree/items.mjs";
@@ -17,4 +18,4 @@ import { PropertyOptions, PropertySelector, getLeafPropertyValues, getProperty,
 import { flattenItemProperties } from "./helpers.mjs";
 import { OCHRE_LANGUAGES, OchreLanguage, OchreLanguageCode, OchreLanguageKind, OchreLanguageStandard, getOchreLanguage, getOchreLanguageCode, isOchreLanguageCode } from "./languages.mjs";
 import { defineLanguages } from "./parsers/languages.mjs";
-export { type AccordionWebBlock, type AnyBibliography, type AnyConcept, type AnyItem, type AnyPeriod, type AnyPerson, type AnyPropertyValue, type AnyPropertyVariable, type AnyResource, type AnySet, type AnySpatialUnit, type AnyText, type AnyTree, type BaseItem, type BaseItemLink, type BelongsTo, type Bibliography, type BibliographyEntryInfo, type BibliographyItemLink, type BibliographySourceDocument, type Concept, type ConceptItemLink, type ContainedItemCategory, type ContainedItemCategoryFromOption, type ContainedItemCategoryOption, type Context, type ContextItem, type ContextItemCategory, type ContextNode, type ContextTree, type ContextTreeFilterLevel, type ContextTreeFilterVariant, type ContextTreeLevel, type ContextTreeLevelItem, type Coordinates, type CoordinatesSource, DEFAULT_PAGE_SIZE, type DictionaryUnitItemLink, type EmbeddedBibliography, type EmbeddedConcept, type EmbeddedItem, type EmbeddedPeriod, type EmbeddedPerson, type EmbeddedPropertyValue, type EmbeddedPropertyVariable, type EmbeddedResource, type EmbeddedSet, type EmbeddedSpatialUnit, type EmbeddedText, type EmbeddedTree, type Event, type Gallery, type Heading, type HeadingItemCategory, type Identification, type Image, type ImageMap, type ImageMapArea, type Interpretation, type Item, type ItemCategory, type ItemCategoryFromOption, type ItemCategoryOption, type ItemCategoryWithEmbeddedItems, type ItemContainerCategory, type ItemLink, type ItemLinkCategory, type ItemLinks, type ItemPayloadKind, type ItemProperty, type ItemWithoutEmbeddedItems, type LanguageCodes, type License, type Metadata, type MultilingualOptions, MultilingualString, type MultilingualStringEntries, type MultilingualStringEntry, type MultilingualStringInput, type MultilingualStringJSON, type MultilingualStringObject, type MultilingualStringText, type Note, OCHRE_LANGUAGES, type Observation, type OchreLanguage, type OchreLanguageCode, type OchreLanguageKind, type OchreLanguageStandard, type OcrString, type Period, type PeriodItemLink, type Person, type PersonItemLink, type Property, type PropertyLike, type PropertyOptions, type PropertyRelation, type PropertySelector, type PropertyValue, type PropertyValueContent, type PropertyValueDataType, type PropertyValueItemLink, type PropertyValueQueryItem, type PropertyVariable, type PropertyVariableItemLink, type ProtectedWebsite, type Query, type QueryGroup, type QueryLeaf, type QueryablePropertyValueDataType, type RecursiveItemCategory, type Resource, type ResourceItemLink, type ResponsiveStyles, type Scope, type Section, type Set, type SetAttributeValueQueryItem, type SetBibliography, type SetConcept, type SetItem, type SetItemCategory, type SetItemLink, type SetItemLocation, type SetItemProperty, type SetItemSimplifiedProperty, type SetItemsSort, type SetItemsSortDirection, type SetPeriod, type SetResource, type SetSpatialUnit, type SetStyle, type SetStyleProperty, type SetTree, type SimplifiedProperty, type SpatialUnit, type SpatialUnitItemLink, type Style, type StylesheetCategory, type StylesheetItem, type Text, type TextItemLink, type TopLevelItem, type Tree, type TreeItemCategory, type TreeItemLink, type WebAccordionItem, type WebBlock, type WebBlockByLayout, type WebBlockItem, type WebBlockLayout, type WebElement, type WebElementComponent, type WebElementComponentName, type WebElementComponentOf, type WebElementOf, type WebIiifViewer, type WebImage, type WebLoadingVariant, type WebOptions, type WebRelationVariant, type WebSectionDisplay, type WebSectionVariant, type WebSidebar, type WebTitle, type Webpage, type Website, type WebsiteMetadata, type WebsitePrivacy, type WebsitePropertyQuery, type WebsitePropertyQueryNode, type WebsiteSegment, type WebsiteType, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchItemOcrData, fetchSetItemLocations, fetchSetItems, fetchSetPropertyValues, fetchTreeItems, fetchWebsite, fetchWebsiteMetadata, flattenItemProperties, getLeafPropertyValues, getOchreLanguage, getOchreLanguageCode, getProperty, getPropertyValue, getPropertyValues, getUniqueProperties, getUniquePropertyVariableLabels, isOchreLanguageCode, isPropertyMatchingFilter, normalizePropertyVariableLabel };
+export { type AccordionWebBlock, type AnyBibliography, type AnyConcept, type AnyItem, type AnyPeriod, type AnyPerson, type AnyPropertyValue, type AnyPropertyVariable, type AnyResource, type AnySet, type AnySpatialUnit, type AnyText, type AnyTree, type BaseItem, type BaseItemLink, type BelongsTo, type Bibliography, type BibliographyEntryInfo, type BibliographyItemLink, type BibliographySourceDocument, type Concept, type ConceptItemLink, type ContainedItemCategory, type ContainedItemCategoryFromOption, type ContainedItemCategoryOption, type Context, type ContextItem, type ContextItemCategory, type ContextNode, type ContextTree, type ContextTreeFilterLevel, type ContextTreeFilterVariant, type ContextTreeLevel, type ContextTreeLevelItem, type Coordinates, type CoordinatesSource, DEFAULT_PAGE_SIZE, type DictionaryUnitItemLink, type EmbeddedBibliography, type EmbeddedConcept, type EmbeddedItem, type EmbeddedPeriod, type EmbeddedPerson, type EmbeddedPropertyValue, type EmbeddedPropertyVariable, type EmbeddedResource, type EmbeddedSet, type EmbeddedSpatialUnit, type EmbeddedText, type EmbeddedTree, type Event, type Gallery, type Heading, type HeadingItemCategory, type Identification, type Image, type ImageMap, type ImageMapArea, type Interpretation, type Item, type ItemCategory, type ItemCategoryFromOption, type ItemCategoryOption, type ItemCategoryWithEmbeddedItems, type ItemContainerCategory, type ItemLink, type ItemLinkCategory, type ItemLinks, type ItemLocation, type ItemPayloadKind, type ItemProperty, type ItemWithoutEmbeddedItems, type LanguageCodes, type License, type MapLayer, type Metadata, type MultilingualOptions, MultilingualString, type MultilingualStringEntries, type MultilingualStringEntry, type MultilingualStringInput, type MultilingualStringJSON, type MultilingualStringObject, type MultilingualStringText, type Note, OCHRE_LANGUAGES, type Observation, type OchreLanguage, type OchreLanguageCode, type OchreLanguageKind, type OchreLanguageStandard, type OcrString, type Period, type PeriodItemLink, type Person, type PersonItemLink, type Property, type PropertyLike, type PropertyOptions, type PropertyRelation, type PropertySelector, type PropertyValue, type PropertyValueContent, type PropertyValueDataType, type PropertyValueItemLink, type PropertyValueQueryItem, type PropertyVariable, type PropertyVariableItemLink, type ProtectedWebsite, type Query, type QueryGroup, type QueryLeaf, type QueryablePropertyValueDataType, type RecursiveItemCategory, type Resource, type ResourceItemLink, type ResponsiveStyles, type Scope, type Section, type Set, type SetAttributeValueQueryItem, type SetBibliography, type SetConcept, type SetItem, type SetItemCategory, type SetItemLink, type SetItemProperty, type SetItemSimplifiedProperty, type SetItemsSort, type SetItemsSortDirection, type SetPeriod, type SetResource, type SetSpatialUnit, type SetStyle, type SetStyleProperty, type SetTree, type SimplifiedProperty, type SpatialUnit, type SpatialUnitItemLink, type Style, type StylesheetCategory, type StylesheetItem, type Text, type TextItemLink, type TopLevelItem, type Tree, type TreeItemCategory, type TreeItemLink, type WebAccordionItem, type WebBlock, type WebBlockByLayout, type WebBlockItem, type WebBlockLayout, type WebElement, type WebElementComponent, type WebElementComponentName, type WebElementComponentOf, type WebElementOf, type WebIiifViewer, type WebImage, type WebLoadingVariant, type WebOptions, type WebRelationVariant, type WebSectionDisplay, type WebSectionVariant, type WebSidebar, type WebTitle, type Webpage, type Website, type WebsiteMetadata, type WebsitePrivacy, type WebsitePropertyQuery, type WebsitePropertyQueryNode, type WebsiteSegment, type WebsiteType, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchItemLocations, fetchItemOcrData, fetchMapLayers, fetchSetItems, fetchSetPropertyValues, fetchTreeItems, fetchWebsite, fetchWebsiteMetadata, flattenItemProperties, getLeafPropertyValues, getOchreLanguage, getOchreLanguageCode, getProperty, getPropertyValue, getPropertyValues, getUniqueProperties, getUniquePropertyVariableLabels, isOchreLanguageCode, isPropertyMatchingFilter, normalizePropertyVariableLabel };

package/dist/index.mjs

@@ -7,12 +7,13 @@ import { defineLanguages } from "./parsers/languages.mjs";
 import { fetchGallery } from "./fetchers/gallery.mjs";
 import { fetchItemChildren } from "./fetchers/item-children.mjs";
 import { fetchItemLinks } from "./fetchers/item-links.mjs";
+import { fetchItemLocations } from "./fetchers/item-locations.mjs";
 import { fetchItemOcrData } from "./fetchers/item-ocr-data.mjs";
 import { fetchItem } from "./fetchers/item.mjs";
-import { fetchSetItemLocations } from "./fetchers/set/item-locations.mjs";
+import { fetchMapLayers } from "./fetchers/map-layers.mjs";
 import { fetchSetItems } from "./fetchers/set/items.mjs";
 import { fetchSetPropertyValues } from "./fetchers/set/property-values.mjs";
 import { fetchTreeItems } from "./fetchers/tree/items.mjs";
 import { fetchWebsiteMetadata } from "./fetchers/website-metadata.mjs";
 import { fetchWebsite } from "./fetchers/website.mjs";
-export { DEFAULT_PAGE_SIZE, MultilingualString, OCHRE_LANGUAGES, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchItemOcrData, fetchSetItemLocations, fetchSetItems, fetchSetPropertyValues, fetchTreeItems, fetchWebsite, fetchWebsiteMetadata, flattenItemProperties, getLeafPropertyValues, getOchreLanguage, getOchreLanguageCode, getProperty, getPropertyValue, getPropertyValues, getUniqueProperties, getUniquePropertyVariableLabels, isOchreLanguageCode, isPropertyMatchingFilter, normalizePropertyVariableLabel };
+export { DEFAULT_PAGE_SIZE, MultilingualString, OCHRE_LANGUAGES, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchItemLocations, fetchItemOcrData, fetchMapLayers, fetchSetItems, fetchSetPropertyValues, fetchTreeItems, fetchWebsite, fetchWebsiteMetadata, flattenItemProperties, getLeafPropertyValues, getOchreLanguage, getOchreLanguageCode, getProperty, getPropertyValue, getPropertyValues, getUniqueProperties, getUniquePropertyVariableLabels, isOchreLanguageCode, isPropertyMatchingFilter, normalizePropertyVariableLabel };

package/dist/parsers/index.d.mts

@@ -1,6 +1,6 @@
 import { Webpage } from "../types/website.mjs";
-import { Bibliography, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Coordinates, Gallery, Identification, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemContainerCategory, ItemLinks, Metadata, Note, Person, Property, Resource, SetItem, SetItemCategory, SimplifiedProperty } from "../types/index.mjs";
-import { XMLBibliography, XMLCoordinates, XMLData, XMLDataItem, XMLGalleryData, XMLIdentification, XMLItemLinks, XMLLink, XMLMetadata, XMLNote, XMLPerson, XMLProperty, XMLResource, XMLSetItems, XMLSimplifiedProperty } from "../xml/types.mjs";
+import { Bibliography, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Coordinates, Gallery, Identification, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemContainerCategory, ItemLinks, Metadata, Note, Person, Property, Resource, SetItem, SetItemCategory, SimplifiedProperty, SpatialUnit } from "../types/index.mjs";
+import { XMLBibliography, XMLCoordinates, XMLData, XMLDataItem, XMLGalleryData, XMLIdentification, XMLItemLinks, XMLLink, XMLMetadata, XMLNote, XMLPerson, XMLProperty, XMLResource, XMLSetItems, XMLSimplifiedProperty, XMLSpatialUnit } from "../xml/types.mjs";
 import { ParserOptions, getParserOptions, parseStringLike } from "./helpers.mjs";
 //#region src/parsers/index.d.ts
 export type RawOchre = XMLData["result"]["ochre"];
@@ -22,6 +22,7 @@ export declare function parseBibliographyList<T extends ReadonlyArray<string>>(r
   bibliography: Array<XMLBibliography>;
 } | undefined, options: ParserOptions<T>): Array<Bibliography<T, "embedded">>;
 export declare function parsePersonList<T extends ReadonlyArray<string>>(rawPersons: Array<XMLPerson> | undefined, options: ParserOptions<T>): Array<Person<T, "embedded">>;
+export declare function parseSpatialUnitMapData(mapData: XMLSpatialUnit["mapData"]): SpatialUnit<ReadonlyArray<string>, "embedded">["mapData"];
 export declare function parseMetadata<T extends ReadonlyArray<string>>(rawOchre: {
   uuidBelongsTo: string;
   metadata: XMLMetadata;

package/dist/parsers/index.mjs

@@ -351,13 +351,22 @@ function parseCoordinatesSource(source, options) {
 }
 function parseCoordinate(coordinate, options) {
 	switch (coordinate.type) {
-		case "point": return {
-			type: "point",
-			latitude: coordinate.latitude,
-			longitude: coordinate.longitude,
-			altitude: coordinate.altitude ?? null,
-			source: parseCoordinatesSource(coordinate.source, options)
-		};
+		case "point": {
+			const [x, y, z] = (coordinate.rawValue ?? "").split(",").map((part) => part.trim() === "" ? NaN : Number(part));
+			return {
+				type: "point",
+				latitude: coordinate.latitude,
+				longitude: coordinate.longitude,
+				altitude: coordinate.altitude ?? null,
+				crs: x != null && y != null && coordinate.WKID != null && coordinate.WKID !== 4326 && Number.isFinite(x) && Number.isFinite(y) ? {
+					wkid: coordinate.WKID,
+					x,
+					y,
+					z: z != null && Number.isFinite(z) ? z : null
+				} : null,
+				source: parseCoordinatesSource(coordinate.source, options)
+			};
+		}
 		case "plane": return {
 			type: "plane",
 			minimum: {
@@ -1229,4 +1238,4 @@ function parseItem(rawData, options) {
 	};
 }
 //#endregion
-export { getParserOptions, parseBibliographyList, parseCoordinates, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike };
+export { getParserOptions, parseBibliographyList, parseCoordinates, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseSpatialUnitMapData, parseStringLike };

package/dist/parsers/website/components.mjs

@@ -1,3 +1,4 @@
+import { normalizeItemCategory } from "../../categories.mjs";
 import { componentSchema } from "../../schemas.mjs";
 import { parseXMLContent, transformPermanentIdentificationUrlToItemLink } from "../string.mjs";
 import { parseStringContent } from "../helpers.mjs";
@@ -134,6 +135,8 @@ function parseAdvancedSearchComponent(parameters) {
 	const boundElementPropertyUuid = componentReader.uuid("bound-element");
 	const href = parseWebsiteLinkTarget(componentReader.valueNode("link-to"), pageSlugs);
 	if (boundElementPropertyUuid == null && href == null) throw new Error(formatComponentError("Bound element or href not found", "advanced-search", elementResource), { cause: componentProperty });
+	const prominentPropertyVariable = componentReader.valueNode("prominent-property-variable");
+	if (prominentPropertyVariable != null && (prominentPropertyVariable.uuid == null || normalizeItemCategory(prominentPropertyVariable.category ?? void 0) !== "propertyVariable")) throw new Error(formatComponentError("Prominent property variable must link to a property variable", "advanced-search", elementResource), { cause: prominentPropertyVariable });
 	const filter = { ...ADVANCED_SEARCH_FILTER_DEFAULTS };
 	componentReader.readAll(filter, {
 		sidebarSort: "filter-sidebar-sort",
@@ -144,6 +147,7 @@ function parseAdvancedSearchComponent(parameters) {
 		component: "advanced-search",
 		boundElementUuid: boundElementPropertyUuid,
 		href,
+		prominentPropertyVariableUuid: prominentPropertyVariable?.uuid ?? null,
 		filter,
 		options: parseWebsiteOptions(elementResource.options, options)
 	};
@@ -432,8 +436,9 @@ const MAP_COMPONENT_DEFAULTS = {
 };
 function parseMapComponent(parameters) {
 	const { componentProperty, componentReader, elementResource, websiteLinks } = parameters;
-	const mapLink = findWebsiteLinkByCategories(websiteLinks, ["set", "tree"]);
-	if (mapLink == null) throw new Error(formatComponentError("Map link not found", "map", elementResource), { cause: componentProperty });
+	const linkUuids = [];
+	for (const link of websiteLinks) if (link.category === "set" || link.category === "tree") linkUuids.push(link.uuid);
+	if (linkUuids.length === 0) throw new Error(formatComponentError("Map link not found", "map", elementResource), { cause: componentProperty });
 	const properties = { ...MAP_COMPONENT_DEFAULTS };
 	componentReader.readAll(properties, {
 		isInteractive: "is-interactive",
@@ -452,7 +457,7 @@ function parseMapComponent(parameters) {
 	if (maximumBoundsProperty !== null) maximumBounds = parseBounds(String(maximumBoundsProperty));
 	return {
 		component: "map",
-		linkUuid: mapLink.uuid,
+		linkUuids,
 		boundElementUuid: componentReader.uuid("bound-element"),
 		customBasemap,
 		initialBounds,

package/dist/parsers/website/index.mjs

@@ -1,4 +1,4 @@
-import { cleanObject, parseLicense } from "../helpers.mjs";
+import { cleanObject, parseLicense, parseRequiredContentLike } from "../helpers.mjs";
 import { parseMetadataLanguages, resolveDefaultLanguage, resolveLanguages } from "../languages.mjs";
 import { parseIdentification, parseLinks, parseMetadata, parsePersonList, parseSimplifiedProperties } from "../index.mjs";
 import { findWebsiteLink, parseWebsiteLinkTarget, webImageFromLink } from "./links.mjs";
@@ -306,13 +306,16 @@ function parseWebsite(data, options) {
 	};
 	const websiteTree = rawOchre.tree[0];
 	if (websiteTree == null) throw new Error("Website tree not found", { cause: data });
-	return parseWebsiteTree(websiteTree, parserOptions, {
+	const website = parseWebsiteTree(websiteTree, parserOptions, {
 		belongsTo: {
 			uuid: rawOchre.uuidBelongsTo,
 			abbreviation: rawOchre.belongsTo
 		},
 		metadata: parseMetadata(rawOchre, parserOptions, defaultLanguage)
 	}, "website");
+	const styleLabels = new Map((rawOchre.styleLabels?.styleLabel ?? []).map((styleLabel) => [styleLabel.valueUuid, parseRequiredContentLike(styleLabel, parserOptions)]));
+	for (const stylesheet of website.properties.options.stylesheets.properties) if (stylesheet.category === "propertyValue") stylesheet.label = styleLabels.get(stylesheet.uuid) ?? null;
+	return website;
 }
 //#endregion
 export { parseWebpageView, parseWebsite };

package/dist/parsers/website/styles.d.mts

@@ -1,5 +1,5 @@
 import { ResponsiveStyles, StylesheetItem } from "../../types/website.mjs";
-import { SimplifiedProperty } from "../../types/index.mjs";
+import { LanguageCodes, SimplifiedProperty } from "../../types/index.mjs";
 import { XMLWebsiteStyle } from "../../xml/types.mjs";
 //#region src/parsers/website/styles.d.ts
 /**
@@ -24,5 +24,5 @@ export declare function emptyResponsiveStyles(): ResponsiveStyles;
  * @returns The parsed stylesheet items
  * @internal
  */
-export declare function parseStylesheets(styles: Array<XMLWebsiteStyle>): Array<StylesheetItem>;
+export declare function parseStylesheets<T extends LanguageCodes>(styles: Array<XMLWebsiteStyle>): Array<StylesheetItem<T>>;
 //#endregion

package/dist/parsers/website/styles.mjs

@@ -85,6 +85,7 @@ function parseStylesheets(styles) {
 				uuid: style.valueUuid,
 				category: "propertyValue",
 				variableUuid: style.variableUuid,
+				label: null,
 				icon: style.lucideIcon ?? null,
 				styles: stylesByViewport
 			});

package/dist/schemas.d.mts

@@ -100,15 +100,24 @@ export declare const setItemsParametersSchema: v.ObjectSchema<{
   readonly setScopeUuids: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, v.MinLengthAction<string[], 1, "At least one set scope UUID is required">]>;
 }, undefined>;
 /**
- * Schema for validating the parameters of the Set item locations fetching function
+ * Schema for validating the parameters of the item locations fetching function
  * @internal
  */
-export declare const setItemLocationsParametersSchema: v.ObjectSchema<{
-  readonly setScopeUuids: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, v.MinLengthAction<string[], 1, "At least one set scope UUID is required">]>;
+export declare const itemLocationsParametersSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly setScopeUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
+  readonly treeScopeUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
   readonly belongsToCollectionScopeUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
   readonly queries: v.OptionalSchema<v.NullableSchema<v.GenericSchema<unknown, Query>, undefined>, null>;
   readonly propertyVariableUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
-}, undefined>;
+  readonly isMapDataIncluded: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+}, undefined>, v.CheckAction<{
+  setScopeUuids: string[];
+  treeScopeUuids: string[];
+  belongsToCollectionScopeUuids: string[];
+  queries: Query | null;
+  propertyVariableUuids: string[];
+  isMapDataIncluded: boolean;
+}, "At least one Set or Tree scope UUID is required">]>;
 export declare const treeItemsParametersSchema: v.ObjectSchema<{
   readonly belongsToCollectionScopeUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
   readonly queries: v.OptionalSchema<v.NullableSchema<v.GenericSchema<unknown, Query>, undefined>, null>;