@blinkk/root-cms 2.0.0-rc.1 → 2.0.0

package/dist/{client-AKOLkEwt.d.ts → client-fqtWzfpQ.d.ts}

@@ -1,6 +1,9 @@
 import { Request, Plugin, RootConfig } from '@blinkk/root';
 import { App } from 'firebase-admin/app';
-import { Firestore, Timestamp, Query, WriteBatch } from 'firebase-admin/firestore';
+import { Firestore, WriteBatch, Timestamp, Query } from 'firebase-admin/firestore';
+
+/** Supported Root AI models. Defaults to 'vertexai/gemini-2.5-flash'. */
+type RootAiModel = 'vertexai/gemini-2.5-flash' | 'vertexai/gemini-2.0-pro' | 'vertexai/gemini-1.5-flash' | 'vertexai/gemini-1.5-pro';
 
 interface CMSUser {
     email: string;
@@ -8,8 +11,8 @@ interface CMSUser {
 interface CMSAIConfig {
     /** Custom API endpoint for chat prompts. */
     endpoint?: string;
-    /** Gen AI model to use. Defaults to 'gemini-1.5-flash'. */
-    model?: 'gemini-1.5-flash' | 'gemini-1.5-pro';
+    /** Gen AI model to use. */
+    model?: RootAiModel;
 }
 interface CMSSidebarTool {
     /** URL for the sidebar icon image. */
@@ -100,6 +103,10 @@ type CMSPluginOptions = {
          */
         tools?: Record<string, CMSSidebarTool>;
     };
+    /**
+     * URL for a custom favicon used by the CMS UI.
+     */
+    favicon?: string;
     /**
      * Callback when an action occurs.
      */
@@ -108,7 +115,14 @@ type CMSPluginOptions = {
      * Experimental config options. Note: these are subject to change at any time.
      */
     experiments?: {
+        /**
+         * Enables the Root CMS AI page.
+         */
         ai?: boolean | CMSAIConfig;
+        /**
+         * Enables the v2 `TranslationsManager`.
+         */
+        v2TranslationsManager?: boolean;
     };
     /**
      * Adjust console output verbosity. Default is `'info'`.
@@ -127,7 +141,191 @@ type CMSPlugin = Plugin & {
     getFirestore: () => Firestore;
 };
 declare function cmsPlugin(options: CMSPluginOptions): CMSPlugin;
-declare function getCmsPlugin(rootConfig: RootConfig): CMSPlugin;
+
+type Locale = string;
+type SourceString = string;
+type TranslatedString = string;
+type TranslationsDocMode = 'draft' | 'published';
+interface TranslationsLocaleDocHashMap {
+    /**
+     * A hash map of a source string's hash fingerprint to the source string and
+     * translated string.
+     */
+    [hash: string]: TranslationsLocaleDocEntry;
+}
+interface TranslationsLocaleDocEntry {
+    source: SourceString;
+    translation: TranslatedString;
+}
+interface TranslationsDbPathOptions {
+    project: string;
+    mode: TranslationsDocMode;
+}
+type TranslationsLocaleDocDbPathOptions = TranslationsDbPathOptions & {
+    id: string;
+    locale: string;
+};
+/**
+ * A translations map containing translations for multiple locales.
+ *
+ * Example:
+ * ```
+ * {
+ *   "one": {"es": "uno", "fr": "un"},
+ *   "two": {"es": "dos", "fr": "deux"}
+ * }
+ * ```
+ */
+interface MultiLocaleTranslationsMap {
+    [source: SourceString]: {
+        [locale: Locale]: TranslatedString;
+    };
+}
+/**
+ * A translations map containing translations for a single locale.
+ *
+ * Example:
+ * ```
+ * {
+ *   "one": "uno",
+ *   "two": "dos"
+ * }
+ * ```
+ */
+interface SingleLocaleTranslationsMap {
+    [source: SourceString]: TranslatedString;
+}
+declare class TranslationsManager {
+    cmsClient: RootCMSClient;
+    constructor(cmsClient: RootCMSClient);
+    /**
+     * Saves draft translations for a translations doc id.
+     *
+     * Example:
+     * ```
+     * const strings = {
+     *   'one': {es: 'uno', fr: 'un'},
+     *   'two': {es: 'dos', fr: 'deux'},
+     * };
+     * await tm.saveTranslations('Pages/index', strings);
+     * ```
+     */
+    saveTranslations(id: string, strings: MultiLocaleTranslationsMap, options?: {
+        tags?: string[];
+        modifiedBy?: string;
+    }): Promise<void>;
+    /**
+     * Publishes a translations doc.
+     */
+    publishTranslations(id: string, options?: {
+        batch?: WriteBatch;
+        publishedBy?: string;
+    }): Promise<void>;
+    /**
+     * Fetches translations from one or more translations docs in the translations
+     * manager.
+     *
+     * Example:
+     * ```
+     * await tm.loadTranslations();
+     * // =>
+     * // {
+     * //   "one": {"es": "uno", "fr": "un"},
+     * //   "two": {"es": "dos", "fr": "deux"}
+     * // }
+     * ```
+     *
+     * To load a specific set of translations docs by id:
+     * ```
+     * const translationsToLoad = ['Global/strings', 'Global/header', 'Global/footer', 'Pages/index'];
+     * await tm.loadTranslations({ids: translationsToLoad});
+     * // =>
+     * // {
+     * //   "one": {"es": "uno", "fr": "un"},
+     * //   "two": {"es": "dos", "fr": "deux"}
+     * // }
+     * ```
+     *
+     * To load a subset of locales (more performant):
+     * ```
+     * await tm.loadTranslations({locales: ['es']});
+     * // =>
+     * // {
+     * //   "one": {"es": "uno"},
+     * //   "two": {"es": "dos"}
+     * // }
+     * ```
+     */
+    loadTranslations(options?: {
+        ids?: string[];
+        tags?: string[];
+        locales?: Locale[];
+        mode?: TranslationsDocMode;
+    }): Promise<MultiLocaleTranslationsMap>;
+    /**
+     * Fetches translations for a given locale, with optional fallbacks.
+     * The return value is a map of source string to translated string.
+     *
+     * Example:
+     * ```
+     * await translationsDoc.loadTranslationsForLocale('es');
+     * // =>
+     * // {
+     * //   "one": "uno",
+     * //   "two": "dos",
+     * // }
+     * ```
+     */
+    loadTranslationsForLocale(locale: Locale, options?: {
+        mode?: TranslationsDocMode;
+        fallbackLocales?: Locale[];
+    }): Promise<SingleLocaleTranslationsMap>;
+    /**
+     * Converts a multi-locale translations map to a flat single-locale map,
+     * with optional support for fallback locales.
+     *
+     * ```
+     * const multiLocaleStrings = {
+     *   'one': {es: 'uno', fr: 'un'},
+     *   'two': {es: 'dos', fr: 'deux'}
+     * };
+     * translationsDoc.toSingleLocaleMap(multiLocaleStrings, ['es']);
+     * // =>
+     * // {
+     * //   "one": "uno",
+     * //   "two": "dos",
+     * // }
+     * ```
+     */
+    private toSingleLocaleMap;
+    /**
+     * Converts a multi-locale translations map to a single-locale hashed version,
+     * used for storage in in the DB.
+     *
+     * ```
+     * const multiLocaleStrings = {
+     *   'one': {es: 'uno', fr: 'un'},
+     *   'two': {es: 'dos', fr: 'deux'}
+     * };
+     * translationsDoc.toLocaleDocHashMap(multiLocaleStrings, 'es');
+     * // =>
+     * // {
+     * //   "<hash1>": {"source": "one", "translation": "uno"},
+     * //   "<hash2>": {"source": "two", "translation": "dos"},
+     * // }
+     * ```
+     *
+     * One reason for using hashes is because the DB has limits on the number of
+     * chars that can be used as the "key" in a object map.
+     */
+    private toLocaleDocHashMap;
+    /**
+     * Import translations from the v1 system to the TranslationsManager.
+     */
+    importTranslationsFromV1(): Promise<void>;
+}
+declare function buildTranslationsDbPath(options: TranslationsDbPathOptions): string;
+declare function buildTranslationsLocaleDocDbPath(options: TranslationsLocaleDocDbPathOptions): string;
 
 interface Doc<Fields = any> {
     /** The id of the doc, e.g. "Pages/foo-bar". */
@@ -155,23 +353,6 @@ interface Doc<Fields = any> {
     };
     fields: Fields;
 }
-interface TranslationsDoc {
-    id: string;
-    sys: {
-        modifiedAt: Timestamp;
-        modifiedBy: string;
-        publishedAt?: Timestamp;
-        publishedBy?: string;
-        linkedSheet?: {
-            spreadsheetId: string;
-            gid: number;
-            linkedAt: Timestamp;
-            linkedBy: string;
-        };
-        tags?: string[];
-    };
-    strings: TranslationsMap;
-}
 type DocMode = 'draft' | 'published';
 type UserRole = 'ADMIN' | 'EDITOR' | 'VIEWER';
 type HttpMethod = 'GET' | 'POST';
@@ -203,6 +384,8 @@ interface DataSource {
 interface DataSourceData<T = any> {
     dataSource: DataSource;
     data: T;
+    /** Optional list of column headers (for gsheet sources). */
+    headers?: string[];
 }
 type DataSourceMode = 'draft' | 'published';
 interface GetDocOptions {
@@ -257,6 +440,7 @@ interface Release {
     id: string;
     description?: string;
     docIds?: string[];
+    dataSourceIds?: string[];
     createdAt?: Timestamp;
     createdBy?: string;
     scheduledAt?: Timestamp;
@@ -312,12 +496,21 @@ declare class RootCMSClient {
      * what you are doing.
      */
     getRawDoc(collectionId: string, slug: string, options: GetDocOptions): Promise<any | null>;
+    /**
+     * Firestore path for a collection.
+     */
     dbCollectionDocsPath(collectionId: string, options: {
         mode: 'draft' | 'published';
     }): string;
+    /**
+     * Firestore path for a content doc.
+     */
     dbDocPath(collectionId: string, slug: string, options: {
         mode: 'draft' | 'published';
     }): string;
+    /**
+     * Firestore doc ref for a content doc.
+     */
     dbDocRef(collectionId: string, slug: string, options: {
         mode: 'draft' | 'published';
     }): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
@@ -349,6 +542,7 @@ declare class RootCMSClient {
     publishDocs(docIds: string[], options?: {
         publishedBy: string;
         batch?: WriteBatch;
+        releaseId?: string;
     }): Promise<any[]>;
     /**
      * Publishes scheduled docs.
@@ -358,33 +552,50 @@ declare class RootCMSClient {
      * Publishes docs in scheduled releases.
      */
     publishScheduledReleases(): Promise<void>;
-    publishTranslationsDoc(translationsId: string, options?: {
-        batch?: WriteBatch;
-        publishedBy?: string;
-    }): Promise<void>;
     /**
      * Checks if a doc is currently "locked" for publishing.
      */
     testPublishingLocked(doc: Doc): boolean;
     /**
-     * Loads all published strings in the db.
+     * Returns a `TranslationsManager` object for managing translations.
+     *
+     * To get translations:
+     * ```
+     * await tm.loadTranslations({
+     *   ids: ['Global/strings', 'Pages/index'],
+     *   locales: ['es'],
+     * });
+     * ```
      *
+     * NOTE: The `TranslationsManager` is a v2 feature that will eventually
+     * replace the v1 translations system.
+     */
+    getTranslationsManager(): TranslationsManager;
+    /**
+     * Loads translations saved in the translations collection, optionally
+     * filtered by tag.
+     *
+     * Returns a map like:
      * ```
      * {
      *   "<hash>": {"source": "Hello", "es": "Hola", "fr": "Bonjour"},
      * }
      * ```
-     *
-     * @deprecated Use `createBatchRequest()` to fetch draft/published translations.
      */
     loadTranslations(options?: LoadTranslationsOptions): Promise<TranslationsMap>;
-    saveDraftTranslations(translationsId: string, translations: {
+    /**
+     * Saves a map of translations, e.g.:
+     * ```
+     * await client.saveTranslations({
+     *   "Hello": {"es": "Hola", "fr": "Bonjour"},
+     * });
+     * ```
+     */
+    saveTranslations(translations: {
         [source: string]: {
             [locale: string]: string;
         };
-    }, options?: {
-        modifiedby?: string;
-    }): Promise<void>;
+    }, tags?: string[]): Promise<void>;
     /**
      * Returns the "key" used for a translation as stored in the db. Translations
      * are stored under `Projects/<project id>/Translations/<sha1 hash>`.
@@ -407,6 +618,18 @@ declare class RootCMSClient {
      * ```
      */
     loadTranslationsForLocale(locale: string, options?: LoadTranslationsOptions): Promise<LocaleTranslations>;
+    /**
+     * Firestore path for a translations file.
+     */
+    dbTranslationsPath(translationsId: string, options: {
+        mode: 'draft' | 'published';
+    }): string;
+    /**
+     * Firestore doc ref for a translations file.
+     */
+    dbTranslationsRef(translationsId: string, options: {
+        mode: 'draft' | 'published';
+    }): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
     /**
      * Returns a data source configuration object.
      */
@@ -420,6 +643,11 @@ declare class RootCMSClient {
     publishDataSource(dataSourceId: string, options?: {
         publishedBy?: string;
     }): Promise<void>;
+    publishDataSources(dataSourceIds: string[], options?: {
+        publishedBy: string;
+        batch?: WriteBatch;
+        commitBatch?: boolean;
+    }): Promise<void>;
     private fetchData;
     private fetchHttpData;
     /**
@@ -428,18 +656,18 @@ declare class RootCMSClient {
     getFromDataSource<T = any>(dataSourceId: string, options?: {
         mode?: 'draft' | 'published';
     }): Promise<DataSourceData<T> | null>;
+    /**
+     * Firestore path for a datasource data.
+     */
     dbDataSourceDataPath(dataSourceId: string, options: {
         mode: 'draft' | 'published';
     }): string;
+    /**
+     * Firestore doc ref for a datasource data.
+     */
     dbDataSourceDataRef(dataSourceId: string, options: {
         mode: 'draft' | 'published';
     }): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
-    dbTranslationsPath(translationsId: string, options: {
-        mode: 'draft' | 'published';
-    }): string;
-    dbTranslationsRef(translationsId: string, options: {
-        mode: 'draft' | 'published';
-    }): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
     /**
      * Gets the user's role from the project's ACL.
      */
@@ -452,8 +680,80 @@ declare class RootCMSClient {
         by?: string;
         metadata?: any;
     }): Promise<void>;
+    /**
+     * Creates a batch request that is capable of fetching one or more docs,
+     * corresponding translations, and dataSources.
+     */
     createBatchRequest(options: BatchRequestOptions): BatchRequest;
 }
+/**
+ * Returns true if the `data` is a rich text data object.
+ */
+declare function isRichTextData(data: any): boolean;
+declare function getCmsPlugin(rootConfig: RootConfig): CMSPlugin;
+/**
+ * Walks the data tree and converts any array of objects into "array objects"
+ * for storage in firestore.
+ */
+declare function marshalData(data: any): any;
+/**
+ * Walks the data tree and converts any Timestamp objects to millis and any
+ * _array maps to normal arrays.
+ *
+ * E.g.:
+ *
+ * normalizeData({
+ *   sys: {modifiedAt: Timestamp(123)},
+ *   fields: {
+ *     _array: ['asdf'],
+ *     asdf: {title: 'hello'}
+ *   }
+ * })
+ * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}
+ */
+declare function unmarshalData(data: any): any;
+/** @deprecated Use `unmarshalData()` instead. */
+declare function normalizeData(data: any): any;
+interface ArrayObject {
+    [key: string]: any;
+    _array: string[];
+}
+/**
+ * Serializes an array into an `ArrayObject`, e.g.:
+ *
+ * ```
+ * marshalArray([1, 2, 3])
+ * // => {a: 1, b: 2, c: 3, _array: ['a', 'b', 'c']}
+ * ```
+ *
+ * This database storage method makes it easier to update a single field in a
+ * deeply nested array object.
+ */
+declare function toArrayObject(arr: any[]): ArrayObject;
+declare const marshalArray: typeof toArrayObject;
+/**
+ * Converts an `ArrayObject` to a normal array.
+ */
+declare function unmarshalArray(arrObject: ArrayObject): any[];
+/**
+ * Converts a translations map from `loadTranslations()` to a map of source to
+ * translated string for a particular locale.
+ *
+ * Returns a map like:
+ * ```
+ * {
+ *   "Hello": "Bonjour",
+ * }
+ * ```
+ */
+declare function translationsForLocale(translationsMap: TranslationsMap, locale: string): LocaleTranslations;
+/**
+ * Parses a docId (e.g. `Pages/foo`) and returns the `collection` and `slug`.
+ */
+declare function parseDocId(docId: string): {
+    collection: string;
+    slug: string;
+};
 interface BatchRequestOptions {
     mode: 'draft' | 'published';
     /**
@@ -474,6 +774,23 @@ interface BatchRequestQueryOptions {
     orderByDirection?: 'asc' | 'desc';
     query?: (query: Query) => Query;
 }
+interface TranslationsDoc {
+    id: string;
+    sys: {
+        modifiedAt: Timestamp;
+        modifiedBy: string;
+        publishedAt?: Timestamp;
+        publishedBy?: string;
+        linkedSheet?: {
+            spreadsheetId: string;
+            gid: number;
+            linkedAt: Timestamp;
+            linkedBy: string;
+        };
+        tags?: string[];
+    };
+    strings: TranslationsMap;
+}
 declare class BatchRequest {
     cmsClient: RootCMSClient;
     private options;
@@ -519,11 +836,13 @@ declare class BatchResponse {
      * The input is either a single locale (e.g. "de") or an array of locales
      * representing the fallback tree, e.g. ["en-CA", "en-GB", "en"].
      *
+     * TODO(stevenle): support the locale fallback tree.
+     *
      * The returned value is a flat map of source string to translated string,
      * e.g.:
      * {"<source>": "<translation>"}
      */
-    getTranslations(locale: string | string[]): LocaleTranslations;
+    getTranslations(locale: string): LocaleTranslations;
     /**
      * Merges the strings from all translations files retrieved in the request.
      * The returned value is a map of string to translations, e.g.:
@@ -532,72 +851,5 @@ declare class BatchResponse {
      */
     private getTranslationsMap;
 }
-/**
- * Returns true if the `data` is a rich text data object.
- */
-declare function isRichTextData(data: any): boolean;
-/**
- * Walks the data tree and converts any array of objects into "array objects"
- * for storage in firestore.
- */
-declare function marshalData(data: any): any;
-/**
- * Walks the data tree and converts any Timestamp objects to millis and any
- * _array maps to normal arrays.
- *
- * E.g.:
- *
- * normalizeData({
- *   sys: {modifiedAt: Timestamp(123)},
- *   fields: {
- *     _array: ['asdf'],
- *     asdf: {title: 'hello'}
- *   }
- * })
- * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}
- */
-declare function unmarshalData(data: any): any;
-/** @deprecated Use `unmarshalData()` instead. */
-declare function normalizeData(data: any): any;
-interface ArrayObject {
-    [key: string]: any;
-    _array: string[];
-}
-/**
- * Serializes an array into an `ArrayObject`, e.g.:
- *
- * ```
- * marshalArray([1, 2, 3])
- * // => {a: 1, b: 2, c: 3, _array: ['a', 'b', 'c']}
- * ```
- *
- * This database storage method makes it easier to update a single field in a
- * deeply nested array object.
- */
-declare function toArrayObject(arr: any[]): ArrayObject;
-declare const marshalArray: typeof toArrayObject;
-/**
- * Converts an `ArrayObject` to a normal array.
- */
-declare function unmarshalArray(arrObject: ArrayObject): any[];
-/**
- * Converts a translations map from `loadTranslations()` to a map of source to
- * translated string for a particular locale.
- *
- * Returns a map like:
- * ```
- * {
- *   "Hello": "Bonjour",
- * }
- * ```
- */
-declare function translationsForLocale(translationsMap: TranslationsMap, locale: string | string[]): LocaleTranslations;
-/**
- * Parses a docId (e.g. `Pages/foo`) and returns the `collection` and `slug`.
- */
-declare function parseDocId(docId: string): {
-    collection: string;
-    slug: string;
-};
 
-export { type Action as A, BatchRequest as B, parseDocId as C, type Doc as D, type CMSUser as E, type CMSAIConfig as F, type GetDocOptions as G, type HttpMethod as H, type CMSSidebarTool as I, type CMSPluginOptions as J, type CMSPlugin as K, type LoadTranslationsOptions as L, cmsPlugin as M, RootCMSClient as R, type SetDocOptions as S, type TranslationsMap as T, type UserRole as U, type LocaleTranslations as a, type TranslationsDoc as b, type DocMode as c, type DataSource as d, type DataSourceData as e, type DataSourceMode as f, getCmsPlugin as g, type SaveDraftOptions as h, type ListDocsOptions as i, type GetCountOptions as j, type Translation as k, type Release as l, type ListActionsOptions as m, type BatchRequestOptions as n, type BatchRequestQuery as o, type BatchRequestQueryOptions as p, BatchResponse as q, isRichTextData as r, marshalData as s, normalizeData as t, unmarshalData as u, type ArrayObject as v, toArrayObject as w, marshalArray as x, unmarshalArray as y, translationsForLocale as z };
+export { cmsPlugin as $, type Action as A, type BatchRequestOptions as B, BatchResponse as C, type Doc as D, type Locale as E, type SourceString as F, type GetDocOptions as G, type HttpMethod as H, type TranslatedString as I, type TranslationsDocMode as J, type TranslationsLocaleDocHashMap as K, type LoadTranslationsOptions as L, type TranslationsLocaleDocEntry as M, type MultiLocaleTranslationsMap as N, type SingleLocaleTranslationsMap as O, TranslationsManager as P, buildTranslationsDbPath as Q, type Release as R, type SetDocOptions as S, type TranslationsMap as T, type UserRole as U, buildTranslationsLocaleDocDbPath as V, type CMSUser as W, type CMSAIConfig as X, type CMSSidebarTool as Y, type CMSPluginOptions as Z, type CMSPlugin as _, type LocaleTranslations as a, type DocMode as b, type DataSource as c, type DataSourceData as d, type DataSourceMode as e, type SaveDraftOptions as f, type ListDocsOptions as g, type GetCountOptions as h, type Translation as i, type ListActionsOptions as j, RootCMSClient as k, isRichTextData as l, getCmsPlugin as m, marshalData as n, normalizeData as o, type ArrayObject as p, marshalArray as q, unmarshalArray as r, translationsForLocale as s, toArrayObject as t, unmarshalData as u, parseDocId as v, type BatchRequestQuery as w, type BatchRequestQueryOptions as x, type TranslationsDoc as y, BatchRequest as z };

package/dist/client.d.ts

@@ -1,4 +1,4 @@
 import '@blinkk/root';
 import 'firebase-admin/app';
 import 'firebase-admin/firestore';
-export { A as Action, v as ArrayObject, B as BatchRequest, n as BatchRequestOptions, o as BatchRequestQuery, p as BatchRequestQueryOptions, q as BatchResponse, d as DataSource, e as DataSourceData, f as DataSourceMode, D as Doc, c as DocMode, j as GetCountOptions, G as GetDocOptions, H as HttpMethod, m as ListActionsOptions, i as ListDocsOptions, L as LoadTranslationsOptions, a as LocaleTranslations, l as Release, R as RootCMSClient, h as SaveDraftOptions, S as SetDocOptions, k as Translation, b as TranslationsDoc, T as TranslationsMap, U as UserRole, g as getCmsPlugin, r as isRichTextData, x as marshalArray, s as marshalData, t as normalizeData, C as parseDocId, w as toArrayObject, z as translationsForLocale, y as unmarshalArray, u as unmarshalData } from './client-AKOLkEwt.js';
+export { A as Action, p as ArrayObject, z as BatchRequest, B as BatchRequestOptions, w as BatchRequestQuery, x as BatchRequestQueryOptions, C as BatchResponse, c as DataSource, d as DataSourceData, e as DataSourceMode, D as Doc, b as DocMode, h as GetCountOptions, G as GetDocOptions, H as HttpMethod, j as ListActionsOptions, g as ListDocsOptions, L as LoadTranslationsOptions, a as LocaleTranslations, R as Release, k as RootCMSClient, f as SaveDraftOptions, S as SetDocOptions, i as Translation, y as TranslationsDoc, T as TranslationsMap, U as UserRole, m as getCmsPlugin, l as isRichTextData, q as marshalArray, n as marshalData, o as normalizeData, v as parseDocId, t as toArrayObject, s as translationsForLocale, r as unmarshalArray, u as unmarshalData } from './client-fqtWzfpQ.js';