ochre-sdk 1.3.5 → 1.3.6

package/dist/parsers/multilingual.d.mts

@@ -19,6 +19,13 @@ export type MultilingualStringInput = string | {
 export type MultilingualStringJSON<T extends ReadonlyArray<string> = ReadonlyArray<string>> = {
   content: Partial<Record<T[number], Array<MultilingualStringEntry>>>;
   aliases: Array<string>;
+  /**
+   * Text in no language, read from `zxx` content that has no other language
+   * beside it
+   *
+   * Optional so payloads written before it existed still parse.
+   */
+  nonLinguistic?: Array<MultilingualStringEntry>;
   /**
    * The language reads fall back to first
    *
@@ -42,17 +49,25 @@ export type MultilingualOptions = {
     */
   availableLanguages?: ReadonlyArray<string>;
   /**
-    Alias values carried by OCHRE as zxx content
+    Alternative names, which OCHRE publishes as zxx content beside a field's
+    languages
     */
   aliases?: ReadonlyArray<string>;
+  /**
+    Text in no language, such as an identifier or a code, which OCHRE publishes
+    as zxx content with no other language beside it
+    */
+  nonLinguistic?: ReadonlyArray<MultilingualStringInput>;
 };
+type StoredOptions = Required<Omit<MultilingualOptions, "nonLinguistic">>;
 type MultilingualContent<T extends ReadonlyArray<string>> = Partial<Record<T[number], ReadonlyArray<MultilingualStringEntry>>>;
 declare const MULTILINGUAL_STRING_INTERNAL_INIT: unique symbol;
 type MultilingualStringInternalInit<T extends ReadonlyArray<string>> = {
   readonly [MULTILINGUAL_STRING_INTERNAL_INIT]: true;
   content: MultilingualContent<T>;
-  options: Required<MultilingualOptions>;
+  options: StoredOptions;
   availableLanguages: ReadonlyArray<T[number]>;
+  nonLinguistic: ReadonlyArray<MultilingualStringEntry>;
 };
 /**
  * Multilingual string
@@ -82,12 +97,13 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
   /**
    * Recreate a multilingual string from its JSON representation.
    */
-  static fromJSON<U extends ReadonlyArray<string>>(json: MultilingualStringJSON<U>, languages: U, options?: Omit<MultilingualOptions, "aliases">): MultilingualString<U>;
-  static fromJSON(json: MultilingualStringJSON, languages?: undefined, options?: Omit<MultilingualOptions, "aliases">): MultilingualString<ReadonlyArray<string>>;
+  static fromJSON<U extends ReadonlyArray<string>>(json: MultilingualStringJSON<U>, languages: U, options?: Omit<MultilingualOptions, "aliases" | "nonLinguistic">): MultilingualString<U>;
+  static fromJSON(json: MultilingualStringJSON, languages?: undefined, options?: Omit<MultilingualOptions, "aliases" | "nonLinguistic">): MultilingualString<ReadonlyArray<string>>;
   private readonly _content;
   private readonly _options;
   private readonly _availableLanguages;
   private readonly _aliases;
+  private readonly _nonLinguistic;
   /**
    * Create a new multilingual string from an object of language codes to text.
    */
@@ -103,6 +119,8 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
    * The fallback order is requested language, then the dataset's default
    * language, then the first language that has any content. This is the only
    * place that order is written down; every reader below is a projection of it.
+   * Non-linguistic text is the same in every language, so it answers every
+   * read, exact ones included.
    */
   private resolveEntries;
   private resolvePrimaryEntry;
@@ -150,11 +168,17 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
    */
   getExactTexts(language: T[number]): Array<string>;
   /**
-   * Get the alias values OCHRE carries as `zxx` content
+   * Get the alternative names OCHRE publishes as `zxx` content beside the
+   * string's languages
+   *
+   * A non-linguistic string has none: its `zxx` content is the text itself.
    */
   getAliases(): Array<string>;
   /**
-   * Get the languages that actually carry content
+   * Get the languages that carry language-specific content
+   *
+   * A non-linguistic string has none, although every language reads its text;
+   * {@link MultilingualString.isNonLinguistic} tells the two apart.
    */
   getAvailableLanguages(): Array<T[number]>;
   /**
@@ -175,11 +199,22 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
    *
    * Answers the structural question. A language whose only entry is blank
    * still counts here; {@link MultilingualString.hasContent} is the question
-   * about text. Aliases are not entries, so a string carrying only aliases is
-   * empty by this measure and {@link MultilingualString.hasAliases} is true.
-   * @returns True when no language carries an entry
+   * about text. Non-linguistic text counts as an entry; aliases never stand
+   * without one, since `zxx` content alone is read as non-linguistic text.
+   * @returns True when no language carries an entry and there is no
+   * non-linguistic text
    */
   isEmpty(): boolean;
+  /**
+   * Whether the string is text in no language, such as an identifier or a code
+   *
+   * OCHRE publishes this as `zxx` content with no other language beside it.
+   * Its text answers every language, so a caller that needs to know whether
+   * text was written in a language, to set an HTML `lang` attribute or to
+   * leave it out of a translation check, asks this.
+   * @returns True when the string holds non-linguistic text
+   */
+  isNonLinguistic(): boolean;
   /**
    * Whether any entry in any language carries text that is not whitespace
    *
@@ -191,13 +226,16 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
    */
   hasContent(): boolean;
   /**
-   * Whether a specific language carries an entry, with no fallback
+   * Whether a specific language reads an entry, with no fallback
+   *
+   * True for every language when the string is non-linguistic, matching the
+   * exact readers, which return non-linguistic text for any language.
    * @param language - The language to test
    * @returns True when that language carries at least one entry
    */
   hasLanguage(language: T[number]): boolean;
   /**
-   * Whether OCHRE carried any `zxx` alias values for this string
+   * Whether OCHRE published any alternative names for this string
    * @returns True when there is at least one alias
    */
   hasAliases(): boolean;
@@ -224,9 +262,11 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
   /**
    * Replace the alias values
    *
-   * Aliases are the `zxx` content OCHRE carries alongside a field's languages,
+   * Aliases are the `zxx` content OCHRE publishes beside a field's languages,
    * so they are set as a whole rather than per language. Empty strings are
-   * dropped, matching how they are read from a payload.
+   * dropped, matching how they are read from a payload, and on a string with
+   * no language they become its non-linguistic text, as the same content
+   * would be read.
    * @param aliases - The aliases to carry
    * @returns A new multilingual string
    */
@@ -243,10 +283,11 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
    *
    * A transform that needs to keep or rewrite markup returns
    * `{ text, richText }` instead of a string, and both are used verbatim.
+   * Non-linguistic text is transformed too, with `null` as its language.
    * @param transform - Produces the new text for one entry
    * @returns A new multilingual string
    */
-  mapText(transform: (text: string, language: T[number]) => MultilingualStringInput): MultilingualString<T>;
+  mapText(transform: (text: string, language: T[number] | null) => MultilingualStringInput): MultilingualString<T>;
   /**
    * Keep only the entries a predicate accepts
    *
@@ -254,11 +295,12 @@ export declare class MultilingualString<T extends ReadonlyArray<string> = Readon
    * can also test `richText` and `isPrimary`. Dropping every entry of a
    * language removes that language, and when that was the default the default
    * moves to the first language that still has content, so reads keep
-   * resolving.
+   * resolving. Non-linguistic entries are tested too, with `null` as their
+   * language.
    * @param shouldKeep - Whether to keep one entry
    * @returns A new multilingual string
    */
-  filterEntries(shouldKeep: (entry: MultilingualStringEntry, language: T[number]) => boolean): MultilingualString<T>;
+  filterEntries(shouldKeep: (entry: MultilingualStringEntry, language: T[number] | null) => boolean): MultilingualString<T>;
   /**
    * Get the JSON representation
    *

package/dist/parsers/multilingual.mjs

@@ -18,6 +18,28 @@ function normalizeAliases(aliases) {
 	for (const alias of candidateAliases) if (alias !== "") normalizedAliases.push(alias);
 	return normalizedAliases;
 }
+/**
+* Apply the rule OCHRE publishes `zxx` content by
+*
+* `zxx` content beside a field's languages names the same thing again, so it
+* is aliases; `zxx` content with no language beside it is the text itself,
+* in no language. Normalizing every string through this keeps the two
+* readings from ever coexisting, whichever way a string was built or edited.
+* @param hasLanguages - Whether any language carries an entry
+* @param aliases - The aliases the string would carry
+* @param nonLinguistic - The non-linguistic entries the string would carry
+* @returns The aliases and non-linguistic entries to store
+*/
+function normalizeUntaggedText(hasLanguages, aliases, nonLinguistic) {
+	if (hasLanguages) return {
+		aliases: normalizeAliases([...aliases, ...Array.from(nonLinguistic, (entry) => entry.text)]),
+		nonLinguistic: []
+	};
+	return {
+		aliases: [],
+		nonLinguistic: normalizePrimary([...nonLinguistic, ...entriesFromTexts(normalizeAliases(aliases))])
+	};
+}
 function entriesFromTexts(texts) {
 	const entries = [];
 	for (const text of texts) entries.push({
@@ -84,12 +106,17 @@ function isInternalInit(value) {
 * Multilingual string
 */
 var MultilingualString = class MultilingualString {
-	static fromNormalized(content, options, availableLanguages) {
+	static fromNormalized(content, options, availableLanguages, nonLinguistic) {
+		const untaggedText = normalizeUntaggedText(availableLanguages.length > 0, options.aliases, nonLinguistic);
 		return new MultilingualString({
 			[MULTILINGUAL_STRING_INTERNAL_INIT]: true,
 			content,
-			options,
-			availableLanguages
+			options: {
+				...options,
+				aliases: untaggedText.aliases
+			},
+			availableLanguages,
+			nonLinguistic: untaggedText.nonLinguistic
 		});
 	}
 	static fromObject(content, languages, options = {}) {
@@ -109,7 +136,7 @@ var MultilingualString = class MultilingualString {
 				availableLanguages: actualLanguages,
 				aliases: normalizeAliases(options.aliases)
 			};
-			return this.fromNormalized(normalizedContent, defaultOptions, availableLanguages);
+			return this.fromNormalized(normalizedContent, defaultOptions, availableLanguages, entriesFromTexts(options.nonLinguistic ?? []));
 		}
 		const normalizedContent = {};
 		for (const language of languages) {
@@ -122,7 +149,7 @@ var MultilingualString = class MultilingualString {
 			availableLanguages: languages,
 			aliases: normalizeAliases(options.aliases)
 		};
-		return this.fromNormalized(normalizedContent, defaultOptions, availableLanguages);
+		return this.fromNormalized(normalizedContent, defaultOptions, availableLanguages, entriesFromTexts(options.nonLinguistic ?? []));
 	}
 	static create(language, text, languages, options = {}) {
 		if (languages === void 0) return this.fromObject({ [language]: text }, void 0, {
@@ -143,7 +170,8 @@ var MultilingualString = class MultilingualString {
 		const mergedOptions = {
 			defaultLanguage: json.defaultLanguage,
 			...options,
-			aliases: json.aliases
+			aliases: json.aliases,
+			nonLinguistic: json.nonLinguistic
 		};
 		if (languages === void 0) return this.fromEntries(content, void 0, mergedOptions);
 		return this.fromEntries(content, languages, mergedOptions);
@@ -152,12 +180,14 @@ var MultilingualString = class MultilingualString {
 	_options;
 	_availableLanguages;
 	_aliases;
+	_nonLinguistic;
 	constructor(content = {}, languages, options = {}) {
 		if (isInternalInit(content)) {
 			this._content = Object.freeze(cloneContent(content.content));
 			this._options = Object.freeze({ ...content.options });
 			this._availableLanguages = Object.freeze([...content.availableLanguages]);
 			this._aliases = Object.freeze([...content.options.aliases]);
+			this._nonLinguistic = Object.freeze(normalizePrimary(content.nonLinguistic));
 			return;
 		}
 		const parsed = languages === void 0 ? MultilingualString.fromObject(content, void 0, options) : MultilingualString.fromObject(content, languages, options);
@@ -165,6 +195,7 @@ var MultilingualString = class MultilingualString {
 		this._options = parsed._options;
 		this._availableLanguages = parsed._availableLanguages;
 		this._aliases = parsed._aliases;
+		this._nonLinguistic = parsed._nonLinguistic;
 	}
 	/**
 	* Resolve the entries to read for a language
@@ -172,6 +203,8 @@ var MultilingualString = class MultilingualString {
 	* The fallback order is requested language, then the dataset's default
 	* language, then the first language that has any content. This is the only
 	* place that order is written down; every reader below is a projection of it.
+	* Non-linguistic text is the same in every language, so it answers every
+	* read, exact ones included.
 	*/
 	resolveEntries(language, isExact) {
 		const candidateLanguages = isExact ? [language] : [
@@ -184,7 +217,7 @@ var MultilingualString = class MultilingualString {
 			const entries = this._content[candidateLanguage] ?? [];
 			if (entries.length > 0) return entries;
 		}
-		return [];
+		return this._nonLinguistic;
 	}
 	resolvePrimaryEntry(language, isExact) {
 		const entries = this.resolveEntries(language, isExact);
@@ -251,13 +284,19 @@ var MultilingualString = class MultilingualString {
 		return Array.from(this.resolveEntries(language, true), (entry) => entry.text);
 	}
 	/**
-	* Get the alias values OCHRE carries as `zxx` content
+	* Get the alternative names OCHRE publishes as `zxx` content beside the
+	* string's languages
+	*
+	* A non-linguistic string has none: its `zxx` content is the text itself.
 	*/
 	getAliases() {
 		return [...this._aliases];
 	}
 	/**
-	* Get the languages that actually carry content
+	* Get the languages that carry language-specific content
+	*
+	* A non-linguistic string has none, although every language reads its text;
+	* {@link MultilingualString.isNonLinguistic} tells the two apart.
 	*/
 	getAvailableLanguages() {
 		return [...this._availableLanguages];
@@ -284,12 +323,25 @@ var MultilingualString = class MultilingualString {
 	*
 	* Answers the structural question. A language whose only entry is blank
 	* still counts here; {@link MultilingualString.hasContent} is the question
-	* about text. Aliases are not entries, so a string carrying only aliases is
-	* empty by this measure and {@link MultilingualString.hasAliases} is true.
-	* @returns True when no language carries an entry
+	* about text. Non-linguistic text counts as an entry; aliases never stand
+	* without one, since `zxx` content alone is read as non-linguistic text.
+	* @returns True when no language carries an entry and there is no
+	* non-linguistic text
 	*/
 	isEmpty() {
-		return this._availableLanguages.length === 0;
+		return this._availableLanguages.length === 0 && this._nonLinguistic.length === 0;
+	}
+	/**
+	* Whether the string is text in no language, such as an identifier or a code
+	*
+	* OCHRE publishes this as `zxx` content with no other language beside it.
+	* Its text answers every language, so a caller that needs to know whether
+	* text was written in a language, to set an HTML `lang` attribute or to
+	* leave it out of a translation check, asks this.
+	* @returns True when the string holds non-linguistic text
+	*/
+	isNonLinguistic() {
+		return this._nonLinguistic.length > 0;
 	}
 	/**
 	* Whether any entry in any language carries text that is not whitespace
@@ -305,18 +357,22 @@ var MultilingualString = class MultilingualString {
 			const entries = this._content[language] ?? [];
 			for (const entry of entries) if (entry.text.trim() !== "") return true;
 		}
+		for (const entry of this._nonLinguistic) if (entry.text.trim() !== "") return true;
 		return false;
 	}
 	/**
-	* Whether a specific language carries an entry, with no fallback
+	* Whether a specific language reads an entry, with no fallback
+	*
+	* True for every language when the string is non-linguistic, matching the
+	* exact readers, which return non-linguistic text for any language.
 	* @param language - The language to test
 	* @returns True when that language carries at least one entry
 	*/
 	hasLanguage(language) {
-		return (this._content[language]?.length ?? 0) > 0;
+		return (this._content[language]?.length ?? 0) > 0 || this._nonLinguistic.length > 0;
 	}
 	/**
-	* Whether OCHRE carried any `zxx` alias values for this string
+	* Whether OCHRE published any alternative names for this string
 	* @returns True when there is at least one alias
 	*/
 	hasAliases() {
@@ -336,7 +392,7 @@ var MultilingualString = class MultilingualString {
 			...normalizeInputText(text),
 			isPrimary: false
 		}]) : entriesFromTexts([text]);
-		return MultilingualString.fromNormalized(newContent, this._options, getLanguagesWithEntries(newContent, this._options.availableLanguages));
+		return MultilingualString.fromNormalized(newContent, this._options, getLanguagesWithEntries(newContent, this._options.availableLanguages), this._nonLinguistic);
 	}
 	/**
 	* Remove the content for a language
@@ -354,14 +410,16 @@ var MultilingualString = class MultilingualString {
 		return MultilingualString.fromNormalized(newContent, {
 			...this._options,
 			defaultLanguage: this._options.defaultLanguage === language ? resolveDefaultLanguageOption(newAvailableLanguages, this._options.availableLanguages) : this._options.defaultLanguage
-		}, newAvailableLanguages);
+		}, newAvailableLanguages, this._nonLinguistic);
 	}
 	/**
 	* Replace the alias values
 	*
-	* Aliases are the `zxx` content OCHRE carries alongside a field's languages,
+	* Aliases are the `zxx` content OCHRE publishes beside a field's languages,
 	* so they are set as a whole rather than per language. Empty strings are
-	* dropped, matching how they are read from a payload.
+	* dropped, matching how they are read from a payload, and on a string with
+	* no language they become its non-linguistic text, as the same content
+	* would be read.
 	* @param aliases - The aliases to carry
 	* @returns A new multilingual string
 	*/
@@ -369,7 +427,7 @@ var MultilingualString = class MultilingualString {
 		return MultilingualString.fromNormalized(cloneContent(this._content), {
 			...this._options,
 			aliases: normalizeAliases(aliases)
-		}, this._availableLanguages);
+		}, this._availableLanguages, this._nonLinguistic);
 	}
 	/**
 	* Transform the text of every entry in every language
@@ -383,6 +441,7 @@ var MultilingualString = class MultilingualString {
 	*
 	* A transform that needs to keep or rewrite markup returns
 	* `{ text, richText }` instead of a string, and both are used verbatim.
+	* Non-linguistic text is transformed too, with `null` as its language.
 	* @param transform - Produces the new text for one entry
 	* @returns A new multilingual string
 	*/
@@ -395,7 +454,10 @@ var MultilingualString = class MultilingualString {
 				isPrimary: entry.isPrimary
 			})));
 		}
-		return MultilingualString.fromNormalized(newContent, this._options, this._availableLanguages);
+		return MultilingualString.fromNormalized(newContent, this._options, this._availableLanguages, Array.from(this._nonLinguistic, (entry) => ({
+			...normalizeInputText(transform(entry.text, null)),
+			isPrimary: entry.isPrimary
+		})));
 	}
 	/**
 	* Keep only the entries a predicate accepts
@@ -404,7 +466,8 @@ var MultilingualString = class MultilingualString {
 	* can also test `richText` and `isPrimary`. Dropping every entry of a
 	* language removes that language, and when that was the default the default
 	* moves to the first language that still has content, so reads keep
-	* resolving.
+	* resolving. Non-linguistic entries are tested too, with `null` as their
+	* language.
 	* @param shouldKeep - Whether to keep one entry
 	* @returns A new multilingual string
 	*/
@@ -420,7 +483,7 @@ var MultilingualString = class MultilingualString {
 		return MultilingualString.fromNormalized(newContent, {
 			...this._options,
 			defaultLanguage: newAvailableLanguages.includes(this._options.defaultLanguage) ? this._options.defaultLanguage : resolveDefaultLanguageOption(newAvailableLanguages, this._options.availableLanguages)
-		}, newAvailableLanguages);
+		}, newAvailableLanguages, this._nonLinguistic.filter((entry) => shouldKeep({ ...entry }, null)));
 	}
 	/**
 	* Get the JSON representation
@@ -435,6 +498,7 @@ var MultilingualString = class MultilingualString {
 		return {
 			content,
 			aliases: this.getAliases(),
+			nonLinguistic: Array.from(this._nonLinguistic, (entry) => ({ ...entry })),
 			defaultLanguage: this._options.defaultLanguage
 		};
 	}

package/dist/parsers/string.d.mts

@@ -37,6 +37,9 @@ export declare function parseXMLContent<V extends ReadonlyArray<string>>(item: X
 }): MultilingualString<V>;
 /**
  * Extracts alias strings from XMLContent where lang="zxx"
+ *
+ * They are aliases only beside another language; parseXMLContent reads
+ * `zxx` content standing alone as non-linguistic text instead.
  * @param content - The XMLContent to extract aliases from
  * @returns Array of alias strings, or null if none found
  *

package/dist/parsers/string.mjs

@@ -459,8 +459,10 @@ function parseXMLContent(item, options) {
 			defaultLanguage: options.defaultLanguage
 		});
 	}
+	const nonLinguistic = [];
+	for (const contentItem of item.content) if (contentItem.lang === "zxx") nonLinguistic.push(parseXMLContentItem(contentItem, { languages: ["zxx"] }));
 	return MultilingualString.empty(languages, {
-		aliases,
+		nonLinguistic,
 		defaultLanguage: options.defaultLanguage
 	});
 }
@@ -487,6 +489,9 @@ function parseXMLContentItem(contentItem, options) {
 }
 /**
 * Extracts alias strings from XMLContent where lang="zxx"
+*
+* They are aliases only beside another language; parseXMLContent reads
+* `zxx` content standing alone as non-linguistic text instead.
 * @param content - The XMLContent to extract aliases from
 * @returns Array of alias strings, or null if none found
 *

package/dist/schemas.d.mts

@@ -14,10 +14,13 @@ export declare function isPseudoUuid(value: string): boolean;
  */
 export declare const uuidSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>;
 /**
- * Schema for validating language codes
+ * Schema for validating OCHRE language codes
+ *
+ * Rejects standard codes OCHRE does not store, naming the OCHRE code to use
+ * instead (`per` for ISO 639-3 `fas`).
  * @internal
  */
-export declare const iso639_3Schema: v.SchemaWithPipe<readonly [v.StringSchema<"Language code must be a string">, v.RegexAction<string, "Language code must be exactly 3 lowercase letters">]>;
+export declare const ochreLanguageCodeSchema: v.SchemaWithPipe<readonly [v.StringSchema<"Language code must be a string">, v.CheckAction<string, (issue: v.CheckIssue<string>) => string>]>;
 /**
  * Valid component types for web elements
  * @internal

package/dist/schemas.mjs

@@ -1,4 +1,5 @@
 import "./constants.mjs";
+import { getOchreLanguageCode, isOchreLanguageCode } from "./languages.mjs";
 import * as v from "valibot";
 //#region src/schemas.ts
 const PSEUDO_UUID_REGEX = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i;
@@ -21,10 +22,17 @@ const sortDirectionSchema = v.optional(v.picklist(["asc", "desc"]), "asc");
 */
 const uuidSchema = v.pipe(v.string(), v.check(isPseudoUuid, "Invalid pseudo-UUID"));
 /**
-* Schema for validating language codes
+* Schema for validating OCHRE language codes
+*
+* Rejects standard codes OCHRE does not store, naming the OCHRE code to use
+* instead (`per` for ISO 639-3 `fas`).
 * @internal
 */
-const iso639_3Schema = v.pipe(v.string("Language code must be a string"), v.regex(/^[a-z]{3}$/, "Language code must be exactly 3 lowercase letters"));
+const ochreLanguageCodeSchema = v.pipe(v.string("Language code must be a string"), v.check(isOchreLanguageCode, (issue) => {
+	const input = issue.input;
+	const ochreCode = getOchreLanguageCode(input);
+	return ochreCode == null ? `Unknown OCHRE language code "${input}"` : `Unknown OCHRE language code "${input}"; OCHRE stores this language as "${ochreCode}"`;
+}));
 /**
 * Valid component types for web elements
 * @internal
@@ -281,4 +289,4 @@ const treeItemsParametersSchema = v.object({
 	...containerItemsParametersEntries
 });
 //#endregion
-export { componentSchema, gallerySchema, isPseudoUuid, iso639_3Schema, itemOcrDataParametersSchema, renderOptionsSchema, setItemLocationsParametersSchema, setItemsParametersSchema, setPropertyValuesParametersSchema, treeItemsParametersSchema, uuidSchema };
+export { componentSchema, gallerySchema, isPseudoUuid, itemOcrDataParametersSchema, ochreLanguageCodeSchema, renderOptionsSchema, setItemLocationsParametersSchema, setItemsParametersSchema, setPropertyValuesParametersSchema, treeItemsParametersSchema, uuidSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "1.3.5",
+  "version": "1.3.6",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",