ochre-sdk 1.0.13 → 1.0.14

package/dist/parsers/mdx.d.mts

@@ -0,0 +1,4 @@
+//#region src/parsers/mdx.d.ts
+declare function serializeMDXText(value: string): string;
+//#endregion
+export { serializeMDXText };

package/dist/parsers/mdx.mjs

@@ -0,0 +1,9 @@
+//#region src/parsers/mdx.ts
+const MDX_LITERAL_EXPRESSION_REGEX = /[!#*<>[\]_`{|}~]/;
+const MDX_LITERAL_BLOCK_REGEX = /(?:^|\n)[\t ]*(?:import|export|[+>-]|\d+[).])(?:[\t ]|$)/;
+function serializeMDXText(value) {
+	if (value === "" || !MDX_LITERAL_EXPRESSION_REGEX.test(value) && !MDX_LITERAL_BLOCK_REGEX.test(value)) return value;
+	return `{${JSON.stringify(value)}}`;
+}
+//#endregion
+export { serializeMDXText };

package/dist/parsers/multilingual.d.mts

@@ -0,0 +1,189 @@
+//#region src/parsers/multilingual.d.ts
+/**
+ * One text entry for a language. When OCHRE exposes multiple entries for the
+ * same language, the first one is primary.
+ */
+type MultilingualStringEntry = {
+  text: string;
+  richText: string;
+  isPrimary: boolean;
+};
+type MultilingualStringText = {
+  text: string;
+  richText: string;
+};
+type MultilingualStringInput = string | {
+  text: string;
+  richText?: string;
+};
+type MultilingualStringJSON<T extends ReadonlyArray<string> = ReadonlyArray<string>> = {
+  content: Partial<Record<T[number], Array<MultilingualStringEntry>>>;
+  aliases: Array<string>;
+};
+type MultilingualStringObject<T extends ReadonlyArray<string> = ReadonlyArray<string>> = Partial<Record<T[number], MultilingualStringInput>>;
+type MultilingualStringEntries<T extends ReadonlyArray<string> = ReadonlyArray<string>> = Partial<Record<T[number], ReadonlyArray<MultilingualStringInput>>>;
+/**
+ * Options for creating and working with multilingual strings
+ */
+type MultilingualOptions = {
+  /** Default language to use for fallbacks */defaultLanguage?: string; /** Available languages for this string */
+  availableLanguages?: ReadonlyArray<string>; /** Alias values carried by OCHRE as zxx content */
+  aliases?: ReadonlyArray<string>;
+};
+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>;
+  availableLanguages: ReadonlyArray<T[number]>;
+};
+/**
+ * Multilingual string
+ */
+declare class MultilingualString<T extends ReadonlyArray<string> = ReadonlyArray<string>> {
+  private readonly _content;
+  private readonly _options;
+  private readonly _availableLanguages;
+  private readonly _aliases;
+  /**
+   * Create a new multilingual string from an object of language codes to text.
+   */
+  /** @internal */
+  constructor(init: MultilingualStringInternalInit<T>);
+  constructor(content: MultilingualStringObject<T>, languages: T, options?: MultilingualOptions);
+  constructor(content?: Partial<Record<string, MultilingualStringInput>>, languages?: undefined, options?: MultilingualOptions);
+  private static fromNormalized;
+  /**
+   * Create a new multilingual string from an object of language codes to text
+   */
+  static fromObject<U extends ReadonlyArray<string>>(content: MultilingualStringObject<U>, languages: U, options?: MultilingualOptions): MultilingualString<U>;
+  static fromObject(content: Partial<Record<string, MultilingualStringInput>>, languages?: undefined, options?: MultilingualOptions): MultilingualString<ReadonlyArray<string>>;
+  /**
+   * Create a new multilingual string from language entries.
+   */
+  static fromEntries<U extends ReadonlyArray<string>>(content: MultilingualStringEntries<U>, languages: U, options?: MultilingualOptions): MultilingualString<U>;
+  static fromEntries(content: Partial<Record<string, ReadonlyArray<MultilingualStringInput>>>, languages?: undefined, options?: MultilingualOptions): MultilingualString<ReadonlyArray<string>>;
+  /**
+   * Create a new multilingual string for a single language
+   */
+  static create<U extends ReadonlyArray<string>>(language: U[number], text: MultilingualStringInput, languages: U, options?: MultilingualOptions): MultilingualString<U>;
+  static create(language: string, text: MultilingualStringInput, languages?: undefined, options?: MultilingualOptions): MultilingualString<ReadonlyArray<string>>;
+  /**
+   * Create an empty multilingual string
+   */
+  static empty<U extends ReadonlyArray<string>>(languages: U, options?: MultilingualOptions): MultilingualString<U>;
+  static empty(languages?: undefined, options?: MultilingualOptions): MultilingualString<ReadonlyArray<string>>;
+  /**
+   * 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>>;
+  private getPrimaryEntry;
+  /**
+   * Get text in a specific language with automatic fallback
+   */
+  getText(language?: T[number]): string;
+  /**
+   * Get rich text in a specific language with automatic fallback
+   */
+  getRichText(language?: T[number]): string;
+  /**
+   * Get primary text in a specific language without fallback
+   */
+  getExactText(language: T[number]): string | null;
+  /**
+   * Get primary rich text in a specific language without fallback
+   */
+  getExactRichText(language: T[number]): string | null;
+  /**
+   * Get all text entries in a specific language without fallback
+   */
+  getExactTexts(language: T[number]): Array<string>;
+  /**
+   * Get all rich text entries in a specific language without fallback
+   */
+  getExactRichTexts(language: T[number]): Array<string>;
+  /**
+   * Get all text entries in a specific language with fallback
+   */
+  getTexts(language?: T[number]): Array<string>;
+  /**
+   * Get all rich text entries in a specific language with fallback
+   */
+  getRichTexts(language?: T[number]): Array<string>;
+  /**
+   * Get all entries in a specific language without fallback
+   */
+  getExactEntries(language: T[number]): Array<MultilingualStringEntry>;
+  /**
+   * Get all entries in a specific language with fallback
+   */
+  getEntries(language?: T[number]): Array<MultilingualStringEntry>;
+  /**
+   * Get aliases carried by OCHRE as zxx content
+   */
+  getAliases(): Array<string>;
+  /**
+   * Check if text exists for a specific language
+   */
+  hasLanguage(language: T[number]): boolean;
+  /**
+   * Check if aliases exist
+   */
+  hasAliases(): boolean;
+  /**
+   * Get all available languages
+   */
+  getAvailableLanguages(): ReadonlyArray<T[number]>;
+  /**
+   * Get all supported languages (the full language array passed to constructor)
+   */
+  getSupportedLanguages(): T;
+  /**
+   * Check if the multilingual string is empty (no content in any language)
+   */
+  isEmpty(): boolean;
+  /**
+   * Check if the multilingual string has any content
+   */
+  hasContent(): boolean;
+  /**
+   * Get the default language
+   */
+  getDefaultLanguage(): T[number];
+  /**
+   * Add or update the primary text for a language (returns new instance)
+   */
+  withText(language: T[number], text: MultilingualStringInput): MultilingualString<T>;
+  /**
+   * Add another text entry for a language (returns new instance)
+   */
+  withEntry(language: T[number], text: MultilingualStringInput): MultilingualString<T>;
+  /**
+   * Replace aliases (returns new instance)
+   */
+  withAliases(aliases: ReadonlyArray<string>): MultilingualString<T>;
+  /**
+   * Remove text for a language (returns new instance)
+   */
+  withoutLanguage(language: T[number]): MultilingualString<T>;
+  /**
+   * Transform all language versions (returns new instance)
+   */
+  map(fn: (text: string, language: T[number]) => string): MultilingualString<T>;
+  /**
+   * Filter languages based on predicate (returns new instance)
+   */
+  filter(predicate: (text: string, language: T[number]) => boolean): MultilingualString<T>;
+  /**
+   * Get the string representation (uses default language)
+   */
+  toString(): string;
+  /**
+   * Get JSON representation
+   */
+  toJSON(): MultilingualStringJSON<T>;
+}
+//#endregion
+export { MultilingualOptions, MultilingualString, MultilingualStringEntries, MultilingualStringEntry, MultilingualStringInput, MultilingualStringJSON, MultilingualStringObject, MultilingualStringText };

package/dist/parsers/multilingual.mjs

@@ -0,0 +1,410 @@
+import { DEFAULT_LANGUAGES } from "../constants.mjs";
+import { serializeMDXText } from "./mdx.mjs";
+//#region src/parsers/multilingual.ts
+const MULTILINGUAL_STRING_INTERNAL_INIT = Symbol("MultilingualString.internalInit");
+function normalizeInputText(text) {
+	return typeof text === "string" ? {
+		text,
+		richText: serializeMDXText(text)
+	} : {
+		text: text.text,
+		richText: text.richText ?? serializeMDXText(text.text)
+	};
+}
+function normalizeAliases(aliases) {
+	const normalizedAliases = [];
+	for (const alias of aliases ?? []) if (alias !== "") normalizedAliases.push(alias);
+	return normalizedAliases;
+}
+function entriesFromTexts(texts) {
+	const entries = [];
+	for (const text of texts) entries.push({
+		...normalizeInputText(text),
+		isPrimary: entries.length === 0
+	});
+	return entries;
+}
+function cloneContent(content) {
+	const clonedContent = {};
+	const entriesByLanguage = Object.entries(content);
+	for (const [language, entries] of entriesByLanguage) {
+		const clonedEntries = [];
+		for (const entry of entries ?? []) clonedEntries.push({
+			text: entry.text,
+			richText: entry.richText,
+			isPrimary: entry.isPrimary
+		});
+		clonedContent[language] = normalizePrimary(clonedEntries);
+	}
+	return clonedContent;
+}
+function normalizePrimary(entries) {
+	const normalizedEntries = [];
+	for (const entry of entries) normalizedEntries.push({
+		text: entry.text,
+		richText: entry.richText,
+		isPrimary: normalizedEntries.length === 0
+	});
+	return normalizedEntries;
+}
+function getLanguagesWithEntries(content, languages) {
+	const availableLanguages = [];
+	for (const language of languages) if ((content[language]?.length ?? 0) > 0) availableLanguages.push(language);
+	return availableLanguages;
+}
+function getImplicitLanguages(content, options) {
+	const languages = [];
+	for (const language of options.availableLanguages ?? []) if (!languages.includes(language)) languages.push(language);
+	for (const language of Object.keys(content)) if (!languages.includes(language)) languages.push(language);
+	return languages.length > 0 ? languages : [...DEFAULT_LANGUAGES];
+}
+function isInternalInit(value) {
+	return typeof value === "object" && value != null && MULTILINGUAL_STRING_INTERNAL_INIT in value;
+}
+/**
+* Multilingual string
+*/
+var MultilingualString = class MultilingualString {
+	_content;
+	_options;
+	_availableLanguages;
+	_aliases;
+	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]);
+			return;
+		}
+		const parsed = languages === void 0 ? MultilingualString.fromObject(content, void 0, options) : MultilingualString.fromObject(content, languages, options);
+		this._content = parsed._content;
+		this._options = parsed._options;
+		this._availableLanguages = parsed._availableLanguages;
+		this._aliases = parsed._aliases;
+	}
+	static fromNormalized(content, options, availableLanguages) {
+		return new MultilingualString({
+			[MULTILINGUAL_STRING_INTERNAL_INIT]: true,
+			content,
+			options,
+			availableLanguages
+		});
+	}
+	static fromObject(content, languages, options = {}) {
+		const entries = {};
+		for (const [language, text] of Object.entries(content)) if (text != null) entries[language] = [text];
+		if (languages === void 0) return MultilingualString.fromEntries(entries, void 0, options);
+		return MultilingualString.fromEntries(entries, languages, options);
+	}
+	static fromEntries(content, languages, options = {}) {
+		if (languages === void 0) {
+			const actualLanguages = getImplicitLanguages(content, options);
+			const normalizedContent = {};
+			for (const language of actualLanguages) normalizedContent[language] = entriesFromTexts(content[language] ?? []);
+			const availableLanguages = getLanguagesWithEntries(normalizedContent, actualLanguages);
+			const defaultOptions = {
+				defaultLanguage: options.defaultLanguage ?? availableLanguages[0] ?? actualLanguages[0],
+				availableLanguages: actualLanguages,
+				aliases: normalizeAliases(options.aliases)
+			};
+			return MultilingualString.fromNormalized(normalizedContent, defaultOptions, availableLanguages);
+		}
+		const normalizedContent = {};
+		for (const language of languages) {
+			const typedLanguage = language;
+			normalizedContent[typedLanguage] = entriesFromTexts(content[typedLanguage] ?? []);
+		}
+		const availableLanguages = getLanguagesWithEntries(normalizedContent, languages);
+		const defaultOptions = {
+			defaultLanguage: options.defaultLanguage ?? availableLanguages[0] ?? languages[0],
+			availableLanguages: languages,
+			aliases: normalizeAliases(options.aliases)
+		};
+		return MultilingualString.fromNormalized(normalizedContent, defaultOptions, availableLanguages);
+	}
+	static create(language, text, languages, options = {}) {
+		if (languages === void 0) return MultilingualString.fromObject({ [language]: text }, void 0, {
+			...options,
+			defaultLanguage: language
+		});
+		return MultilingualString.fromObject({ [language]: text }, languages, {
+			...options,
+			defaultLanguage: language
+		});
+	}
+	static empty(languages, options = {}) {
+		if (languages === void 0) return MultilingualString.fromObject({}, void 0, options);
+		return MultilingualString.fromObject({}, languages, options);
+	}
+	static fromJSON(json, languages, options = {}) {
+		const content = json.content;
+		const mergedOptions = {
+			...options,
+			aliases: json.aliases
+		};
+		if (languages === void 0) return MultilingualString.fromEntries(content, void 0, mergedOptions);
+		return MultilingualString.fromEntries(content, languages, mergedOptions);
+	}
+	getPrimaryEntry(language) {
+		const entries = this._content[language] ?? [];
+		for (const entry of entries) if (entry.isPrimary) return entry;
+		return entries[0] ?? null;
+	}
+	/**
+	* Get text in a specific language with automatic fallback
+	*/
+	getText(language) {
+		if (language == null) {
+			const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
+			if (defaultEntry != null) return defaultEntry.text;
+		}
+		if (language != null) {
+			const requestedEntry = this.getPrimaryEntry(language);
+			if (requestedEntry != null) return requestedEntry.text;
+		}
+		const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
+		if (defaultEntry != null) return defaultEntry.text;
+		for (const availableLanguage of this._availableLanguages) {
+			const entry = this.getPrimaryEntry(availableLanguage);
+			if (entry != null) return entry.text;
+		}
+		return "";
+	}
+	/**
+	* Get rich text in a specific language with automatic fallback
+	*/
+	getRichText(language) {
+		if (language == null) {
+			const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
+			if (defaultEntry != null) return defaultEntry.richText;
+		}
+		if (language != null) {
+			const requestedEntry = this.getPrimaryEntry(language);
+			if (requestedEntry != null) return requestedEntry.richText;
+		}
+		const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
+		if (defaultEntry != null) return defaultEntry.richText;
+		for (const availableLanguage of this._availableLanguages) {
+			const entry = this.getPrimaryEntry(availableLanguage);
+			if (entry != null) return entry.richText;
+		}
+		return "";
+	}
+	/**
+	* Get primary text in a specific language without fallback
+	*/
+	getExactText(language) {
+		return this.getPrimaryEntry(language)?.text ?? null;
+	}
+	/**
+	* Get primary rich text in a specific language without fallback
+	*/
+	getExactRichText(language) {
+		return this.getPrimaryEntry(language)?.richText ?? null;
+	}
+	/**
+	* Get all text entries in a specific language without fallback
+	*/
+	getExactTexts(language) {
+		const texts = [];
+		for (const entry of this._content[language] ?? []) texts.push(entry.text);
+		return texts;
+	}
+	/**
+	* Get all rich text entries in a specific language without fallback
+	*/
+	getExactRichTexts(language) {
+		const texts = [];
+		for (const entry of this._content[language] ?? []) texts.push(entry.richText);
+		return texts;
+	}
+	/**
+	* Get all text entries in a specific language with fallback
+	*/
+	getTexts(language) {
+		if (language != null && (this._content[language]?.length ?? 0) > 0) return this.getExactTexts(language);
+		const defaultLanguage = this._options.defaultLanguage;
+		if ((this._content[defaultLanguage]?.length ?? 0) > 0) return this.getExactTexts(defaultLanguage);
+		const firstLanguage = this._availableLanguages[0];
+		return firstLanguage == null ? [] : this.getExactTexts(firstLanguage);
+	}
+	/**
+	* Get all rich text entries in a specific language with fallback
+	*/
+	getRichTexts(language) {
+		if (language != null && (this._content[language]?.length ?? 0) > 0) return this.getExactRichTexts(language);
+		const defaultLanguage = this._options.defaultLanguage;
+		if ((this._content[defaultLanguage]?.length ?? 0) > 0) return this.getExactRichTexts(defaultLanguage);
+		const firstLanguage = this._availableLanguages[0];
+		return firstLanguage == null ? [] : this.getExactRichTexts(firstLanguage);
+	}
+	/**
+	* Get all entries in a specific language without fallback
+	*/
+	getExactEntries(language) {
+		const entries = [];
+		for (const entry of this._content[language] ?? []) entries.push({
+			text: entry.text,
+			richText: entry.richText,
+			isPrimary: entry.isPrimary
+		});
+		return entries;
+	}
+	/**
+	* Get all entries in a specific language with fallback
+	*/
+	getEntries(language) {
+		if (language != null && (this._content[language]?.length ?? 0) > 0) return this.getExactEntries(language);
+		const defaultLanguage = this._options.defaultLanguage;
+		if ((this._content[defaultLanguage]?.length ?? 0) > 0) return this.getExactEntries(defaultLanguage);
+		const firstLanguage = this._availableLanguages[0];
+		return firstLanguage == null ? [] : this.getExactEntries(firstLanguage);
+	}
+	/**
+	* Get aliases carried by OCHRE as zxx content
+	*/
+	getAliases() {
+		return [...this._aliases];
+	}
+	/**
+	* Check if text exists for a specific language
+	*/
+	hasLanguage(language) {
+		return (this._content[language]?.length ?? 0) > 0;
+	}
+	/**
+	* Check if aliases exist
+	*/
+	hasAliases() {
+		return this._aliases.length > 0;
+	}
+	/**
+	* Get all available languages
+	*/
+	getAvailableLanguages() {
+		return this._availableLanguages;
+	}
+	/**
+	* Get all supported languages (the full language array passed to constructor)
+	*/
+	getSupportedLanguages() {
+		return this._options.availableLanguages;
+	}
+	/**
+	* Check if the multilingual string is empty (no content in any language)
+	*/
+	isEmpty() {
+		return this._availableLanguages.length === 0;
+	}
+	/**
+	* Check if the multilingual string has any content
+	*/
+	hasContent() {
+		const contentEntries = Object.values(this._content);
+		for (const entries of contentEntries) for (const entry of entries ?? []) if (entry.text.trim().length > 0 || entry.richText.trim().length > 0) return true;
+		return false;
+	}
+	/**
+	* Get the default language
+	*/
+	getDefaultLanguage() {
+		return this._options.defaultLanguage;
+	}
+	/**
+	* Add or update the primary text for a language (returns new instance)
+	*/
+	withText(language, text) {
+		const newContent = cloneContent(this._content);
+		newContent[language] = entriesFromTexts([text]);
+		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
+		return MultilingualString.fromNormalized(newContent, this._options, newAvailableLanguages);
+	}
+	/**
+	* Add another text entry for a language (returns new instance)
+	*/
+	withEntry(language, text) {
+		const newContent = cloneContent(this._content);
+		newContent[language] = normalizePrimary([...newContent[language] ?? [], {
+			...normalizeInputText(text),
+			isPrimary: false
+		}]);
+		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
+		return MultilingualString.fromNormalized(newContent, this._options, newAvailableLanguages);
+	}
+	/**
+	* Replace aliases (returns new instance)
+	*/
+	withAliases(aliases) {
+		return MultilingualString.fromNormalized(this._content, {
+			...this._options,
+			aliases: normalizeAliases(aliases)
+		}, this._availableLanguages);
+	}
+	/**
+	* Remove text for a language (returns new instance)
+	*/
+	withoutLanguage(language) {
+		const newContent = {};
+		const currentContent = cloneContent(this._content);
+		for (const supportedLanguage of this._options.availableLanguages) if (supportedLanguage !== language) newContent[supportedLanguage] = normalizePrimary(currentContent[supportedLanguage] ?? []);
+		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
+		const newDefaultLanguage = this._options.defaultLanguage === language ? newAvailableLanguages[0] ?? this._options.availableLanguages[0] : this._options.defaultLanguage;
+		return MultilingualString.fromNormalized(newContent, {
+			...this._options,
+			defaultLanguage: newDefaultLanguage
+		}, newAvailableLanguages);
+	}
+	/**
+	* Transform all language versions (returns new instance)
+	*/
+	map(fn) {
+		const newContent = {};
+		for (const language of this._availableLanguages) {
+			const mappedEntries = [];
+			for (const entry of this._content[language] ?? []) mappedEntries.push({
+				text: fn(entry.text, language),
+				richText: fn(entry.richText, language),
+				isPrimary: entry.isPrimary
+			});
+			newContent[language] = normalizePrimary(mappedEntries);
+		}
+		return MultilingualString.fromNormalized(newContent, this._options, this._availableLanguages);
+	}
+	/**
+	* Filter languages based on predicate (returns new instance)
+	*/
+	filter(predicate) {
+		const newContent = {};
+		for (const language of this._availableLanguages) {
+			const entries = [];
+			for (const entry of this._content[language] ?? []) if (predicate(entry.text, language)) entries.push(entry);
+			newContent[language] = normalizePrimary(entries);
+		}
+		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
+		const newDefaultLanguage = (newContent[this._options.defaultLanguage]?.length ?? 0) > 0 ? this._options.defaultLanguage : newAvailableLanguages[0] ?? this._options.availableLanguages[0];
+		return MultilingualString.fromNormalized(newContent, {
+			...this._options,
+			defaultLanguage: newDefaultLanguage
+		}, newAvailableLanguages);
+	}
+	/**
+	* Get the string representation (uses default language)
+	*/
+	toString() {
+		return this.getText();
+	}
+	/**
+	* Get JSON representation
+	*/
+	toJSON() {
+		const content = {};
+		for (const language of this._availableLanguages) content[language] = this.getExactEntries(language);
+		return {
+			content,
+			aliases: this.getAliases()
+		};
+	}
+};
+//#endregion
+export { MultilingualString };

package/dist/parsers/string.d.mts

@@ -0,0 +1,29 @@
+import { MultilingualString, MultilingualStringText } from "./multilingual.mjs";
+import { XMLContent, XMLString } from "../xml/types.mjs";
+
+//#region src/parsers/string.d.ts
+declare function transformPermanentIdentificationUrl(url: string): string;
+declare function parseXMLString(string: XMLString): MultilingualStringText;
+/**
+ * Parses rich text content into a formatted string with links and annotations
+ *
+ * @param item - XML-based rich text item to parse
+ * @param options - Options for parsing
+ * @param options.languages - Languages of the content
+ * @returns Plain and rich formatted strings
+ *
+ * @internal
+ */
+declare function parseXMLContent<V extends ReadonlyArray<string>>(item: XMLContent, options: {
+  languages: V;
+}): MultilingualString<V>;
+/**
+ * Extracts alias strings from XMLContent where lang="zxx"
+ * @param content - The XMLContent to extract aliases from
+ * @returns Array of alias strings, or null if none found
+ *
+ * @internal
+ */
+declare function extractAliases(content: XMLContent | undefined): Array<string> | null;
+//#endregion
+export { extractAliases, parseXMLContent, parseXMLString, transformPermanentIdentificationUrl };