@acorex-platform/module-content-management-client 0.0.21

package/fesm2022/acorex-platform-module-content-management-client-contracts.mjs

@@ -0,0 +1,583 @@
+import { resolveMultiLanguageString } from '@acorex-platform/framework-shared/core';
+
+const AXPContentManagementMenuKeys = {
+    Root: 'content-management:menu',
+    HelpRoot: 'app:help',
+    Promotions: 'content-management:menu:promotions',
+    TextTemplates: 'content-management:menu:text-templates',
+    Glossary: 'content-management:menu:glossary',
+    HelpCenter: 'app:help:center',
+    Tutorials: 'app:help:tutorials',
+    About: 'app:about',
+};
+
+/**
+ * Content & Documents capabilities used by this module.
+ * Domain capability keys for this module. Root groups live in `AXPCommonPermissionGroupKeys` (common contracts).
+ */
+const AXPContentDocumentsPermissionKeys = {
+    Access: 'ContentDocuments:Permission:Access',
+    MaintainDocuments: 'ContentDocuments:Permission:MaintainDocuments',
+    MaintainContent: 'ContentDocuments:Permission:MaintainContent',
+    MaintainFormTemplates: 'ContentDocuments:Permission:MaintainFormTemplates',
+    Setup: 'ContentDocuments:Permission:Setup',
+};
+/**
+ * @deprecated Prefer {@link AXPContentDocumentsPermissionKeys}.
+ * Legacy nested shape kept so existing imports compile during migration.
+ */
+const AXMPermissionsKeys = {
+    ContentManagement: {
+        Management: AXPContentDocumentsPermissionKeys.MaintainContent,
+        Promotion: {
+            Management: AXPContentDocumentsPermissionKeys.MaintainContent,
+            View: AXPContentDocumentsPermissionKeys.MaintainContent,
+            Edit: AXPContentDocumentsPermissionKeys.MaintainContent,
+            Delete: AXPContentDocumentsPermissionKeys.MaintainContent,
+            Create: AXPContentDocumentsPermissionKeys.MaintainContent,
+        },
+        TextTemplate: {
+            Management: AXPContentDocumentsPermissionKeys.MaintainContent,
+            View: AXPContentDocumentsPermissionKeys.MaintainContent,
+            Edit: AXPContentDocumentsPermissionKeys.MaintainContent,
+            Delete: AXPContentDocumentsPermissionKeys.MaintainContent,
+            Create: AXPContentDocumentsPermissionKeys.MaintainContent,
+        },
+    },
+};
+
+const config = {
+    i18n: 'content-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        module: 'ContentManagement',
+        name: 'ContentManagement',
+        title: `@${config.i18n}:module.title`,
+        icon: 'fa-light fa-file-invoice',
+    },
+    entities: {
+        promotion: {
+            name: 'Promotion',
+            title: `@${config.i18n}:promotions.entities.promotion.title`,
+            titlePlural: `@${config.i18n}:promotions.entities.promotion.plural`,
+            icon: 'fa-light fa-megaphone',
+        },
+        glossary: {
+            name: 'Glossary',
+            title: `@${config.i18n}:glossaries.entities.glossary.title`,
+            titlePlural: `@${config.i18n}:glossaries.entities.glossary.plural`,
+            icon: 'fa-light fa-file',
+        },
+        textTemplate: {
+            name: 'TextTemplate',
+            title: `@${config.i18n}:templates.entities.text-template.title`,
+            titlePlural: `@${config.i18n}:templates.entities.text-template.plural`,
+            icon: 'fa-light fa-envelope',
+        },
+    },
+};
+
+//#region ----- Types -----
+//#endregion
+//#region ----- Locale defaults -----
+/**
+ * Default short-date pattern when settings do not provide ShortDate.
+ * Aligns with locale-management profiles (en-US / en-AU / en-NZ / fa-IR).
+ */
+function defaultShortDatePatternForLocale(locale) {
+    const code = normalizeLocale(locale);
+    if (code === 'en-us') {
+        return 'MM/DD/YYYY';
+    }
+    if (code.startsWith('fa')) {
+        return 'YYYY/MM/DD';
+    }
+    // en-AU, en-NZ, en-GB, and most other locales
+    return 'DD/MM/YYYY';
+}
+function defaultShortTimePatternForLocale(_locale) {
+    return 'HH:mm';
+}
+/**
+ * Resolves calendar: settings value, else `solar-hijri` for `fa-*`, else Gregorian.
+ */
+function resolveTextTemplateCalendar(locale, calendarSetting) {
+    const setting = (calendarSetting ?? '').trim().toLowerCase();
+    if (setting === 'solar-hijri' ||
+        setting === 'jalali' ||
+        setting === 'persian' ||
+        setting === 'hijri-shamsi') {
+        return 'solar-hijri';
+    }
+    if (setting === 'gregory' || setting === 'gregorian') {
+        return 'gregory';
+    }
+    return normalizeLocale(locale).startsWith('fa') ? 'solar-hijri' : 'gregory';
+}
+//#endregion
+//#region ----- Date / number formatting (Nest-safe) -----
+/**
+ * Parses ISO / `YYYY-MM-DD` / Date-like merge values into a Date.
+ * Date-only keys are treated as UTC midnight to avoid off-by-one shifts.
+ */
+function parseTextTemplateDateValue(value) {
+    if (value == null || value === '') {
+        return null;
+    }
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? null : value;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+        const date = new Date(`${trimmed}T00:00:00.000Z`);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    const date = new Date(trimmed);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+/**
+ * Formats a date with regional patterns (`DD/MM/YYYY`, `D MMMM YYYY`, `HH:mm`, …)
+ * using the active locale for month names, digits, and calendar (Jalali for fa-IR).
+ */
+function formatTextTemplateDate(value, pattern, timeZone = 'UTC', locale = 'en-US', calendar) {
+    const date = parseTextTemplateDateValue(value);
+    if (!date) {
+        return value == null ? '' : String(value);
+    }
+    const resolvedLocale = locale?.trim() || 'en-US';
+    const resolvedCalendar = resolveTextTemplateCalendar(resolvedLocale, calendar);
+    const intlCalendar = resolvedCalendar === 'solar-hijri' ? 'persian' : 'gregory';
+    const parts = getZonedCalendarParts(date, timeZone || 'UTC', resolvedLocale, intlCalendar);
+    const monthLong = getLocalizedMonthName(date, resolvedLocale, intlCalendar, timeZone || 'UTC', 'long');
+    const monthShort = getLocalizedMonthName(date, resolvedLocale, intlCalendar, timeZone || 'UTC', 'short');
+    let out = pattern?.trim() || defaultShortDatePatternForLocale(resolvedLocale);
+    // Longer tokens first.
+    out = out.replace(/YYYY/g, formatLocaleInteger(parts.year, resolvedLocale, 4));
+    out = out.replace(/MMMM/g, monthLong);
+    out = out.replace(/MMM/g, monthShort);
+    out = out.replace(/MM/g, formatLocaleInteger(parts.month, resolvedLocale, 2));
+    out = out.replace(/\bM\b/g, formatLocaleInteger(parts.month, resolvedLocale, 0));
+    out = out.replace(/DD/g, formatLocaleInteger(parts.day, resolvedLocale, 2));
+    out = out.replace(/\bD\b/g, formatLocaleInteger(parts.day, resolvedLocale, 0));
+    out = out.replace(/HH/g, formatLocaleInteger(parts.hour, resolvedLocale, 2));
+    out = out.replace(/mm/g, formatLocaleInteger(parts.minute, resolvedLocale, 2));
+    out = out.replace(/ss/g, formatLocaleInteger(parts.second, resolvedLocale, 2));
+    return out;
+}
+function formatTextTemplateNumber(value, locale, options = {}) {
+    const num = coerceNumber(value);
+    if (num == null) {
+        return value == null ? '' : String(value);
+    }
+    const resolvedLocale = locale?.trim() || 'en-US';
+    const style = options.style ?? 'decimal';
+    try {
+        if (style === 'integer') {
+            return new Intl.NumberFormat(resolvedLocale, {
+                maximumFractionDigits: 0,
+            }).format(num);
+        }
+        if (style === 'percent') {
+            return new Intl.NumberFormat(resolvedLocale, {
+                style: 'percent',
+                maximumFractionDigits: 2,
+            }).format(num);
+        }
+        if (style === 'currency') {
+            return new Intl.NumberFormat(resolvedLocale, {
+                style: 'currency',
+                currency: options.currency?.trim() || defaultCurrencyForLocale(resolvedLocale),
+            }).format(num);
+        }
+        return new Intl.NumberFormat(resolvedLocale, {
+            maximumFractionDigits: 6,
+        }).format(num);
+    }
+    catch {
+        return String(num);
+    }
+}
+/**
+ * Formats merge values using PlatformManagement.Token `dataType` / `format` metadata.
+ * Unknown tokens and non-typed strings are left unchanged.
+ */
+function formatTextTemplateMergeValues(merge, metaByName, regional) {
+    const out = { ...merge };
+    const locale = regional.locale?.trim() || 'en-US';
+    const shortDate = regional.shortDate?.trim() || defaultShortDatePatternForLocale(locale);
+    const shortTime = regional.shortTime?.trim() || defaultShortTimePatternForLocale(locale);
+    const timeZone = regional.timeZone?.trim() || 'UTC';
+    const calendar = resolveTextTemplateCalendar(locale, regional.calendar);
+    for (const [name, raw] of Object.entries(merge)) {
+        const meta = metaByName[name];
+        if (!meta) {
+            continue;
+        }
+        const dataType = (meta.dataType ?? 'String').trim();
+        const format = (meta.format ?? 'None').trim();
+        if (dataType === 'DateTime') {
+            const pattern = `${shortDate} ${shortTime}`.trim();
+            const dateOnly = looksLikeDateOnly(raw);
+            out[name] = formatTextTemplateDate(raw, dateOnly ? shortDate : pattern, timeZone, locale, calendar);
+            continue;
+        }
+        if (dataType === 'Integer') {
+            out[name] = formatTextTemplateNumber(raw, locale, { style: 'integer' });
+            continue;
+        }
+        if (dataType === 'Decimal' || format === 'Currency' || format === 'Percent') {
+            const style = format === 'Currency' ? 'currency' : format === 'Percent' ? 'percent' : 'decimal';
+            out[name] = formatTextTemplateNumber(raw, locale, { style });
+        }
+    }
+    return out;
+}
+//#endregion
+//#region ----- Helpers -----
+function normalizeLocale(locale) {
+    return (locale ?? 'en-US').trim().toLowerCase() || 'en-us';
+}
+function defaultCurrencyForLocale(locale) {
+    const code = normalizeLocale(locale);
+    if (code === 'en-au')
+        return 'AUD';
+    if (code === 'en-nz')
+        return 'NZD';
+    if (code.startsWith('fa') || code === 'en-ir')
+        return 'IRR';
+    if (code === 'en-gb')
+        return 'GBP';
+    return 'USD';
+}
+function coerceNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const num = Number(value.trim());
+        return Number.isFinite(num) ? num : null;
+    }
+    return null;
+}
+function looksLikeDateOnly(value) {
+    const trimmed = value.trim();
+    if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+        return true;
+    }
+    return /^\d{4}-\d{2}-\d{2}T00:00:00(?:\.0+)?Z$/i.test(trimmed);
+}
+function formatLocaleInteger(value, locale, minDigits) {
+    const abs = Math.trunc(Math.abs(value));
+    const padded = minDigits > 0 ? String(abs).padStart(minDigits, '0') : String(abs);
+    try {
+        // Format digit-by-digit so padding zeros stay and locale digits apply (fa-IR → ۰۱۲…).
+        return padded
+            .split('')
+            .map((ch) => new Intl.NumberFormat(locale, { useGrouping: false }).format(Number(ch)))
+            .join('');
+    }
+    catch {
+        return padded;
+    }
+}
+function getLocalizedMonthName(date, locale, calendar, timeZone, width) {
+    try {
+        return new Intl.DateTimeFormat(locale, {
+            timeZone,
+            calendar,
+            month: width,
+        }).format(date);
+    }
+    catch {
+        try {
+            return new Intl.DateTimeFormat('en-US', {
+                timeZone,
+                calendar: 'gregory',
+                month: width,
+            }).format(date);
+        }
+        catch {
+            return String(date.getUTCMonth() + 1);
+        }
+    }
+}
+function getZonedCalendarParts(date, timeZone, locale, calendar) {
+    try {
+        const formatter = new Intl.DateTimeFormat(locale, {
+            timeZone: timeZone || 'UTC',
+            calendar,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+            // Keep part extraction numeric-stable; display digits are localized later.
+            numberingSystem: 'latn',
+        });
+        const parts = formatter.formatToParts(date);
+        const read = (type) => {
+            const value = parts.find((part) => part.type === type)?.value;
+            return value ? Number(value) : 0;
+        };
+        let hour = read('hour');
+        // Some engines emit 24:00 for midnight.
+        if (hour === 24) {
+            hour = 0;
+        }
+        return {
+            year: read('year'),
+            month: read('month'),
+            day: read('day'),
+            hour,
+            minute: read('minute'),
+            second: read('second'),
+        };
+    }
+    catch {
+        return {
+            year: date.getUTCFullYear(),
+            month: date.getUTCMonth() + 1,
+            day: date.getUTCDate(),
+            hour: date.getUTCHours(),
+            minute: date.getUTCMinutes(),
+            second: date.getUTCSeconds(),
+        };
+    }
+}
+//#endregion
+
+/** Template kind: content (leaf message) or master (layout shell with `[content]`). */
+const AXM_TEXT_TEMPLATE_KIND = {
+    Content: 'content',
+    Master: 'master',
+};
+/** Print / PDF channel key on `channels` (rich body, no subject). */
+const AXM_TEXT_TEMPLATE_PRINT_CHANNEL = 'print';
+/** Reserved body slot for child template body injection (not a `{{token}}` variable). */
+const AXM_TEXT_TEMPLATE_CONTENT_SLOT = '[content]';
+/** Max `parentId` chain length (leaf → … → root), including the leaf. */
+const AXM_TEXT_TEMPLATE_MAX_PARENT_DEPTH = 5;
+//#endregion
+
+//#region ----- Placeholder replacement -----
+const TEXT_TEMPLATE_PLACEHOLDER_PATTERN = /\{\{([\w-]+)\}\}/g;
+/**
+ * Collects unique placeholder token names from text (`{{name}}`).
+ */
+function collectTextTemplatePlaceholderNames(text) {
+    return [...new Set((text.match(TEXT_TEMPLATE_PLACEHOLDER_PATTERN) ?? []).map((m) => m.slice(2, -2)))];
+}
+/**
+ * Replaces `{{token}}` when `merge[token]` is defined; otherwise leaves the token unchanged.
+ */
+function replaceTextTemplatePlaceholders(text, merge) {
+    return text.replace(TEXT_TEMPLATE_PLACEHOLDER_PATTERN, (full, name) => Object.prototype.hasOwnProperty.call(merge, name) ? merge[name] : full);
+}
+/**
+ * Resolves a template channel field (plain string or per-locale map) for the active locale.
+ */
+function resolveTextTemplateLocalizedString(value, locale) {
+    if (value == null || value === '') {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return resolveMultiLanguageString(value, locale);
+}
+/**
+ * Returns true when `text` contains the reserved `[content]` slot.
+ */
+function textTemplateContainsContentSlot(text) {
+    if (text == null || text === '') {
+        return false;
+    }
+    return text.includes(AXM_TEXT_TEMPLATE_CONTENT_SLOT);
+}
+/**
+ * Injects child body into every `[content]` occurrence in a master body.
+ */
+function replaceTextTemplateContentSlot(masterBody, content) {
+    if (!masterBody.includes(AXM_TEXT_TEMPLATE_CONTENT_SLOT)) {
+        return masterBody;
+    }
+    return masterBody.split(AXM_TEXT_TEMPLATE_CONTENT_SLOT).join(content);
+}
+/**
+ * Composes a body chain: leaf first, then parents toward root.
+ * Each level applies `{{token}}` merge; parents receive the child body via `[content]`.
+ */
+function composeTextTemplateBodyChain(bodiesLeafToRoot, merge) {
+    if (!bodiesLeafToRoot.length) {
+        return '';
+    }
+    let body = replaceTextTemplatePlaceholders(bodiesLeafToRoot[0] ?? '', merge);
+    for (let i = 1; i < bodiesLeafToRoot.length; i++) {
+        const parentMerged = replaceTextTemplatePlaceholders(bodiesLeafToRoot[i] ?? '', merge);
+        body = replaceTextTemplateContentSlot(parentMerged, body);
+    }
+    return body;
+}
+//#endregion
+//#region ----- Validation helpers -----
+function collectLocalizedBodyStrings(body) {
+    if (body == null || body === '') {
+        return [];
+    }
+    if (typeof body === 'string') {
+        return body.trim() ? [body] : [];
+    }
+    return Object.values(body).filter((v) => typeof v === 'string' && v.trim().length > 0);
+}
+/**
+ * Master templates: every non-empty channel body locale must include `[content]`.
+ * Content templates: no channel body may include `[content]`.
+ */
+function validateTextTemplateContentSlots(input) {
+    const kind = (input.kind ?? AXM_TEXT_TEMPLATE_KIND.Content);
+    const channels = input.channels ?? {};
+    const channelEntries = Object.entries(channels);
+    if (kind === AXM_TEXT_TEMPLATE_KIND.Master) {
+        if (!channelEntries.length) {
+            return { ok: false, error: 'Master templates must define at least one channel with a [content] slot.' };
+        }
+        for (const [channelName, channel] of channelEntries) {
+            const bodies = collectLocalizedBodyStrings(channel?.body);
+            if (!bodies.length) {
+                return {
+                    ok: false,
+                    error: `Master template channel "${channelName}" must include a body with the [content] slot.`,
+                };
+            }
+            for (const body of bodies) {
+                if (!textTemplateContainsContentSlot(body)) {
+                    return {
+                        ok: false,
+                        error: `Master template channel "${channelName}" body must include the [content] slot.`,
+                    };
+                }
+            }
+        }
+        return { ok: true };
+    }
+    for (const [channelName, channel] of channelEntries) {
+        for (const body of collectLocalizedBodyStrings(channel?.body)) {
+            if (textTemplateContainsContentSlot(body)) {
+                return {
+                    ok: false,
+                    error: `Content template channel "${channelName}" must not include the reserved [content] slot.`,
+                };
+            }
+        }
+    }
+    return { ok: true };
+}
+/**
+ * Validates parent reference and walks the parent chain for kind, cycles, and max depth.
+ * `loadParent` should return the next parent row (or null when missing).
+ */
+async function validateTextTemplateParentChain(input) {
+    const parentId = input.parentId?.trim() || null;
+    if (!parentId) {
+        return { ok: true };
+    }
+    const selfId = input.id?.trim() || null;
+    if (selfId && parentId === selfId) {
+        return { ok: false, error: 'A text template cannot be its own parent.' };
+    }
+    const maxDepth = input.maxDepth ?? AXM_TEXT_TEMPLATE_MAX_PARENT_DEPTH;
+    const visited = new Set();
+    if (selfId) {
+        visited.add(selfId);
+    }
+    let currentId = parentId;
+    let depth = 1;
+    while (currentId) {
+        if (visited.has(currentId)) {
+            return { ok: false, error: 'Text template parent chain contains a cycle.' };
+        }
+        if (depth > maxDepth) {
+            return {
+                ok: false,
+                error: `Text template parent chain exceeds the maximum depth of ${maxDepth}.`,
+            };
+        }
+        visited.add(currentId);
+        const parent = await input.loadParent(currentId);
+        if (!parent) {
+            return { ok: false, error: `Parent text template not found (id: ${currentId}).` };
+        }
+        if ((parent.kind ?? AXM_TEXT_TEMPLATE_KIND.Content) !== AXM_TEXT_TEMPLATE_KIND.Master) {
+            return { ok: false, error: 'Parent text template must be a master template.' };
+        }
+        currentId = parent.parentId?.trim() || null;
+        depth += 1;
+    }
+    return { ok: true };
+}
+//#endregion
+
+//#region ----- Text template render contracts -----
+/** Server + client command key for rendering a text template channel. */
+const AXM_TEXT_TEMPLATE_RENDER_COMMAND_KEY = 'ContentManagement:TextTemplate:Render';
+//#endregion
+//#region ----- Text template draft preview contracts -----
+/** Server command key for previewing unsaved draft text template content. */
+const AXM_TEXT_TEMPLATE_PREVIEW_COMMAND_KEY = 'ContentManagement:TextTemplate:Preview';
+//#endregion
+
+//#region ----- Seeded text template ids -----
+/**
+ * Namespace for {@link tenantMasterId} when cloning text templates per tenant
+ * (`packs` SetupTenant → `content-management.common-setup`).
+ */
+const AXM_TEXT_TEMPLATE_TENANT_MASTER_NAMESPACE = 'content';
+/**
+ * Canonical ContentManagement.TextTemplate ids used as SetupTenant clone keys
+ * and runtime lookups (resolve via tenantMasterId + tenantId).
+ * Keep aligned with packs `text-template.mock.ids.ts`.
+ *
+ * Prefix `c71000` — same as `mockStableUuid('c71000', seq)`.
+ */
+const AXM_TEXT_TEMPLATE_IDS = {
+    emailCompanyMaster: 'c7100001-0001-4111-b111-010101010101',
+    passwordReset: 'c7100002-0001-4111-b111-020202020202',
+    emailVerification: 'c7100003-0001-4111-b111-030303030303',
+    passwordChanged: 'c7100004-0001-4111-b111-040404040404',
+    ticketReceived: 'c7100005-0001-4111-b111-050505050505',
+    ticketResolved: 'c7100006-0001-4111-b111-060606060606',
+    employeeHappyBirthday: 'c7100007-0001-4111-b111-070707070707',
+    employeeJoiningCompany: 'c7100008-0001-4111-b111-080808080808',
+    /** Document expired — daily notifier (email + in-app). */
+    documentExpired: 'c7100009-0001-4111-b111-090909090909',
+    /** Document near expiry — daily notifier (email + in-app). */
+    documentNearExpiry: 'c710000a-0001-4111-b111-0a0a0a0a0a0a',
+    /** Company print master — header, border, footer around `[content]`. */
+    printCompanyMaster: 'c710000b-0001-4111-b111-0b0b0b0b0b0b',
+    /** Default questionnaire print child (title, date, `{{sessionBody}}`). */
+    questionnairePrint: 'c710000c-0001-4111-b111-0c0c0c0c0c0c',
+};
+//#endregion
+
+//#region ---- Contracts barrel ----
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMPermissionsKeys, AXM_TEXT_TEMPLATE_CONTENT_SLOT, AXM_TEXT_TEMPLATE_IDS, AXM_TEXT_TEMPLATE_KIND, AXM_TEXT_TEMPLATE_MAX_PARENT_DEPTH, AXM_TEXT_TEMPLATE_PREVIEW_COMMAND_KEY, AXM_TEXT_TEMPLATE_PRINT_CHANNEL, AXM_TEXT_TEMPLATE_RENDER_COMMAND_KEY, AXM_TEXT_TEMPLATE_TENANT_MASTER_NAMESPACE, AXPContentDocumentsPermissionKeys, AXPContentManagementMenuKeys, RootConfig, collectTextTemplatePlaceholderNames, composeTextTemplateBodyChain, defaultShortDatePatternForLocale, defaultShortTimePatternForLocale, formatTextTemplateDate, formatTextTemplateMergeValues, formatTextTemplateNumber, parseTextTemplateDateValue, replaceTextTemplateContentSlot, replaceTextTemplatePlaceholders, resolveTextTemplateCalendar, resolveTextTemplateLocalizedString, textTemplateContainsContentSlot, validateTextTemplateContentSlots, validateTextTemplateParentChain };
+//# sourceMappingURL=acorex-platform-module-content-management-client-contracts.mjs.map