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

package/dist/lib/modules/model/ModelService.d.ts

@@ -2,11 +2,36 @@ import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService, SearchParams } from "../shared";
-import { AssetModelContent, DeviceModelContent, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, MetadataReferential, MetadataReferentialEntry, TooltipModels } from "./types/ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../measure";
 import { NamedMeasures } from "../decoder";
 import { KuzzleLogger } from "kuzzle-logger";
+import { MetadataModelContent } from "./MetadataReferential";
+/**
+ * Fields of a group model update.
+ * Affinity and icon are kept when omitted.
+ */
+export type GroupModelUpdate = {
+    affinity?: JSONObject;
+    defaultMetadata: JSONObject;
+    icon?: string;
+    locales: {
+        [valueName: string]: LocaleDetails;
+    };
+    metadataDetails: MetadataDetails;
+    metadataGroups: MetadataGroups;
+    metadataMappings: MetadataMappings;
+};
+/**
+ * Fields of a device model update.
+ * Metadata details and default values are kept when omitted.
+ */
+export type DeviceModelUpdate = {
+    defaultMetadata?: JSONObject;
+    metadataDetails?: MetadataDetails;
+    metadataMappings: MetadataMappings;
+};
 export declare class ModelService extends BaseService {
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
@@ -14,51 +39,47 @@ export declare class ModelService extends BaseService {
     private checkModelsConflicts;
     private checkDefaultValues;
     private checkGroupAffinity;
-    writeAsset(engineGroups: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
+    writeAsset(tenantClasses: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
-    }, engineIds?: string[], icon?: string): Promise<KDocument<AssetModelContent>>;
+    }, indexes?: string[], icon?: string): Promise<KDocument<AssetModelContent>>;
     writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, icon?: string): Promise<KDocument<DeviceModelContent>>;
-    writeGroup(engineGroups: string[], model: string, affinity: JSONObject, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, icon?: string, locales?: {
+    writeGroup(tenantClasses: string[], model: string, affinity: JSONObject, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, icon?: string, locales?: {
         [valueName: string]: LocaleDetails;
     }): Promise<KDocument<GroupModelContent>>;
     writeMeasure(type: string, valuesMappings: JSONObject, validationSchema?: SchemaObject, valuesDetails?: MeasureValuesDetails, locales?: {
         [valueName: string]: LocaleDetails;
-    }, engineIds?: string[], icon?: string): Promise<KDocument<MeasureModelContent>>;
+    }, indexes?: string[], icon?: string): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;
     deleteGroup(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;
     /**
-     * List all asset models regardless of engine group scope.
+     * List all asset models regardless of tenant class scope.
      * Used for super admin global view.
      */
     listAllAssets(): Promise<KDocument<AssetModelContent>[]>;
     /**
      * Check if an engine (tenant) exists by its ID.
      */
-    engineExists(engineId: string): Promise<boolean>;
-    /**
-     * Check if the requesting user has access to an engine.
-     */
-    userHasEngineAccess(request: KuzzleRequest, engineId: string): Promise<boolean>;
+    engineExists(index: string): Promise<boolean>;
     /**
-     * Find engine groups that don't exist.
+     * Find tenant classes that don't exist.
      */
-    findInvalidEngineGroups(engineGroups: string[]): Promise<string[]>;
-    listAsset(engineGroups: string[], engineId?: string): Promise<KDocument<AssetModelContent>[]>;
+    findInvalidTenantClasses(tenantClasses: string[]): Promise<string[]>;
+    listAsset(tenantClasses: string[], index?: string): Promise<KDocument<AssetModelContent>[]>;
     listDevices(): Promise<KDocument<DeviceModelContent>[]>;
-    listGroups(engineGroups: string[]): Promise<KDocument<GroupModelContent>[]>;
-    listMeasures(engineId?: string): Promise<KDocument<MeasureModelContent>[]>;
-    searchAssets(engineGroups: string[], engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
+    listGroups(tenantClasses: string[]): Promise<KDocument<GroupModelContent>[]>;
+    listMeasures(index?: string): Promise<KDocument<MeasureModelContent>[]>;
+    searchAssets(tenantClasses: string[], index: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
     searchDevices(searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<DeviceModelContent>>>;
-    searchGroups(engineGroups: string[], searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
-    searchMeasures(engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<MeasureModelContent>>>;
+    searchGroups(tenantClasses: string[], searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
+    searchMeasures(index: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<MeasureModelContent>>>;
     assetExists(model: string): Promise<boolean>;
     deviceExists(model: string): Promise<boolean>;
-    getAsset(engineGroups: string[], engineId: string | undefined, model: string): Promise<KDocument<AssetModelContent>>;
+    getAsset(tenantClasses: string[], index: string | undefined, model: string): Promise<KDocument<AssetModelContent>>;
     getDevice(model: string): Promise<KDocument<DeviceModelContent>>;
     getGroup(model: string): Promise<KDocument<GroupModelContent>>;
-    getMeasure(type: string, engineId?: string): Promise<KDocument<MeasureModelContent>>;
+    getMeasure(type: string, index?: string): Promise<KDocument<MeasureModelContent>>;
     /**
      * Checks that creating/updating a measure model does not shadow an existing
      * one at a different scope (global vs tenant-scoped).
@@ -67,7 +88,84 @@ export declare class ModelService extends BaseService {
     /**
      * Update an asset model
      */
-    updateAsset(engineGroups: string[], engineId: string | undefined, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
+    updateAsset(tenantClasses: string[], index: string | undefined, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
     }, icon: string | undefined, request: KuzzleRequest): Promise<KDocument<AssetModelContent>>;
+    /**
+     * 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
+     */
+    updateDevice(model: string, { defaultMetadata, metadataDetails, metadataMappings }: DeviceModelUpdate): Promise<KDocument<DeviceModelContent>>;
+    /**
+     * 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
+     */
+    private getScopedGroup;
+    /**
+     * 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
+     */
+    updateGroup(tenantClasses: string[], model: string, { affinity, defaultMetadata, icon, locales, metadataDetails, metadataGroups, metadataMappings, }: GroupModelUpdate): Promise<KDocument<GroupModelContent>>;
+    /**
+     * 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
+     */
+    private resolveMetadata;
+    /**
+     * Resolves the referential metadata of stored models, to be returned by the API
+     */
+    resolveModels<D extends {
+        _source: MetadataModelContent;
+    }>(documents: D[]): Promise<D[]>;
+    getMetadataReferential(): Promise<MetadataReferential>;
+    /**
+     * 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
+     */
+    writeMetadata(name: string, definition: MetadataReferentialEntry): Promise<MetadataReferential>;
+    /**
+     * 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
+     */
+    deleteMetadata(name: string): Promise<MetadataReferential>;
+    /**
+     * 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
+     */
+    private checkReferentialOnly;
+    /**
+     * 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.
+     */
+    private updateEnginesOrRestore;
+    private getStoredModel;
+    /**
+     * @throws BadRequestError if the metadata is registered from code
+     */
+    private checkUnmanagedMetadata;
 }

package/dist/lib/modules/model/ModelsConflicts.d.ts

@@ -36,3 +36,26 @@ export declare function getGroupConflicts(measures: GroupModelContent[], additio
  * @returns An array of ConflictChunk between current measures and the new measure
  */
 export declare function getMeasureConflicts(measures: MeasureModelContent[], additional: MeasureModelContent): ConflictChunk[];
+/**
+ * Find every conflicts between two sets of fields mappings (name => field mappings),
+ * e.g. metadata mappings or the metadata properties of an ES collection.
+ *
+ * Unlike findConflicts, a field defined with a type on one side and with properties on the other
+ * is a conflict, Elasticsearch cannot change a field from a value to an object or the opposite.
+ * Fields defined on one side only are not conflicts.
+ *
+ * @param currentMappings The current fields mappings
+ * @param newMappings The new fields mappings
+ * @param basePath Optional path to be added before conflicts paths
+ * @returns An array of MappingsConflict
+ */
+export declare function findMappingsConflicts(currentMappings: any, newMappings: any, basePath?: string): MappingsConflict[];
+/**
+ * Find every conflicts between two objects.
+ * WARNING: "undefined" type of conflicts are not registered
+ * @param sourceObject The source object used to compare
+ * @param objectToCompare The target object to compare to
+ * @param basePath Optional path to be added before conflicts paths
+ * @returns An array of MappingsConflict
+ */
+export declare function findConflicts(sourceObject: any, objectToCompare: any, basePath?: string): MappingsConflict[];

package/dist/lib/modules/model/ModelsController.d.ts

@@ -1,6 +1,6 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { ModelService } from "./ModelService";
-import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult, ApiModelDeleteGroupResult, ApiModelGetGroupResult, ApiModelListGroupsResult, ApiModelSearchGroupsResult, ApiModelWriteGroupResult } from "./types/ModelApi";
+import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult, ApiModelDeleteGroupResult, ApiModelGetGroupResult, ApiModelListGroupsResult, ApiModelSearchGroupsResult, ApiModelWriteGroupResult, ApiModelUpdateGroupResult, ApiModelUpdateDeviceResult, ApiModelGetMetadataReferentialResult, ApiModelWriteMetadataResult, ApiModelDeleteMetadataResult } from "./types/ModelApi";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class ModelsController {
     private modelService;
@@ -20,7 +20,7 @@ export declare class ModelsController {
     deleteGroup(request: KuzzleRequest): Promise<ApiModelDeleteGroupResult>;
     deleteMeasure(request: KuzzleRequest): Promise<ApiModelDeleteMeasureResult>;
     listAssets(request: KuzzleRequest): Promise<ApiModelListAssetsResult>;
-    listDevices(): Promise<ApiModelListDevicesResult>;
+    listDevices(request: KuzzleRequest): Promise<ApiModelListDevicesResult>;
     listGroups(request: KuzzleRequest): Promise<ApiModelListGroupsResult>;
     listMeasures(request: KuzzleRequest): Promise<ApiModelListMeasuresResult>;
     searchAssets(request: KuzzleRequest): Promise<ApiModelSearchAssetsResult>;
@@ -28,4 +28,13 @@ export declare class ModelsController {
     searchGroups(request: KuzzleRequest): Promise<ApiModelSearchGroupsResult>;
     searchMeasures(request: KuzzleRequest): Promise<ApiModelSearchMeasuresResult>;
     updateAsset(request: KuzzleRequest): Promise<ApiModelUpdateAssetResult>;
+    updateDevice(request: KuzzleRequest): Promise<ApiModelUpdateDeviceResult>;
+    updateGroup(request: KuzzleRequest): Promise<ApiModelUpdateGroupResult>;
+    /**
+     * Resolves the referential metadata of models, unless the rawModel flag is set
+     */
+    private resolveModels;
+    getMetadataReferential(): Promise<ApiModelGetMetadataReferentialResult>;
+    writeMetadata(request: KuzzleRequest): Promise<ApiModelWriteMetadataResult>;
+    deleteMetadata(request: KuzzleRequest): Promise<ApiModelDeleteMetadataResult>;
 }

package/dist/lib/modules/model/ModelsRegister.d.ts

@@ -1,7 +1,7 @@
 import { DeviceManagerPlugin } from "../plugin";
 import { NamedMeasures } from "../decoder";
 import { MeasureDefinition } from "../measure";
-import { GroupAffinity, LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { GroupAffinity, LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, MetadataReferentialEntry, TooltipModels } from "./types/ModelContent";
 import { JSONObject } from "kuzzle-sdk";
 export declare class ModelsRegister {
     private config;
@@ -10,14 +10,46 @@ export declare class ModelsRegister {
     private deviceModels;
     private groupModels;
     private measureModels;
+    private metadataReferential;
     private logger;
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
     loadModels(): Promise<void>;
+    /**
+     * Merges the metadata registered from code over the stored metadata referential and saves it.
+     * Metadata added through the API are kept, the details of metadata registered from code win.
+     *
+     * @throws PluginImplementationError if the mappings of a stored metadata are modified, or if a new
+     *  metadata conflicts with the stored models or the engines collections mappings
+     */
+    private loadMetadataReferential;
+    /**
+     * Checks the metadata registered from code that are not in the stored referential yet
+     * against the inline metadata of the stored models and the engines collections mappings
+     *
+     * @throws PluginImplementationError on a conflict
+     */
+    private checkNewMetadata;
+    /**
+     * Validates the metadata of models registered from code against the metadata referential
+     * and enriches the details and default values of the metadata coming from it
+     */
+    private resolveModels;
+    /**
+     * Registers a metadata in the metadata referential.
+     * Asset, device and group models can then use it with `{ referential: true }` in their metadataMappings.
+     * Its mappings cannot be modified once loaded, they are merged into the engines collections.
+     * Registering again an identical definition is allowed, so several modules can share a metadata.
+     *
+     * @param name - Name of the metadata
+     * @param definition - Mappings, default translations, editor hint, default value and icon of the metadata
+     * @throws PluginImplementationError if the metadata is invalid or already registered with another definition
+     */
+    registerMetadata(name: string, definition: MetadataReferentialEntry): void;
     /**
      * Registers an asset model.
      *
-     * @param engineGroups - The engine group names.
+     * @param tenantClasses - The tenant class names.
      * @param model - The name of the asset model, which must be in PascalCase.
      * @param measures - The measures associated with this asset model.
      * @param metadataMappings - The metadata mappings for the model, defaults to an empty object.
@@ -28,7 +60,7 @@ export declare class ModelsRegister {
      * @param icon - Optional icon representing the model.
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
-    registerAsset(engineGroups: string[], model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
+    registerAsset(tenantClasses: string[], model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
         [valueName: string]: LocaleDetails;
     }, icon?: string): void;
     /**
@@ -48,7 +80,7 @@ export declare class ModelsRegister {
      * Registers a group model.
      *
      *
-     * @param engineGroups - The engine group names.
+     * @param tenantClasses - The tenant class names.
      * @param model - The name of the group model, which must be in PascalCase.
      * @param affinity - The type of object accepted and their model affinity.
      * @param metadataMappings - The metadata mappings for the model, defaults to an empty object.
@@ -59,7 +91,7 @@ export declare class ModelsRegister {
      * @param locales - Optional translations specific to the model.
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
-    registerGroup(engineGroups: string[], model: string, affinity: GroupAffinity, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, icon?: string, locales?: {
+    registerGroup(tenantClasses: string[], model: string, affinity: GroupAffinity, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, icon?: string, locales?: {
         [valueName: string]: LocaleDetails;
     }): void;
     registerMeasure(type: string, measureDefinition: MeasureDefinition): void;

package/dist/lib/modules/model/types/ModelApi.d.ts

@@ -1,5 +1,5 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetModelContent, DeviceModelContent, GroupAffinity, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupAffinity, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, MetadataReferential, MetadataReferentialEntry, TooltipModels } from "./ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
@@ -8,30 +8,45 @@ interface ModelsControllerRequest {
 export interface ApiModelGetAssetRequest extends ModelsControllerRequest {
     action: "getAsset";
     model: string;
-    engineGroups: string[];
+    tenantClasses: string[];
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
 }
 export type ApiModelGetAssetResult = KDocument<AssetModelContent>;
 export interface ApiModelGetDeviceRequest extends ModelsControllerRequest {
     action: "getDevice";
     model: string;
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
 }
 export type ApiModelGetDeviceResult = KDocument<DeviceModelContent>;
 export interface ApiModelGetGroupRequest extends ModelsControllerRequest {
     action: "getGroup";
     model: string;
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
 }
 export type ApiModelGetGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelGetMeasureRequest extends ModelsControllerRequest {
     action: "getMeasure";
     type: string;
-    engineId?: string;
+    index?: string;
 }
 export type ApiModelGetMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
     action: "writeAsset";
     body: {
-        engineGroups: string[];
-        engineIds?: string[];
+        /**
+         * Mutually exclusive with `indexes`
+         */
+        tenantClasses?: string[];
+        indexes?: string[];
         model: string;
         icon?: string;
         metadataDetails?: MetadataDetails;
@@ -63,7 +78,7 @@ export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
     action: "writeGroup";
     body: {
         affinity: GroupAffinity;
-        engineGroups: string[];
+        tenantClasses: string[];
         model: string;
         icon?: string;
         metadataDetails?: MetadataDetails;
@@ -76,11 +91,48 @@ export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
     };
 }
 export type ApiModelWriteGroupResult = KDocument<GroupModelContent>;
+export interface ApiModelUpdateDeviceRequest extends ModelsControllerRequest {
+    action: "updateDevice";
+    model: string;
+    body: {
+        /**
+         * Full set of metadata mappings: the existing ones, unchanged, and the new ones,
+         * which must be metadata of the referential (`{ referential: true }`)
+         */
+        metadataMappings: MetadataMappings;
+        /**
+         * Replaces the metadata details when present
+         */
+        metadataDetails?: MetadataDetails;
+        /**
+         * Replaces the default values when present
+         */
+        defaultValues?: JSONObject;
+    };
+}
+export type ApiModelUpdateDeviceResult = KDocument<DeviceModelContent>;
+export interface ApiModelUpdateGroupRequest extends ModelsControllerRequest {
+    action: "updateGroup";
+    tenantClasses?: string[];
+    model: string;
+    body: {
+        affinity?: GroupAffinity;
+        icon?: string;
+        metadataDetails?: MetadataDetails;
+        metadataGroups?: MetadataGroups;
+        metadataMappings?: MetadataMappings;
+        defaultValues?: JSONObject;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
+    };
+}
+export type ApiModelUpdateGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     action: "writeMeasure";
     body: {
         type: string;
-        engineIds?: string[];
+        indexes?: string[];
         icon?: string;
         locales?: {
             [valueName: string]: LocaleDetails;
@@ -93,7 +145,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
     action: "updateAsset";
-    engineGroups: string[];
+    tenantClasses: string[];
     model: string;
     body: {
         icon?: string;
@@ -131,7 +183,11 @@ export interface ApiModelDeleteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelDeleteMeasureResult = void;
 export interface ApiModelListAssetsRequest extends ModelsControllerRequest {
     action: "listAssets";
-    engineGroups: string[];
+    tenantClasses: string[];
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
 }
 export type ApiModelListAssetsResult = {
     models: KDocument<AssetModelContent>[];
@@ -139,6 +195,10 @@ export type ApiModelListAssetsResult = {
 };
 export interface ApiModelListDevicesRequest extends ModelsControllerRequest {
     action: "listDevices";
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
 }
 export type ApiModelListDevicesResult = {
     models: KDocument<DeviceModelContent>[];
@@ -146,7 +206,11 @@ export type ApiModelListDevicesResult = {
 };
 export interface ApiModelListGroupsRequest extends ModelsControllerRequest {
     action: "listGroups";
-    engineGroups: string[];
+    tenantClasses: string[];
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
 }
 export type ApiModelListGroupsResult = {
     models: KDocument<GroupModelContent>[];
@@ -154,7 +218,7 @@ export type ApiModelListGroupsResult = {
 };
 export interface ApiModelListMeasuresRequest extends ModelsControllerRequest {
     action: "listMeasures";
-    engineId?: string;
+    index?: string;
 }
 export type ApiModelListMeasuresResult = {
     models: KDocument<MeasureModelContent>[];
@@ -162,7 +226,11 @@ export type ApiModelListMeasuresResult = {
 };
 export interface ApiModelSearchAssetsRequest extends ModelsControllerRequest {
     action: "searchAssets";
-    engineGroups: string[];
+    tenantClasses: string[];
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -171,6 +239,10 @@ export interface ApiModelSearchAssetsRequest extends ModelsControllerRequest {
 export type ApiModelSearchAssetsResult = SearchResult<KHit<AssetModelContent>>;
 export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
     action: "searchDevices";
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -179,7 +251,11 @@ export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
 export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
 export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
     action: "searchGroups";
-    engineGroups: string[];
+    tenantClasses: string[];
+    /**
+     * Returns the stored model, without resolving its referential metadata
+     */
+    rawModel?: boolean;
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -188,11 +264,26 @@ export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
 export type ApiModelSearchGroupsResult = SearchResult<KHit<GroupModelContent>>;
 export interface ApiModelSearchMeasuresRequest extends ModelsControllerRequest {
     action: "searchMeasures";
-    engineId?: string;
+    index?: string;
     from?: number;
     size?: number;
     scrollTTL?: string;
     body?: JSONObject;
 }
 export type ApiModelSearchMeasuresResult = SearchResult<KHit<MeasureModelContent>>;
+export interface ApiModelGetMetadataReferentialRequest extends ModelsControllerRequest {
+    action: "getMetadataReferential";
+}
+export type ApiModelGetMetadataReferentialResult = MetadataReferential;
+export interface ApiModelWriteMetadataRequest extends ModelsControllerRequest {
+    action: "writeMetadata";
+    name: string;
+    body: MetadataReferentialEntry;
+}
+export type ApiModelWriteMetadataResult = MetadataReferential;
+export interface ApiModelDeleteMetadataRequest extends ModelsControllerRequest {
+    action: "deleteMetadata";
+    name: string;
+}
+export type ApiModelDeleteMetadataResult = MetadataReferential;
 export {};