kuzzle-device-manager 3.0.0-3-dev.19 → 3.0.0-3-dev.21

package/dist/lib/modules/model/ModelService.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelService = void 0;
 const kuzzle_1 = require("kuzzle");
@@ -11,6 +14,8 @@ const AJValidator_1 = require("../shared/utils/AJValidator");
 const SchemaValidationError_1 = require("../shared/errors/SchemaValidationError");
 const MeasuresDuplicates_1 = require("./MeasuresDuplicates");
 const MeasuresNamesDuplicatesError_1 = require("./MeasuresNamesDuplicatesError");
+const lodash_1 = __importDefault(require("lodash"));
+const MetadataReferential_1 = require("./MetadataReferential");
 class ModelService extends shared_1.BaseService {
     constructor(plugin, logger) {
         super(plugin);
@@ -18,8 +23,8 @@ class ModelService extends shared_1.BaseService {
         this.registerAskEvents();
     }
     registerAskEvents() {
-        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:asset:get", async ({ engineGroups, engineId, model }) => {
-            const assetModel = await this.getAsset(engineGroups, engineId, model);
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:asset:get", async ({ tenantClasses, index, model }) => {
+            const assetModel = await this.getAsset(tenantClasses, index, model);
             return assetModel._source;
         });
         (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:device:get", async ({ model }) => {
@@ -30,8 +35,9 @@ class ModelService extends shared_1.BaseService {
             const groupModel = await this.getGroup(model);
             return groupModel._source;
         });
-        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:measure:get", async ({ type, engineId }) => {
-            const measureModel = await this.getMeasure(type, engineId);
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:metadata-referential:get", async () => this.getMetadataReferential());
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:measure:get", async ({ type, index }) => {
+            const measureModel = await this.getMeasure(type, index);
             return measureModel._source;
         });
         const genericModelsHandler = async (documents, request) => {
@@ -155,160 +161,180 @@ class ModelService extends shared_1.BaseService {
         }
         return { models, strict, type };
     }
-    async writeAsset(engineGroups, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, engineIds, icon) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
-        }
-        if (engineIds?.length && engineGroups?.length) {
-            throw new kuzzle_1.BadRequestError(`"engineIds" and "engineGroups" are mutually exclusive on an asset model.`);
-        }
-        const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
-        if (duplicates.length > 0) {
-            throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Asset model measures contain one or multiple duplicate measure name", duplicates);
-        }
-        const normalizedEngineGroups = engineGroups.includes("commons")
-            ? ["commons"]
-            : engineGroups;
-        // Anti-shadowing: reject if a model with the same name exists at a different scope level
-        const isGlobal = normalizedEngineGroups.includes("commons") &&
-            (!engineIds || engineIds.length === 0);
-        const isTenantScoped = engineIds && engineIds.length > 0;
-        const isGroupScoped = !isGlobal && !isTenantScoped;
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        const existing = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
-            query: {
-                bool: {
-                    must: [
-                        { term: { type: "asset" } },
-                        { term: { "asset.model": model } },
-                    ],
-                },
-            },
-        }, { size: 10 });
-        for (const hit of existing.hits) {
-            const doc = hit._source;
-            const docIsGlobal = doc.engineGroups?.includes("commons") &&
-                (!doc.engineIds || doc.engineIds.length === 0);
-            const docIsTenantScoped = doc.engineIds && doc.engineIds.length > 0;
-            const docIsGroupScoped = !docIsGlobal && !docIsTenantScoped;
-            // Same scope level: allow overwrite
-            if (isGlobal && docIsGlobal) {
-                continue;
-            }
-            if (isTenantScoped && docIsTenantScoped) {
-                continue;
-            }
-            if (isGroupScoped && docIsGroupScoped) {
-                continue;
+    async writeAsset(tenantClasses, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, indexes, icon) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
             }
-            // Different scope levels: reject
-            if (docIsGlobal) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists as a global (commons) model. A model cannot exist at multiple scopes.`);
+            if (indexes?.length && tenantClasses?.length) {
+                throw new kuzzle_1.BadRequestError(`"indexes" and "tenantClasses" are mutually exclusive on an asset model.`);
             }
-            if (isGlobal) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at a non-global scope. A model cannot exist at multiple scopes.`);
+            const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
+            if (duplicates.length > 0) {
+                throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Asset model measures contain one or multiple duplicate measure name", duplicates);
             }
-            if (isTenantScoped && docIsGroupScoped) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at group scope. A model cannot be both group-scoped and tenant-scoped.`);
+            const normalizedTenantClasses = tenantClasses.includes("commons")
+                ? ["commons"]
+                : tenantClasses;
+            // Anti-shadowing: reject if a model with the same name exists at a different scope level
+            const isGlobal = normalizedTenantClasses.includes("commons") &&
+                (!indexes || indexes.length === 0);
+            const isTenantScoped = indexes && indexes.length > 0;
+            const isGroupScoped = !isGlobal && !isTenantScoped;
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            const existing = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
+                query: {
+                    bool: {
+                        must: [
+                            { term: { type: "asset" } },
+                            { term: { "asset.model": model } },
+                        ],
+                    },
+                },
+            }, { size: 10 });
+            for (const hit of existing.hits) {
+                const doc = hit._source;
+                const docIsGlobal = doc.tenantClasses?.includes("commons") &&
+                    (!doc.indexes || doc.indexes.length === 0);
+                const docIsTenantScoped = doc.indexes && doc.indexes.length > 0;
+                const docIsGroupScoped = !docIsGlobal && !docIsTenantScoped;
+                // Same scope level: allow overwrite
+                if (isGlobal && docIsGlobal) {
+                    continue;
+                }
+                if (isTenantScoped && docIsTenantScoped) {
+                    continue;
+                }
+                if (isGroupScoped && docIsGroupScoped) {
+                    continue;
+                }
+                // Different scope levels: reject
+                if (docIsGlobal) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists as a global (commons) model. A model cannot exist at multiple scopes.`);
+                }
+                if (isGlobal) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at a non-global scope. A model cannot exist at multiple scopes.`);
+                }
+                if (isTenantScoped && docIsGroupScoped) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at group scope. A model cannot be both group-scoped and tenant-scoped.`);
+                }
+                if (isGroupScoped && docIsTenantScoped) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at tenant scope. A model cannot be both group-scoped and tenant-scoped.`);
+                }
             }
-            if (isGroupScoped && docIsTenantScoped) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at tenant scope. A model cannot be both group-scoped and tenant-scoped.`);
+            const { fields: metadata, resolvedMappings } = await this.resolveMetadata("asset", model, { defaultMetadata, metadataDetails, metadataMappings });
+            const modelContent = {
+                asset: {
+                    ...metadata,
+                    icon,
+                    locales,
+                    measures,
+                    metadataGroups,
+                    model,
+                    tooltipModels,
+                },
+                ...(indexes?.length
+                    ? { indexes }
+                    : { tenantClasses: normalizedTenantClasses }),
+                type: "asset",
+            };
+            const modelId = ModelSerializer_1.ModelSerializer.id("asset", modelContent);
+            const stored = await this.getStoredModel(modelId);
+            this.checkReferentialOnly("asset", model, metadataMappings, stored);
+            this.checkDefaultValues(resolvedMappings, metadata.defaultMetadata);
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "asset" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`New assets mappings are causing conflicts`, conflicts);
             }
-        }
-        const modelContent = {
-            asset: {
-                defaultMetadata,
-                icon,
-                locales,
-                measures,
-                metadataDetails,
-                metadataGroups,
-                metadataMappings,
-                model,
-                tooltipModels,
-            },
-            ...(engineIds?.length
-                ? { engineIds }
-                : { engineGroups: normalizedEngineGroups }),
-            type: "asset",
-        };
-        this.checkDefaultValues(metadataMappings, defaultMetadata);
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "asset" } });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`New assets mappings are causing conflicts`, conflicts);
-        }
-        const assetModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("asset", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
-            assetModel: assetModel._source,
+            const assetModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("asset", modelContent), modelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(modelId, stored);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
+                assetModel: assetModel._source,
+            });
+            return assetModel;
         });
-        return assetModel;
     }
     async writeDevice(model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, icon) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Device model "${model}" must be PascalCase.`);
-        }
-        const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
-        if (duplicates.length > 0) {
-            throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Device model measures contain one or multiple duplicate measure name", duplicates);
-        }
-        const modelContent = {
-            device: {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Device model "${model}" must be PascalCase.`);
+            }
+            const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
+            if (duplicates.length > 0) {
+                throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Device model measures contain one or multiple duplicate measure name", duplicates);
+            }
+            const { fields: metadata } = await this.resolveMetadata("device", model, {
                 defaultMetadata,
-                icon,
-                measures,
                 metadataDetails,
-                metadataGroups,
                 metadataMappings,
-                model,
-            },
-            type: "device",
-        };
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "device" } });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`New devices mappings are causing conflicts`, conflicts);
-        }
-        const deviceModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("device", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:device:refresh-model", {
-            deviceModel: modelContent,
+            });
+            const modelContent = {
+                device: {
+                    ...metadata,
+                    icon,
+                    measures,
+                    metadataGroups,
+                    model,
+                },
+                type: "device",
+            };
+            const modelId = ModelSerializer_1.ModelSerializer.id("device", modelContent);
+            const stored = await this.getStoredModel(modelId);
+            this.checkReferentialOnly("device", model, metadataMappings, stored);
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "device" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`New devices mappings are causing conflicts`, conflicts);
+            }
+            const deviceModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("device", modelContent), modelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(modelId, stored);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:device:refresh-model", {
+                deviceModel: modelContent,
+            });
+            return deviceModel;
         });
-        return deviceModel;
     }
-    async writeGroup(engineGroups, model, affinity, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, icon, locales) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
-        }
-        if (engineGroups.includes("commons")) {
-            engineGroups = ["commons"];
-        }
-        const groupAffinity = this.checkGroupAffinity(affinity);
-        const modelContent = {
-            engineGroups,
-            group: {
-                affinity: groupAffinity,
+    async writeGroup(tenantClasses, model, affinity, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, icon, locales) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
+            }
+            if (tenantClasses.includes("commons")) {
+                tenantClasses = ["commons"];
+            }
+            const groupAffinity = this.checkGroupAffinity(affinity);
+            const { fields: metadata } = await this.resolveMetadata("group", model, {
                 defaultMetadata,
-                icon,
-                locales,
                 metadataDetails,
-                metadataGroups,
                 metadataMappings,
-                model,
-            },
-            type: "group",
-        };
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { groupModels: [modelContent] });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`New group mappings are causing conflicts`, conflicts);
-        }
-        const groupModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("group", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-        return groupModel;
+            });
+            const modelContent = {
+                tenantClasses,
+                group: {
+                    ...metadata,
+                    affinity: groupAffinity,
+                    icon,
+                    locales,
+                    metadataGroups,
+                    model,
+                },
+                type: "group",
+            };
+            const modelId = ModelSerializer_1.ModelSerializer.id("group", modelContent);
+            const stored = await this.getStoredModel(modelId);
+            this.checkReferentialOnly("group", model, metadataMappings, stored);
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { groupModels: [modelContent] });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`New group mappings are causing conflicts`, conflicts);
+            }
+            const groupModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("group", modelContent), modelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(modelId, stored);
+            return groupModel;
+        });
     }
-    async writeMeasure(type, valuesMappings, validationSchema, valuesDetails, locales, engineIds, icon) {
+    async writeMeasure(type, valuesMappings, validationSchema, valuesDetails, locales, indexes, icon) {
         const modelContent = {
             measure: {
                 icon,
@@ -319,11 +345,11 @@ class ModelService extends shared_1.BaseService {
             },
             type: "measure",
         };
-        if (engineIds?.length) {
-            modelContent.engineIds = engineIds;
+        if (indexes?.length) {
+            modelContent.indexes = indexes;
         }
         // Anti-shadowing: a measure type must be either global or tenant-scoped, not both
-        await this.checkMeasureShadowing(type, engineIds);
+        await this.checkMeasureShadowing(type, indexes);
         if (validationSchema) {
             try {
                 (0, AJValidator_1.addSchemaToCache)(type, validationSchema);
@@ -337,9 +363,11 @@ class ModelService extends shared_1.BaseService {
         if (conflicts.length > 0) {
             throw new MappingsConflictsError_1.MappingsConflictsError(`New assets mappings are causing conflicts`, conflicts);
         }
-        const measureModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("measure", modelContent), modelContent);
+        const modelId = ModelSerializer_1.ModelSerializer.id("measure", modelContent);
+        const stored = await this.getStoredModel(modelId);
+        const measureModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, modelId, modelContent);
         await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
+        await this.updateEnginesOrRestore(modelId, stored);
         return measureModel;
     }
     async deleteAsset(_id) {
@@ -355,7 +383,7 @@ class ModelService extends shared_1.BaseService {
         await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
     }
     /**
-     * List all asset models regardless of engine group scope.
+     * List all asset models regardless of tenant class scope.
      * Used for super admin global view.
      */
     async listAllAssets() {
@@ -365,14 +393,14 @@ class ModelService extends shared_1.BaseService {
     /**
      * Check if an engine (tenant) exists by its ID.
      */
-    async engineExists(engineId) {
+    async engineExists(index) {
         try {
             const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.CONFIG, {
                 query: {
                     bool: {
                         must: [
                             { term: { type: "engine-device-manager" } },
-                            { term: { "engine.index": engineId } },
+                            { term: { "engine.index": index } },
                         ],
                     },
                 },
@@ -384,27 +412,11 @@ class ModelService extends shared_1.BaseService {
         }
     }
     /**
-     * Check if the requesting user has access to an engine.
-     */
-    async userHasEngineAccess(request, engineId) {
-        try {
-            const result = await this.sdk.security.checkRights(request.context.user?._id, {
-                controller: "device-manager/assets",
-                action: "get",
-                index: engineId,
-            });
-            return result;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Find engine groups that don't exist.
+     * Find tenant classes that don't exist.
      */
-    async findInvalidEngineGroups(engineGroups) {
+    async findInvalidTenantClasses(tenantClasses) {
         // "commons" is always valid
-        const toCheck = engineGroups.filter((g) => g !== "commons");
+        const toCheck = tenantClasses.filter((g) => g !== "commons");
         if (toCheck.length === 0) {
             return [];
         }
@@ -413,11 +425,11 @@ class ModelService extends shared_1.BaseService {
                 equals: { type: "engine-device-manager" },
             },
         }, { lang: "koncorde", size: 5000 });
-        const existingGroups = new Set(result.hits.map((h) => h._source.engine?.group));
-        return toCheck.filter((g) => !existingGroups.has(g));
+        const existingTenantClasses = new Set(result.hits.map((h) => h._source.engine?.group));
+        return toCheck.filter((g) => !existingTenantClasses.has(g));
     }
-    async listAsset(engineGroups, engineId) {
-        const result = await this.searchAssets(engineGroups, engineId, {
+    async listAsset(tenantClasses, index) {
+        const result = await this.searchAssets(tenantClasses, index, {
             searchBody: {
                 sort: { "asset.model": "asc" },
             },
@@ -434,8 +446,8 @@ class ModelService extends shared_1.BaseService {
         });
         return result.hits;
     }
-    async listGroups(engineGroups) {
-        const result = await this.searchGroups(engineGroups, {
+    async listGroups(tenantClasses) {
+        const result = await this.searchGroups(tenantClasses, {
             searchBody: {
                 sort: { "group.model": "asc" },
             },
@@ -443,8 +455,8 @@ class ModelService extends shared_1.BaseService {
         });
         return result.hits;
     }
-    async listMeasures(engineId) {
-        const result = await this.searchMeasures(engineId, {
+    async listMeasures(index) {
+        const result = await this.searchMeasures(index, {
             searchBody: {
                 sort: { "measure.type": "asc" },
             },
@@ -452,26 +464,26 @@ class ModelService extends shared_1.BaseService {
         });
         return result.hits;
     }
-    async searchAssets(engineGroups, engineId, searchParams) {
-        const scopeFilter = engineId
+    async searchAssets(tenantClasses, index, searchParams) {
+        const scopeFilter = index
             ? {
                 bool: {
                     should: [
                         {
                             bool: {
-                                must: [{ term: { engineIds: engineId } }],
+                                must: [{ term: { indexes: index } }],
                             },
                         },
                         {
                             bool: {
-                                must: [{ terms: { engineGroups } }],
-                                must_not: [{ exists: { field: "engineIds" } }],
+                                must: [{ terms: { tenantClasses } }],
+                                must_not: [{ exists: { field: "indexes" } }],
                             },
                         },
                         {
                             bool: {
-                                must: [{ term: { engineGroups: "commons" } }],
-                                must_not: [{ exists: { field: "engineIds" } }],
+                                must: [{ term: { tenantClasses: "commons" } }],
+                                must_not: [{ exists: { field: "indexes" } }],
                             },
                         },
                     ],
@@ -482,14 +494,14 @@ class ModelService extends shared_1.BaseService {
                     should: [
                         {
                             bool: {
-                                must: [{ terms: { engineGroups } }],
-                                must_not: [{ exists: { field: "engineIds" } }],
+                                must: [{ terms: { tenantClasses } }],
+                                must_not: [{ exists: { field: "indexes" } }],
                             },
                         },
                         {
                             bool: {
-                                must: [{ term: { engineGroups: "commons" } }],
-                                must_not: [{ exists: { field: "engineIds" } }],
+                                must: [{ term: { tenantClasses: "commons" } }],
+                                must_not: [{ exists: { field: "indexes" } }],
                             },
                         },
                     ],
@@ -533,7 +545,7 @@ class ModelService extends shared_1.BaseService {
             size: searchParams.size,
         });
     }
-    async searchGroups(engineGroups, searchParams) {
+    async searchGroups(tenantClasses, searchParams) {
         const query = {
             bool: {
                 must: [
@@ -542,8 +554,8 @@ class ModelService extends shared_1.BaseService {
                     {
                         bool: {
                             should: [
-                                { terms: { engineGroups } },
-                                { term: { engineGroups: "commons" } },
+                                { terms: { tenantClasses } },
+                                { term: { tenantClasses: "commons" } },
                             ],
                         },
                     },
@@ -560,19 +572,19 @@ class ModelService extends shared_1.BaseService {
             size: searchParams.size,
         });
     }
-    async searchMeasures(engineId, searchParams) {
-        const scopeFilter = engineId
+    async searchMeasures(index, searchParams) {
+        const scopeFilter = index
             ? {
                 bool: {
                     should: [
-                        { term: { engineIds: engineId } },
-                        { bool: { must_not: [{ exists: { field: "engineIds" } }] } },
+                        { term: { indexes: index } },
+                        { bool: { must_not: [{ exists: { field: "indexes" } }] } },
                     ],
                 },
             }
             : {
                 bool: {
-                    must_not: [{ exists: { field: "engineIds" } }],
+                    must_not: [{ exists: { field: "indexes" } }],
                 },
             };
         const query = {
@@ -614,16 +626,16 @@ class ModelService extends shared_1.BaseService {
         const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
         return result.total > 0;
     }
-    async getAsset(engineGroups, engineId, model) {
+    async getAsset(tenantClasses, index, model) {
         const baseFilter = [
             { term: { type: "asset" } },
             { term: { "asset.model": model } },
         ];
         // Priority 1: tenant-scoped model for this specific engine
-        if (engineId) {
+        if (index) {
             const tenantQuery = {
                 bool: {
-                    must: [...baseFilter, { term: { engineIds: engineId } }],
+                    must: [...baseFilter, { term: { indexes: index } }],
                 },
             };
             const tenantResult = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: tenantQuery }, { lang: "elasticsearch", size: 1 });
@@ -631,11 +643,11 @@ class ModelService extends shared_1.BaseService {
                 return tenantResult.hits[0];
             }
         }
-        // Priority 2: group-scoped model (no engineIds field)
+        // Priority 2: group-scoped model (no indexes field)
         const groupQuery = {
             bool: {
-                must: [...baseFilter, { terms: { engineGroups } }],
-                must_not: [{ exists: { field: "engineIds" } }],
+                must: [...baseFilter, { terms: { tenantClasses } }],
+                must_not: [{ exists: { field: "indexes" } }],
             },
         };
         const groupResult = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: groupQuery }, { lang: "elasticsearch", size: 1 });
@@ -645,15 +657,15 @@ class ModelService extends shared_1.BaseService {
         // Priority 3: commons model
         const commonsQuery = {
             bool: {
-                must: [...baseFilter, { term: { engineGroups: "commons" } }],
-                must_not: [{ exists: { field: "engineIds" } }],
+                must: [...baseFilter, { term: { tenantClasses: "commons" } }],
+                must_not: [{ exists: { field: "indexes" } }],
             },
         };
         const commonsResult = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: commonsQuery }, { lang: "elasticsearch", size: 1 });
         if (commonsResult.total > 0) {
             return commonsResult.hits[0];
         }
-        throw new kuzzle_1.NotFoundError(`Unknown Asset model "${model}" for engineGroups ${engineGroups.join(", ")}.`);
+        throw new kuzzle_1.NotFoundError(`Unknown Asset model "${model}" for tenantClasses ${tenantClasses.join(", ")}.`);
     }
     async getDevice(model) {
         const query = {
@@ -684,23 +696,23 @@ class ModelService extends shared_1.BaseService {
         }
         return result.hits[0];
     }
-    async getMeasure(type, engineId) {
+    async getMeasure(type, index) {
         const baseFilter = [
             { term: { type: "measure" } },
             { term: { "measure.type": type } },
         ];
-        const scopeFilter = engineId
+        const scopeFilter = index
             ? {
                 bool: {
                     should: [
-                        { term: { engineIds: engineId } },
-                        { bool: { must_not: [{ exists: { field: "engineIds" } }] } },
+                        { term: { indexes: index } },
+                        { bool: { must_not: [{ exists: { field: "indexes" } }] } },
                     ],
                 },
             }
             : {
                 bool: {
-                    must_not: [{ exists: { field: "engineIds" } }],
+                    must_not: [{ exists: { field: "indexes" } }],
                 },
             };
         const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
@@ -719,8 +731,8 @@ class ModelService extends shared_1.BaseService {
      * Checks that creating/updating a measure model does not shadow an existing
      * one at a different scope (global vs tenant-scoped).
      */
-    async checkMeasureShadowing(type, engineIds) {
-        const isNewTenantScoped = engineIds && engineIds.length > 0;
+    async checkMeasureShadowing(type, indexes) {
+        const isNewTenantScoped = indexes && indexes.length > 0;
         // Check for existing measures of the same type at the opposite scope
         const conflictQuery = isNewTenantScoped
             ? {
@@ -730,7 +742,7 @@ class ModelService extends shared_1.BaseService {
                         { term: { type: "measure" } },
                         { term: { "measure.type": type } },
                     ],
-                    must_not: [{ exists: { field: "engineIds" } }],
+                    must_not: [{ exists: { field: "indexes" } }],
                 },
             }
             : {
@@ -739,7 +751,7 @@ class ModelService extends shared_1.BaseService {
                     must: [
                         { term: { type: "measure" } },
                         { term: { "measure.type": type } },
-                        { exists: { field: "engineIds" } },
+                        { exists: { field: "indexes" } },
                     ],
                 },
             };
@@ -752,61 +764,334 @@ class ModelService extends shared_1.BaseService {
     /**
      * Update an asset model
      */
-    async updateAsset(engineGroups, engineId, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, icon, request) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
-        }
-        this.checkDefaultValues(metadataMappings, defaultMetadata);
-        const existingAsset = await this.getAsset(engineGroups, engineId, model);
-        // The field must be deleted if an element of the table is to be deleted
-        await this.sdk.document.deleteFields(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingAsset._id, [
-            "asset.tooltipModels",
-            "asset.metadataMappings",
-            "asset.defaultMetadata",
-            "asset.metadataDetails",
-            "asset.metadataGroups",
-        ], { source: true });
-        const measuresUpdated = measures.length === 0 ? existingAsset._source.asset.measures : measures;
-        // Preserve the existing scope: scope (engineGroups / engineIds) is decided
-        // at write time and must not be silently rewritten by an update payload.
-        // This also enforces engineGroups / engineIds mutual exclusivity (KZLPRD-1192).
-        const assetModelContent = {
-            asset: {
-                defaultMetadata,
-                icon: icon ?? existingAsset._source.asset.icon,
-                locales,
-                measures: measuresUpdated,
-                metadataDetails,
-                metadataGroups,
+    async updateAsset(tenantClasses, index, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, icon, request) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
+            }
+            const existingAsset = await this.getAsset(tenantClasses, index, model);
+            this.checkReferentialOnly("asset", model, metadataMappings, existingAsset._source);
+            const { fields: metadata, resolvedMappings } = await this.resolveMetadata("asset", model, { defaultMetadata, metadataDetails, metadataMappings });
+            this.checkDefaultValues(resolvedMappings, metadata.defaultMetadata);
+            const measuresUpdated = measures.length === 0 ? existingAsset._source.asset.measures : measures;
+            // Preserve the existing scope: scope (tenantClasses / indexes) is decided
+            // at write time and must not be silently rewritten by an update payload.
+            // This also enforces tenantClasses / indexes mutual exclusivity (KZLPRD-1192).
+            const assetModelContent = {
+                asset: {
+                    ...metadata,
+                    icon: icon ?? existingAsset._source.asset.icon,
+                    locales,
+                    measures: measuresUpdated,
+                    metadataGroups,
+                    model,
+                    tooltipModels,
+                },
+                tenantClasses: existingAsset._source.tenantClasses,
+                indexes: existingAsset._source.indexes,
+                type: "asset",
+            };
+            const assetModel = {
+                _id: existingAsset._id,
+                _source: assetModelContent,
+            };
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [assetModelContent], type: "asset" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Assets mappings are causing conflicts`, conflicts);
+            }
+            // The field must be deleted if an element of the table is to be deleted.
+            // ? Only after the conflicts check, so a rejected update leaves the model untouched
+            await this.sdk.document.deleteFields(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingAsset._id, [
+                "asset.tooltipModels",
+                "asset.metadataMappings",
+                "asset.defaultMetadata",
+                "asset.metadataDetails",
+                "asset.metadataGroups",
+            ], { source: true });
+            const endDocument = await this.updateDocument(request, assetModel, {
+                collection: plugin_1.InternalCollection.MODELS,
+                index: this.config.platformIndex,
+            }, { source: true });
+            // ? Only update indexes and refresh asset models when necessary
+            if (Object.keys(metadata.metadataMappings).length > 0 ||
+                measures.length > 0) {
+                await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+                await this.updateEnginesOrRestore(existingAsset._id, existingAsset._source);
+                await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
+                    assetModel: endDocument._source,
+                });
+            }
+            return endDocument;
+        });
+    }
+    /**
+     * Adds metadata of the metadata referential to a device model.
+     *
+     * Device models are additive only from the API: every existing metadata must be kept unchanged,
+     * new metadata must come from the referential. Metadata details and default values can change.
+     * The engines mappings are updated and the devices get the new metadata with their default value.
+     *
+     * @throws BadRequestError if an existing metadata is missing or changed, or a new one is inline
+     * @throws MappingsConflictsError if the new metadata conflict with the existing mappings
+     */
+    async updateDevice(model, { defaultMetadata, metadataDetails, metadataMappings }) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            const existingDevice = await this.getDevice(model);
+            const existing = existingDevice._source.device;
+            const existingMappings = existing.metadataMappings ?? {};
+            const removed = Object.keys(existingMappings).filter((name) => !lodash_1.default.isEqual(existingMappings[name], metadataMappings[name]));
+            if (removed.length > 0) {
+                throw new kuzzle_1.BadRequestError(`Device model "${model}" metadata cannot be removed or modified: ${removed.join(", ")}`);
+            }
+            const inline = Object.keys(metadataMappings).filter((name) => !(name in existingMappings) &&
+                !(0, MetadataReferential_1.isReferentialMapping)(metadataMappings[name]));
+            if (inline.length > 0) {
+                throw new kuzzle_1.BadRequestError(`New metadata of device model "${model}" must come from the metadata referential, inline metadata: ${inline.join(", ")}`);
+            }
+            const { fields: metadata } = await this.resolveMetadata("device", model, {
+                defaultMetadata: defaultMetadata ?? existing.defaultMetadata,
+                metadataDetails: metadataDetails ?? existing.metadataDetails,
                 metadataMappings,
-                model,
-                tooltipModels,
+            });
+            const deviceModelContent = {
+                ...existingDevice._source,
+                device: { ...existing, ...metadata },
+            };
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [deviceModelContent], type: "device" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Devices mappings are causing conflicts`, conflicts);
+            }
+            const deviceModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingDevice._id, deviceModelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(existingDevice._id, existingDevice._source);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:device:refresh-model", { deviceModel: deviceModel._source });
+            return deviceModel;
+        });
+    }
+    /**
+     * Returns the group model available for the given tenant classes:
+     * a model of these classes first, then a commons model.
+     *
+     * @throws NotFoundError if no group model with this name is available
+     */
+    async getScopedGroup(tenantClasses, model) {
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
+            query: {
+                and: [
+                    { equals: { type: "group" } },
+                    { equals: { "group.model": model } },
+                ],
             },
-            engineGroups: existingAsset._source.engineGroups,
-            engineIds: existingAsset._source.engineIds,
-            type: "asset",
-        };
-        const assetModel = {
-            _id: existingAsset._id,
-            _source: assetModelContent,
-        };
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [assetModelContent], type: "asset" } });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`Assets mappings are causing conflicts`, conflicts);
-        }
-        const endDocument = await this.updateDocument(request, assetModel, {
-            collection: plugin_1.InternalCollection.MODELS,
-            engineId: this.config.platformIndex,
-        }, { source: true });
-        // ? Only update engineIds and refresh asset models when necessary
-        if (Object.keys(metadataMappings).length > 0 || measures.length > 0) {
+        }, { lang: "koncorde", size: 100 });
+        const scoped = result.hits.find(({ _source }) => _source.tenantClasses.some((tenantClass) => tenantClass !== "commons" && tenantClasses.includes(tenantClass)));
+        const common = result.hits.find(({ _source }) => _source.tenantClasses.includes("commons"));
+        const groupModel = scoped ?? common;
+        if (!groupModel) {
+            throw new kuzzle_1.NotFoundError(`Unknown Group model "${model}" for tenant classes "${tenantClasses.join(", ")}".`);
+        }
+        return { _id: groupModel._id, _source: groupModel._source };
+    }
+    /**
+     * Updates a group model, keeping its scope.
+     * Affinity and icon are kept when omitted.
+     *
+     * The engines mappings are updated and the groups of the model are refreshed.
+     *
+     * @throws MappingsConflictsError if the new mappings conflict with the existing ones
+     */
+    async updateGroup(tenantClasses, model, { affinity, defaultMetadata, icon, locales, metadataDetails, metadataGroups, metadataMappings, }) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
+            }
+            const existingGroup = await this.getScopedGroup(tenantClasses, model);
+            const existing = existingGroup._source.group;
+            this.checkReferentialOnly("group", model, metadataMappings, existingGroup._source);
+            const { fields: metadata, resolvedMappings } = await this.resolveMetadata("group", model, { defaultMetadata, metadataDetails, metadataMappings });
+            this.checkDefaultValues(resolvedMappings, metadata.defaultMetadata);
+            const groupModelContent = {
+                tenantClasses: existingGroup._source.tenantClasses,
+                group: {
+                    ...metadata,
+                    affinity: affinity === undefined
+                        ? existing.affinity
+                        : this.checkGroupAffinity(affinity),
+                    icon: icon ?? existing.icon,
+                    locales,
+                    metadataGroups,
+                    model,
+                },
+                type: "group",
+            };
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { groupModels: [groupModelContent] });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Group mappings are causing conflicts`, conflicts);
+            }
+            const groupModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingGroup._id, groupModelContent);
             await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
-                assetModel: endDocument._source,
+            await this.updateEnginesOrRestore(existingGroup._id, existingGroup._source);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:group:refresh-model", {
+                groupModel: groupModel._source,
             });
+            return groupModel;
+        });
+    }
+    /**
+     * Validates the metadata of a model written through the API against the metadata referential
+     * and enriches the details and default values of the metadata coming from it
+     */
+    async resolveMetadata(modelType, model, fields) {
+        const enrichment = (0, MetadataReferential_1.enrichModelMetadata)(await this.getMetadataReferential(), fields, {
+            createError: (message) => new kuzzle_1.BadRequestError(message),
+            model,
+            modelType,
+        });
+        for (const warning of enrichment.warnings) {
+            this.logger.warn(warning);
+        }
+        return enrichment;
+    }
+    /**
+     * Resolves the referential metadata of stored models, to be returned by the API
+     */
+    async resolveModels(documents) {
+        const referential = await this.getMetadataReferential();
+        return documents.map((document) => ({
+            ...document,
+            _source: (0, MetadataReferential_1.resolveModelMetadata)(referential, document._source),
+        }));
+    }
+    async getMetadataReferential() {
+        return (0, MetadataReferential_1.fetchMetadataReferential)(this.sdk, this.config.platformIndex);
+    }
+    /**
+     * Creates a metadata of the metadata referential, or updates its details.
+     *
+     * The mappings of a new metadata are merged into the assets, devices and groups collections
+     * of every engine. They cannot be modified afterwards: only the locales, editor hint,
+     * default value and icon of an existing metadata can change. These are copied into the models
+     * using the metadata when they are written, the existing models are not modified.
+     *
+     * @throws BadRequestError if the mappings of an existing metadata are modified
+     * @throws MappingsConflictsError if the new metadata conflicts with an inline metadata of a model
+     *  or with the actual mappings of an engine collection
+     */
+    async writeMetadata(name, definition) {
+        (0, MetadataReferential_1.checkMetadataReferentialEntry)(name, definition, (message) => new kuzzle_1.BadRequestError(message));
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            const stored = await this.getMetadataReferential();
+            const entry = {
+                locales: {},
+                ...lodash_1.default.omit(definition, "managed"),
+            };
+            this.checkUnmanagedMetadata(stored, name);
+            if (stored[name]) {
+                if (!lodash_1.default.isEqual(stored[name].mappings, entry.mappings)) {
+                    throw new kuzzle_1.BadRequestError(`The mappings of metadata "${name}" cannot be modified, they are already merged into the engines collections`);
+                }
+                const referential = { ...stored, [name]: entry };
+                await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, referential);
+                return referential;
+            }
+            const models = await (0, MetadataReferential_1.fetchMetadataModels)(this.sdk, this.config.platformIndex);
+            const modelsConflicts = (0, MetadataReferential_1.getEntryModelsConflicts)(name, entry, models.map(({ _source }) => _source));
+            if (modelsConflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Metadata "${name}" conflicts with the metadata of models`, modelsConflicts);
+            }
+            const esConflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesMetadataConflict", { metadataMappings: { [name]: entry.mappings } });
+            if (esConflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Metadata "${name}" conflicts with the engines collections mappings`, esConflicts);
+            }
+            const referential = { ...stored, [name]: entry };
+            await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, referential);
+            try {
+                await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
+            }
+            catch (error) {
+                // ? A metadata rejected by Elasticsearch would make every next engines update fail
+                await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, stored);
+                throw error;
+            }
+            return referential;
+        });
+    }
+    /**
+     * Deletes a metadata of the metadata referential.
+     * Its mappings stay in the engines collections, Elasticsearch cannot remove them.
+     *
+     * @throws BadRequestError if a model still uses the metadata
+     */
+    async deleteMetadata(name) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            const referential = await this.getMetadataReferential();
+            if (!referential[name]) {
+                throw new kuzzle_1.NotFoundError(`Unknown metadata "${name}" in the metadata referential`);
+            }
+            this.checkUnmanagedMetadata(referential, name);
+            const referencingModels = await (0, MetadataReferential_1.fetchReferencingModels)(this.sdk, this.config.platformIndex, name);
+            if (referencingModels.length > 0) {
+                throw new kuzzle_1.BadRequestError(`Metadata "${name}" is still used by the models: ${referencingModels
+                    .map(({ _id }) => _id)
+                    .join(", ")}`);
+            }
+            const updatedReferential = lodash_1.default.omit(referential, name);
+            await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, updatedReferential);
+            return updatedReferential;
+        });
+    }
+    /**
+     * With the referentialOnly option, rejects the inline metadata a model write adds.
+     * The inline metadata already defined by the stored model are kept (legacy).
+     *
+     * @throws BadRequestError if new inline metadata are added
+     */
+    checkReferentialOnly(modelType, model, metadataMappings, stored) {
+        if (!this.config.models?.metadata?.referentialOnly) {
+            return;
+        }
+        const added = (0, MetadataReferential_1.getAddedInlineMetadata)(metadataMappings, stored);
+        if (added.length > 0) {
+            throw new kuzzle_1.BadRequestError(`New metadata of ${modelType} model "${model}" must come from the metadata referential, inline metadata: ${added.join(", ")}`);
+        }
+    }
+    /**
+     * Updates the engines collections. If Elasticsearch rejects the new mappings, the model is
+     * restored to its previous version (or deleted if it is new), otherwise every next engines
+     * update would fail on it.
+     */
+    async updateEnginesOrRestore(_id, previous) {
+        try {
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
+        }
+        catch (error) {
+            if (previous) {
+                await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id, lodash_1.default.omit(previous, "_kuzzle_info"), { refresh: "wait_for" });
+            }
+            else {
+                await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id, { refresh: "wait_for" });
+            }
+            throw error;
+        }
+    }
+    async getStoredModel(_id) {
+        try {
+            const { _source } = await this.sdk.document.get(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
+            return _source;
+        }
+        catch (error) {
+            if (error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * @throws BadRequestError if the metadata is registered from code
+     */
+    checkUnmanagedMetadata(referential, name) {
+        if (referential[name]?.managed) {
+            throw new kuzzle_1.BadRequestError(`Metadata "${name}" is registered from code, it cannot be modified or deleted through the API`);
         }
-        return endDocument;
     }
 }
 exports.ModelService = ModelService;