npm - @openremote/rest - Versions diffs - 1.8.0-snapshot.20250725120000 → 1.8.0-snapshot.20250725120002 - Mend

@openremote/rest 1.8.0-snapshot.20250725120000 → 1.8.0-snapshot.20250725120002

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/umd/index.bundle.js +1 -1
package/dist/umd/index.bundle.js.map +1 -1
package/dist/umd/index.js +1 -1
package/dist/umd/index.js.map +1 -1
package/lib/restclient.d.ts +575 -575
package/lib/restclient.js +619 -619
package/lib/restclient.js.map +1 -1
package/package.json +3 -3

package/lib/restclient.js CHANGED Viewed

@@ -1,690 +1,518 @@
 /* tslint:disable */
 /* eslint-disable */
-// Generated using typescript-generator version 3.2.1263 on 2025-07-25 10:49:04.
-export class AssetModelResourceClient {
+// Generated using typescript-generator version 3.2.1263 on 2025-07-25 16:03:40.
+export class ProvisioningResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /model/assetDescriptors
-     * Java method: org.openremote.model.asset.AssetModelResource.getAssetDescriptors
-     */
-    getAssetDescriptors(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetDescriptors`, queryParams: queryParams, options: options });
-    }
-    /**
-     * HTTP GET /model/assetInfo/{assetType}
-     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfo
+     * HTTP POST /provisioning
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.createProvisioningConfig
      */
-    getAssetInfo(assetType, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfo/${assetType}`, queryParams: queryParams, options: options });
+    createProvisioningConfig(provisioningConfig, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `provisioning`, data: provisioningConfig, options: options });
     }
     /**
-     * HTTP GET /model/assetInfos
-     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfos
+     * HTTP GET /provisioning
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.getProvisioningConfigs
      */
-    getAssetInfos(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfos`, queryParams: queryParams, options: options });
+    getProvisioningConfigs(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `provisioning`, options: options });
     }
     /**
-     * HTTP GET /model/metaItemDescriptors
-     * Java method: org.openremote.model.asset.AssetModelResource.getMetaItemDescriptors
+     * HTTP DELETE /provisioning/{id}
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.deleteProvisioningConfig
      */
-    getMetaItemDescriptors(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/metaItemDescriptors`, queryParams: queryParams, options: options });
+    deleteProvisioningConfig(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `provisioning/${id}`, options: options });
     }
     /**
-     * HTTP GET /model/valueDescriptors
-     * Java method: org.openremote.model.asset.AssetModelResource.getValueDescriptors
+     * HTTP PUT /provisioning/{id}
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.updateProvisioningConfig
      */
-    getValueDescriptors(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/valueDescriptors`, queryParams: queryParams, options: options });
+    updateProvisioningConfig(id, provisioningConfig, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `provisioning/${id}`, data: provisioningConfig, options: options });
     }
 }
-export class AssetDatapointResourceClient {
+export class AssetPredictedDatapointResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /asset/datapoint/export
-     * Java method: org.openremote.model.datapoint.AssetDatapointResource.getDatapointExport
-     */
-    getDatapointExport(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/datapoint/export`, queryParams: queryParams, options: options });
-    }
-    /**
-     * HTTP GET /asset/datapoint/periods
-     * Java method: org.openremote.model.datapoint.AssetDatapointResource.getDatapointPeriod
+     * HTTP POST /asset/predicted/{assetId}/{attributeName}
+     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.getPredictedDatapoints
      */
-    getDatapointPeriod(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/datapoint/periods`, queryParams: queryParams, options: options });
+    getPredictedDatapoints(assetId, attributeName, query, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: query, options: options });
     }
     /**
-     * HTTP POST /asset/datapoint/{assetId}/{attributeName}
-     * Java method: org.openremote.model.datapoint.AssetDatapointResource.getDatapoints
+     * HTTP PUT /asset/predicted/{assetId}/{attributeName}
+     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.writePredictedDatapoints
      */
-    getDatapoints(assetId, attributeName, query, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/datapoint/${assetId}/${attributeName}`, data: query, options: options });
+    writePredictedDatapoints(assetId, attributeName, predictedDatapoints, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: predictedDatapoints, options: options });
     }
 }
-export class ConsoleResourceClient {
+export class DashboardResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /console/register
-     * Java method: org.openremote.model.console.ConsoleResource.register
+     * HTTP POST /dashboard
+     * Java method: org.openremote.model.dashboard.DashboardResource.create
      */
-    register(consoleRegistration, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `console/register`, data: consoleRegistration, options: options });
-    }
-}
-export class GatewayServiceResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    create(dashboard, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard`, data: dashboard, options: options });
     }
     /**
-     * HTTP POST /gateway/tunnel
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.startTunnel
+     * HTTP PUT /dashboard
+     * Java method: org.openremote.model.dashboard.DashboardResource.update
      */
-    startTunnel(tunnelInfo, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
+    update(dashboard, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `dashboard`, data: dashboard, options: options });
     }
     /**
-     * HTTP DELETE /gateway/tunnel
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.stopTunnel
+     * HTTP GET /dashboard/all/{realm}
+     * Java method: org.openremote.model.dashboard.DashboardResource.getAllRealmDashboards
      */
-    stopTunnel(tunnelInfo, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
+    getAllRealmDashboards(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/all/${realm}`, options: options });
     }
     /**
-     * HTTP GET /gateway/tunnel/{realm}
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.getAllActiveTunnelInfos
+     * HTTP POST /dashboard/query
+     * Java method: org.openremote.model.dashboard.DashboardResource.query
      */
-    getAllActiveTunnelInfos(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}`, options: options });
+    query(dashboardQuery, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard/query`, data: dashboardQuery, options: options });
     }
     /**
-     * HTTP GET /gateway/tunnel/{realm}/{id}
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.getGatewayActiveTunnelInfos
+     * HTTP DELETE /dashboard/{realm}/{dashboardId}
+     * Java method: org.openremote.model.dashboard.DashboardResource.delete
      */
-    getGatewayActiveTunnelInfos(realm, id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}`, options: options });
+    delete(realm, dashboardId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
     }
     /**
-     * HTTP GET /gateway/tunnel/{realm}/{id}/{target}/{targetPort}
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.getActiveTunnelInfo
+     * HTTP GET /dashboard/{realm}/{dashboardId}
+     * Java method: org.openremote.model.dashboard.DashboardResource.get
      */
-    getActiveTunnelInfo(realm, id, target, targetPort, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}/${target}/${targetPort}`, options: options });
+    get(realm, dashboardId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
     }
 }
-export class ProvisioningResourceClient {
+export class AssetResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /provisioning
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.createProvisioningConfig
+     * HTTP POST /asset
+     * Java method: org.openremote.model.asset.AssetResource.create
      */
-    createProvisioningConfig(provisioningConfig, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `provisioning`, data: provisioningConfig, options: options });
+    create(asset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset`, data: asset, options: options });
     }
     /**
-     * HTTP GET /provisioning
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.getProvisioningConfigs
+     * HTTP DELETE /asset
+     * Java method: org.openremote.model.asset.AssetResource.delete
      */
-    getProvisioningConfigs(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `provisioning`, options: options });
+    delete(queryParams, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP DELETE /provisioning/{id}
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.deleteProvisioningConfig
+     * HTTP PUT /asset/attributes
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValues
      */
-    deleteProvisioningConfig(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `provisioning/${id}`, options: options });
+    writeAttributeValues(attributeStates, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes`, data: attributeStates, options: options });
     }
     /**
-     * HTTP PUT /provisioning/{id}
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.updateProvisioningConfig
+     * HTTP PUT /asset/attributes/timestamp
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeEvents
      */
-    updateProvisioningConfig(id, provisioningConfig, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `provisioning/${id}`, data: provisioningConfig, options: options });
-    }
-}
-export class NotificationResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    writeAttributeEvents(attributeEvents, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes/timestamp`, data: attributeEvents, options: options });
     }
     /**
-     * HTTP GET /notification
-     * Java method: org.openremote.model.notification.NotificationResource.getNotifications
+     * HTTP DELETE /asset/parent
+     * Java method: org.openremote.model.asset.AssetResource.updateNoneParent
      */
-    getNotifications(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `notification`, queryParams: queryParams, options: options });
+    updateNoneParent(queryParams, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/parent`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP DELETE /notification
-     * Java method: org.openremote.model.notification.NotificationResource.removeNotifications
+     * HTTP GET /asset/partial/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.getPartial
      */
-    removeNotifications(queryParams, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification`, queryParams: queryParams, options: options });
+    getPartial(assetId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/partial/${assetId}`, options: options });
     }
     /**
-     * HTTP POST /notification/alert
-     * Java method: org.openremote.model.notification.NotificationResource.sendNotification
+     * HTTP POST /asset/query
+     * Java method: org.openremote.model.asset.AssetResource.queryAssets
      */
-    sendNotification(notification, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `notification/alert`, data: notification, options: options });
+    queryAssets(query, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/query`, data: query, options: options });
     }
     /**
-     * HTTP DELETE /notification/{notificationId}
-     * Java method: org.openremote.model.notification.NotificationResource.removeNotification
+     * HTTP GET /asset/user/current
+     * Java method: org.openremote.model.asset.AssetResource.getCurrentUserAssets
      */
-    removeNotification(notificationId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification/${notificationId}`, options: options });
+    getCurrentUserAssets(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/current`, options: options });
     }
     /**
-     * HTTP PUT /notification/{notificationId}/acknowledged
-     * Java method: org.openremote.model.notification.NotificationResource.notificationAcknowledged
+     * HTTP POST /asset/user/link
+     * Java method: org.openremote.model.asset.AssetResource.createUserAssetLinks
      */
-    notificationAcknowledged(notificationId, acknowledgement, queryParams, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/acknowledged`, queryParams: queryParams, data: acknowledgement, options: options });
+    createUserAssetLinks(userAssets, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link`, data: userAssets, options: options });
     }
     /**
-     * HTTP PUT /notification/{notificationId}/delivered
-     * Java method: org.openremote.model.notification.NotificationResource.notificationDelivered
+     * HTTP GET /asset/user/link
+     * Java method: org.openremote.model.asset.AssetResource.getUserAssetLinks
      */
-    notificationDelivered(notificationId, queryParams, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/delivered`, queryParams: queryParams, options: options });
-    }
-}
-export class RulesResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    getUserAssetLinks(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/link`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP POST /rules
-     * Java method: org.openremote.model.rules.RulesResource.createGlobalRuleset
+     * HTTP POST /asset/user/link/delete
+     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLinks
      */
-    createGlobalRuleset(ruleset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `rules`, data: ruleset, options: options });
+    deleteUserAssetLinks(userAssets, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link/delete`, data: userAssets, options: options });
     }
     /**
-     * HTTP GET /rules
-     * Java method: org.openremote.model.rules.RulesResource.getGlobalRulesets
+     * HTTP DELETE /asset/user/link/{realm}/{userId}
+     * Java method: org.openremote.model.asset.AssetResource.deleteAllUserAssetLinks
      */
-    getGlobalRulesets(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules`, queryParams: queryParams, options: options });
+    deleteAllUserAssetLinks(realm, userId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}`, options: options });
     }
     /**
-     * HTTP POST /rules/asset
-     * Java method: org.openremote.model.rules.RulesResource.createAssetRuleset
+     * HTTP DELETE /asset/user/link/{realm}/{userId}/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLink
      */
-    createAssetRuleset(ruleset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/asset`, data: ruleset, options: options });
+    deleteUserAssetLink(realm, userId, assetId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}/${assetId}`, options: options });
     }
     /**
-     * HTTP GET /rules/asset/for/{assetId}
-     * Java method: org.openremote.model.rules.RulesResource.getAssetRulesets
+     * HTTP GET /asset/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.get
      */
-    getAssetRulesets(assetId, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/asset/for/${assetId}`, queryParams: queryParams, options: options });
+    get(assetId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/${assetId}`, options: options });
     }
     /**
-     * HTTP DELETE /rules/asset/{id}
-     * Java method: org.openremote.model.rules.RulesResource.deleteAssetRuleset
+     * HTTP PUT /asset/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.update
      */
-    deleteAssetRuleset(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/asset/${id}`, options: options });
+    update(assetId, asset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}`, data: asset, options: options });
     }
     /**
-     * HTTP GET /rules/asset/{id}
-     * Java method: org.openremote.model.rules.RulesResource.getAssetRuleset
-     */
-    getAssetRuleset(id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/asset/${id}`, options: options });
-    }
-    /**
-     * HTTP PUT /rules/asset/{id}
-     * Java method: org.openremote.model.rules.RulesResource.updateAssetRuleset
-     */
-    updateAssetRuleset(id, ruleset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/asset/${id}`, data: ruleset, options: options });
-    }
-    /**
-     * HTTP GET /rules/geofences/{assetId}
-     * Java method: org.openremote.model.rules.RulesResource.getAssetGeofences
-     */
-    getAssetGeofences(assetId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/geofences/${assetId}`, options: options });
-    }
-    /**
-     * HTTP GET /rules/info/asset/{assetId}
-     * Java method: org.openremote.model.rules.RulesResource.getAssetEngineInfo
-     */
-    getAssetEngineInfo(assetId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/asset/${assetId}`, options: options });
-    }
-    /**
-     * HTTP GET /rules/info/global
-     * Java method: org.openremote.model.rules.RulesResource.getGlobalEngineInfo
-     */
-    getGlobalEngineInfo(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/global`, options: options });
-    }
-    /**
-     * HTTP GET /rules/info/realm/{realm}
-     * Java method: org.openremote.model.rules.RulesResource.getRealmEngineInfo
-     */
-    getRealmEngineInfo(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/realm/${realm}`, options: options });
-    }
-    /**
-     * HTTP POST /rules/realm
-     * Java method: org.openremote.model.rules.RulesResource.createRealmRuleset
+     * HTTP PUT /asset/{assetId}/attribute/{attributeName}
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
      */
-    createRealmRuleset(ruleset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/realm`, data: ruleset, options: options });
+    writeAttributeValue$PUT$asset_assetId_attribute_attributeName(assetId, attributeName, value, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}/attribute/${attributeName}`, data: value, options: options });
     }
     /**
-     * HTTP GET /rules/realm/for/{realm}
-     * Java method: org.openremote.model.rules.RulesResource.getRealmRulesets
+     * HTTP PUT /asset/{assetId}/attribute/{attributeName}/{timestamp}
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
      */
-    getRealmRulesets(realm, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/for/${realm}`, queryParams: queryParams, options: options });
+    writeAttributeValue$PUT$asset_assetId_attribute_attributeName_timestamp(assetId, attributeName, timestamp, value, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}/attribute/${attributeName}/${timestamp}`, data: value, options: options });
     }
     /**
-     * HTTP DELETE /rules/realm/{id}
-     * Java method: org.openremote.model.rules.RulesResource.deleteRealmRuleset
+     * HTTP PUT /asset/{parentAssetId}/child
+     * Java method: org.openremote.model.asset.AssetResource.updateParent
      */
-    deleteRealmRuleset(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/realm/${id}`, options: options });
+    updateParent(parentAssetId, queryParams, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${parentAssetId}/child`, queryParams: queryParams, options: options });
     }
-    /**
-     * HTTP GET /rules/realm/{id}
-     * Java method: org.openremote.model.rules.RulesResource.getRealmRuleset
-     */
-    getRealmRuleset(id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/${id}`, options: options });
+}
+export class ConfigurationResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP PUT /rules/realm/{id}
-     * Java method: org.openremote.model.rules.RulesResource.updateRealmRuleset
+     * HTTP GET /configuration/manager
+     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfig
      */
-    updateRealmRuleset(id, ruleset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/realm/${id}`, data: ruleset, options: options });
+    getManagerConfig(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager`, options: options });
     }
     /**
-     * HTTP DELETE /rules/{id}
-     * Java method: org.openremote.model.rules.RulesResource.deleteGlobalRuleset
+     * HTTP PUT /configuration/manager
+     * Java method: org.openremote.model.manager.ConfigurationResource.update
      */
-    deleteGlobalRuleset(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/${id}`, options: options });
+    update(managerConfiguration, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `configuration/manager`, data: managerConfiguration, options: options });
     }
     /**
-     * HTTP GET /rules/{id}
-     * Java method: org.openremote.model.rules.RulesResource.getGlobalRuleset
+     * HTTP POST /configuration/manager/file
+     * Java method: org.openremote.model.manager.ConfigurationResource.fileUpload
      */
-    getGlobalRuleset(id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/${id}`, options: options });
+    fileUpload(fileInfo, queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `configuration/manager/file`, queryParams: queryParams, data: fileInfo, options: options });
     }
     /**
-     * HTTP PUT /rules/{id}
-     * Java method: org.openremote.model.rules.RulesResource.updateGlobalRuleset
+     * HTTP GET /configuration/manager/image/{filename: .+}
+     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfigImage
      */
-    updateGlobalRuleset(id, ruleset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/${id}`, data: ruleset, options: options });
+    getManagerConfigImage(filename, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager/image/${filename}`, options: options });
     }
 }
-export class FlowResourceClient {
+export class AppResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /flow
-     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitions
+     * HTTP GET /apps
+     * Java method: org.openremote.model.apps.AppResource.getApps
      */
-    getAllNodeDefinitions(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `flow`, options: options });
+    getApps(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `apps`, options: options });
     }
     /**
-     * HTTP GET /flow/{name}
-     * Java method: org.openremote.model.rules.flow.FlowResource.getNodeDefinition
+     * HTTP GET /apps/consoleConfig
+     * Java method: org.openremote.model.apps.AppResource.getConsoleConfig
      */
-    getNodeDefinition(name, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${name}`, options: options });
+    getConsoleConfig(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/consoleConfig`, options: options });
     }
     /**
-     * HTTP GET /flow/{type}
-     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitionsByType
+     * HTTP GET /apps/info
+     * Java method: org.openremote.model.apps.AppResource.getAppInfos
      */
-    getAllNodeDefinitionsByType(type, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${type}`, options: options });
+    getAppInfos(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/info`, options: options });
     }
 }
-export class AgentResourceClient {
+export class NotificationResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /agent/assetDiscovery/{agentId}
-     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolAssetDiscovery
+     * HTTP GET /notification
+     * Java method: org.openremote.model.notification.NotificationResource.getNotifications
      */
-    doProtocolAssetDiscovery(agentId, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `agent/assetDiscovery/${agentId}`, queryParams: queryParams, options: options });
+    getNotifications(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `notification`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP POST /agent/assetImport/{agentId}
-     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolAssetImport
+     * HTTP DELETE /notification
+     * Java method: org.openremote.model.notification.NotificationResource.removeNotifications
      */
-    doProtocolAssetImport(agentId, fileInfo, queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `agent/assetImport/${agentId}`, queryParams: queryParams, data: fileInfo, options: options });
+    removeNotifications(queryParams, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /agent/instanceDiscovery/{agentType}
-     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolInstanceDiscovery
+     * HTTP POST /notification/alert
+     * Java method: org.openremote.model.notification.NotificationResource.sendNotification
      */
-    doProtocolInstanceDiscovery(agentType, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `agent/instanceDiscovery/${agentType}`, queryParams: queryParams, options: options });
+    sendNotification(notification, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `notification/alert`, data: notification, options: options });
     }
-}
-export class StatusResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    /**
+     * HTTP DELETE /notification/{notificationId}
+     * Java method: org.openremote.model.notification.NotificationResource.removeNotification
+     */
+    removeNotification(notificationId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification/${notificationId}`, options: options });
     }
     /**
-     * HTTP GET /health
-     * Java method: org.openremote.model.system.StatusResource.getHealthStatus
+     * HTTP PUT /notification/{notificationId}/acknowledged
+     * Java method: org.openremote.model.notification.NotificationResource.notificationAcknowledged
      */
-    getHealthStatus(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `health`, options: options });
+    notificationAcknowledged(notificationId, acknowledgement, queryParams, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/acknowledged`, queryParams: queryParams, data: acknowledgement, options: options });
     }
     /**
-     * HTTP GET /info
-     * Java method: org.openremote.model.system.StatusResource.getInfo
+     * HTTP PUT /notification/{notificationId}/delivered
+     * Java method: org.openremote.model.notification.NotificationResource.notificationDelivered
      */
-    getInfo(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `info`, options: options });
+    notificationDelivered(notificationId, queryParams, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/delivered`, queryParams: queryParams, options: options });
     }
 }
-export class MapResourceClient {
+export class AssetModelResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /map
-     * Java method: org.openremote.model.map.MapResource.getSettings
-     */
-    getSettings(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map`, options: options });
-    }
-    /**
-     * HTTP PUT /map
-     * Java method: org.openremote.model.map.MapResource.saveSettings
-     */
-    saveSettings(mapConfig, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `map`, data: mapConfig, options: options });
-    }
-    /**
-     * HTTP DELETE /map/deleteMap
-     * Java method: org.openremote.model.map.MapResource.deleteMap
-     */
-    deleteMap(options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `map/deleteMap`, options: options });
-    }
-    /**
-     * HTTP GET /map/getCustomMapInfo
-     * Java method: org.openremote.model.map.MapResource.getCustomMapInfo
-     */
-    getCustomMapInfo(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map/getCustomMapInfo`, options: options });
-    }
-    /**
-     * HTTP GET /map/js
-     * Java method: org.openremote.model.map.MapResource.getSettingsJs
-     */
-    getSettingsJs(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map/js`, options: options });
-    }
-    /**
-     * HTTP GET /map/tile/{zoom}/{column}/{row}
-     * Java method: org.openremote.model.map.MapResource.getTile
-     */
-    getTile(zoom, column, row, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map/tile/${zoom}/${column}/${row}`, options: options });
-    }
-    /**
-     * HTTP POST /map/upload
-     * Java method: org.openremote.model.map.MapResource.uploadMap
+     * HTTP GET /model/assetDescriptors
+     * Java method: org.openremote.model.asset.AssetModelResource.getAssetDescriptors
      */
-    uploadMap(queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `map/upload`, queryParams: queryParams, options: options });
-    }
-}
-export class ConfigurationResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    getAssetDescriptors(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetDescriptors`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /configuration/manager
-     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfig
+     * HTTP GET /model/assetInfo/{assetType}
+     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfo
      */
-    getManagerConfig(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager`, options: options });
+    getAssetInfo(assetType, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfo/${assetType}`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP PUT /configuration/manager
-     * Java method: org.openremote.model.manager.ConfigurationResource.update
+     * HTTP GET /model/assetInfos
+     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfos
      */
-    update(managerConfiguration, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `configuration/manager`, data: managerConfiguration, options: options });
+    getAssetInfos(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfos`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP POST /configuration/manager/file
-     * Java method: org.openremote.model.manager.ConfigurationResource.fileUpload
+     * HTTP GET /model/metaItemDescriptors
+     * Java method: org.openremote.model.asset.AssetModelResource.getMetaItemDescriptors
      */
-    fileUpload(fileInfo, queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `configuration/manager/file`, queryParams: queryParams, data: fileInfo, options: options });
+    getMetaItemDescriptors(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/metaItemDescriptors`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /configuration/manager/image/{filename: .+}
-     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfigImage
+     * HTTP GET /model/valueDescriptors
+     * Java method: org.openremote.model.asset.AssetModelResource.getValueDescriptors
      */
-    getManagerConfigImage(filename, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager/image/${filename}`, options: options });
+    getValueDescriptors(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/valueDescriptors`, queryParams: queryParams, options: options });
     }
 }
-export class AlarmResourceClient {
+export class RulesResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /alarm
-     * Java method: org.openremote.model.alarm.AlarmResource.createAlarm
-     */
-    createAlarm(alarm, queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `alarm`, queryParams: queryParams, data: alarm, options: options });
-    }
-    /**
-     * HTTP GET /alarm
-     * Java method: org.openremote.model.alarm.AlarmResource.getAlarms
-     */
-    getAlarms(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm`, queryParams: queryParams, options: options });
-    }
-    /**
-     * HTTP DELETE /alarm
-     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarms
-     */
-    removeAlarms(ids, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm`, data: ids, options: options });
-    }
-    /**
-     * HTTP PUT /alarm/assets
-     * Java method: org.openremote.model.alarm.AlarmResource.setAssetLinks
-     */
-    setAssetLinks(links, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `alarm/assets`, data: links, options: options });
-    }
-    /**
-     * HTTP GET /alarm/{alarmId}
-     * Java method: org.openremote.model.alarm.AlarmResource.getAlarm
-     */
-    getAlarm(alarmId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}`, options: options });
-    }
-    /**
-     * HTTP DELETE /alarm/{alarmId}
-     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarm
-     */
-    removeAlarm(alarmId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm/${alarmId}`, options: options });
-    }
-    /**
-     * HTTP PUT /alarm/{alarmId}
-     * Java method: org.openremote.model.alarm.AlarmResource.updateAlarm
-     */
-    updateAlarm(alarmId, alarm, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `alarm/${alarmId}`, data: alarm, options: options });
-    }
-    /**
-     * HTTP GET /alarm/{alarmId}/assets
-     * Java method: org.openremote.model.alarm.AlarmResource.getAssetLinks
+     * HTTP POST /rules
+     * Java method: org.openremote.model.rules.RulesResource.createGlobalRuleset
      */
-    getAssetLinks(alarmId, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}/assets`, queryParams: queryParams, options: options });
-    }
-}
-export class AssetResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    createGlobalRuleset(ruleset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `rules`, data: ruleset, options: options });
     }
     /**
-     * HTTP POST /asset
-     * Java method: org.openremote.model.asset.AssetResource.create
+     * HTTP GET /rules
+     * Java method: org.openremote.model.rules.RulesResource.getGlobalRulesets
      */
-    create(asset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset`, data: asset, options: options });
+    getGlobalRulesets(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP DELETE /asset
-     * Java method: org.openremote.model.asset.AssetResource.delete
+     * HTTP POST /rules/asset
+     * Java method: org.openremote.model.rules.RulesResource.createAssetRuleset
      */
-    delete(queryParams, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset`, queryParams: queryParams, options: options });
+    createAssetRuleset(ruleset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/asset`, data: ruleset, options: options });
     }
     /**
-     * HTTP PUT /asset/attributes
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValues
+     * HTTP GET /rules/asset/for/{assetId}
+     * Java method: org.openremote.model.rules.RulesResource.getAssetRulesets
      */
-    writeAttributeValues(attributeStates, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes`, data: attributeStates, options: options });
+    getAssetRulesets(assetId, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/asset/for/${assetId}`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP PUT /asset/attributes/timestamp
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeEvents
+     * HTTP DELETE /rules/asset/{id}
+     * Java method: org.openremote.model.rules.RulesResource.deleteAssetRuleset
      */
-    writeAttributeEvents(attributeEvents, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes/timestamp`, data: attributeEvents, options: options });
+    deleteAssetRuleset(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/asset/${id}`, options: options });
     }
     /**
-     * HTTP DELETE /asset/parent
-     * Java method: org.openremote.model.asset.AssetResource.updateNoneParent
+     * HTTP GET /rules/asset/{id}
+     * Java method: org.openremote.model.rules.RulesResource.getAssetRuleset
      */
-    updateNoneParent(queryParams, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/parent`, queryParams: queryParams, options: options });
+    getAssetRuleset(id, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/asset/${id}`, options: options });
     }
     /**
-     * HTTP GET /asset/partial/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.getPartial
+     * HTTP PUT /rules/asset/{id}
+     * Java method: org.openremote.model.rules.RulesResource.updateAssetRuleset
      */
-    getPartial(assetId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/partial/${assetId}`, options: options });
+    updateAssetRuleset(id, ruleset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/asset/${id}`, data: ruleset, options: options });
     }
     /**
-     * HTTP POST /asset/query
-     * Java method: org.openremote.model.asset.AssetResource.queryAssets
+     * HTTP GET /rules/geofences/{assetId}
+     * Java method: org.openremote.model.rules.RulesResource.getAssetGeofences
      */
-    queryAssets(query, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/query`, data: query, options: options });
+    getAssetGeofences(assetId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/geofences/${assetId}`, options: options });
     }
     /**
-     * HTTP GET /asset/user/current
-     * Java method: org.openremote.model.asset.AssetResource.getCurrentUserAssets
+     * HTTP GET /rules/info/asset/{assetId}
+     * Java method: org.openremote.model.rules.RulesResource.getAssetEngineInfo
      */
-    getCurrentUserAssets(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/current`, options: options });
+    getAssetEngineInfo(assetId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/asset/${assetId}`, options: options });
     }
     /**
-     * HTTP POST /asset/user/link
-     * Java method: org.openremote.model.asset.AssetResource.createUserAssetLinks
+     * HTTP GET /rules/info/global
+     * Java method: org.openremote.model.rules.RulesResource.getGlobalEngineInfo
      */
-    createUserAssetLinks(userAssets, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link`, data: userAssets, options: options });
+    getGlobalEngineInfo(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/global`, options: options });
     }
     /**
-     * HTTP GET /asset/user/link
-     * Java method: org.openremote.model.asset.AssetResource.getUserAssetLinks
+     * HTTP GET /rules/info/realm/{realm}
+     * Java method: org.openremote.model.rules.RulesResource.getRealmEngineInfo
      */
-    getUserAssetLinks(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/link`, queryParams: queryParams, options: options });
+    getRealmEngineInfo(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/realm/${realm}`, options: options });
     }
     /**
-     * HTTP POST /asset/user/link/delete
-     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLinks
+     * HTTP POST /rules/realm
+     * Java method: org.openremote.model.rules.RulesResource.createRealmRuleset
      */
-    deleteUserAssetLinks(userAssets, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link/delete`, data: userAssets, options: options });
+    createRealmRuleset(ruleset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/realm`, data: ruleset, options: options });
     }
     /**
-     * HTTP DELETE /asset/user/link/{realm}/{userId}
-     * Java method: org.openremote.model.asset.AssetResource.deleteAllUserAssetLinks
+     * HTTP GET /rules/realm/for/{realm}
+     * Java method: org.openremote.model.rules.RulesResource.getRealmRulesets
      */
-    deleteAllUserAssetLinks(realm, userId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}`, options: options });
+    getRealmRulesets(realm, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/for/${realm}`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP DELETE /asset/user/link/{realm}/{userId}/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLink
+     * HTTP DELETE /rules/realm/{id}
+     * Java method: org.openremote.model.rules.RulesResource.deleteRealmRuleset
      */
-    deleteUserAssetLink(realm, userId, assetId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}/${assetId}`, options: options });
+    deleteRealmRuleset(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/realm/${id}`, options: options });
     }
     /**
-     * HTTP GET /asset/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.get
+     * HTTP GET /rules/realm/{id}
+     * Java method: org.openremote.model.rules.RulesResource.getRealmRuleset
      */
-    get(assetId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/${assetId}`, options: options });
+    getRealmRuleset(id, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/${id}`, options: options });
     }
     /**
-     * HTTP PUT /asset/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.update
+     * HTTP PUT /rules/realm/{id}
+     * Java method: org.openremote.model.rules.RulesResource.updateRealmRuleset
      */
-    update(assetId, asset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}`, data: asset, options: options });
+    updateRealmRuleset(id, ruleset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/realm/${id}`, data: ruleset, options: options });
     }
     /**
-     * HTTP PUT /asset/{assetId}/attribute/{attributeName}
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
+     * HTTP DELETE /rules/{id}
+     * Java method: org.openremote.model.rules.RulesResource.deleteGlobalRuleset
      */
-    writeAttributeValue$PUT$asset_assetId_attribute_attributeName(assetId, attributeName, value, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}/attribute/${attributeName}`, data: value, options: options });
+    deleteGlobalRuleset(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/${id}`, options: options });
     }
     /**
-     * HTTP PUT /asset/{assetId}/attribute/{attributeName}/{timestamp}
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
+     * HTTP GET /rules/{id}
+     * Java method: org.openremote.model.rules.RulesResource.getGlobalRuleset
      */
-    writeAttributeValue$PUT$asset_assetId_attribute_attributeName_timestamp(assetId, attributeName, timestamp, value, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}/attribute/${attributeName}/${timestamp}`, data: value, options: options });
+    getGlobalRuleset(id, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/${id}`, options: options });
     }
     /**
-     * HTTP PUT /asset/{parentAssetId}/child
-     * Java method: org.openremote.model.asset.AssetResource.updateParent
+     * HTTP PUT /rules/{id}
+     * Java method: org.openremote.model.rules.RulesResource.updateGlobalRuleset
      */
-    updateParent(parentAssetId, queryParams, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${parentAssetId}/child`, queryParams: queryParams, options: options });
+    updateGlobalRuleset(id, ruleset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/${id}`, data: ruleset, options: options });
     }
 }
 export class SyslogResourceClient {
@@ -720,23 +548,58 @@ export class SyslogResourceClient {
         return this.httpClient.request({ method: "GET", url: uriEncoding `syslog/event`, queryParams: queryParams, options: options });
     }
 }
-export class AssetPredictedDatapointResourceClient {
+export class MapResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /asset/predicted/{assetId}/{attributeName}
-     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.getPredictedDatapoints
+     * HTTP GET /map
+     * Java method: org.openremote.model.map.MapResource.getSettings
      */
-    getPredictedDatapoints(assetId, attributeName, query, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: query, options: options });
+    getSettings(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `map`, options: options });
     }
     /**
-     * HTTP PUT /asset/predicted/{assetId}/{attributeName}
-     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.writePredictedDatapoints
+     * HTTP PUT /map
+     * Java method: org.openremote.model.map.MapResource.saveSettings
      */
-    writePredictedDatapoints(assetId, attributeName, predictedDatapoints, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: predictedDatapoints, options: options });
+    saveSettings(mapConfig, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `map`, data: mapConfig, options: options });
+    }
+    /**
+     * HTTP DELETE /map/deleteMap
+     * Java method: org.openremote.model.map.MapResource.deleteMap
+     */
+    deleteMap(options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `map/deleteMap`, options: options });
+    }
+    /**
+     * HTTP GET /map/getCustomMapInfo
+     * Java method: org.openremote.model.map.MapResource.getCustomMapInfo
+     */
+    getCustomMapInfo(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `map/getCustomMapInfo`, options: options });
+    }
+    /**
+     * HTTP GET /map/js
+     * Java method: org.openremote.model.map.MapResource.getSettingsJs
+     */
+    getSettingsJs(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `map/js`, options: options });
+    }
+    /**
+     * HTTP GET /map/tile/{zoom}/{column}/{row}
+     * Java method: org.openremote.model.map.MapResource.getTile
+     */
+    getTile(zoom, column, row, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `map/tile/${zoom}/${column}/${row}`, options: options });
+    }
+    /**
+     * HTTP POST /map/upload
+     * Java method: org.openremote.model.map.MapResource.uploadMap
+     */
+    uploadMap(queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `map/upload`, queryParams: queryParams, options: options });
     }
 }
 export class UserResourceClient {
@@ -912,51 +775,110 @@ export class UserResourceClient {
         return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/${userId}`, options: options });
     }
 }
-export class RealmResourceClient {
+export class StatusResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /realm
-     * Java method: org.openremote.model.security.RealmResource.create
+     * HTTP GET /health
+     * Java method: org.openremote.model.system.StatusResource.getHealthStatus
      */
-    create(realm, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `realm`, data: realm, options: options });
+    getHealthStatus(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `health`, options: options });
     }
     /**
-     * HTTP GET /realm
-     * Java method: org.openremote.model.security.RealmResource.getAll
+     * HTTP GET /info
+     * Java method: org.openremote.model.system.StatusResource.getInfo
      */
-    getAll(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `realm`, options: options });
+    getInfo(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `info`, options: options });
+    }
+}
+export class AssetDatapointResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /realm/accessible
-     * Java method: org.openremote.model.security.RealmResource.getAccessible
+     * HTTP GET /asset/datapoint/export
+     * Java method: org.openremote.model.datapoint.AssetDatapointResource.getDatapointExport
      */
-    getAccessible(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/accessible`, options: options });
+    getDatapointExport(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/datapoint/export`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP DELETE /realm/{name}
-     * Java method: org.openremote.model.security.RealmResource.delete
+     * HTTP GET /asset/datapoint/periods
+     * Java method: org.openremote.model.datapoint.AssetDatapointResource.getDatapointPeriod
      */
-    delete(name, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `realm/${name}`, options: options });
+    getDatapointPeriod(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/datapoint/periods`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /realm/{name}
-     * Java method: org.openremote.model.security.RealmResource.get
+     * HTTP POST /asset/datapoint/{assetId}/{attributeName}
+     * Java method: org.openremote.model.datapoint.AssetDatapointResource.getDatapoints
      */
-    get(name, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/${name}`, options: options });
+    getDatapoints(assetId, attributeName, query, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/datapoint/${assetId}/${attributeName}`, data: query, options: options });
+    }
+}
+export class AlarmResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP PUT /realm/{name}
-     * Java method: org.openremote.model.security.RealmResource.update
+     * HTTP POST /alarm
+     * Java method: org.openremote.model.alarm.AlarmResource.createAlarm
      */
-    update(name, realm, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `realm/${name}`, data: realm, options: options });
+    createAlarm(alarm, queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `alarm`, queryParams: queryParams, data: alarm, options: options });
+    }
+    /**
+     * HTTP GET /alarm
+     * Java method: org.openremote.model.alarm.AlarmResource.getAlarms
+     */
+    getAlarms(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP DELETE /alarm
+     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarms
+     */
+    removeAlarms(ids, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm`, data: ids, options: options });
+    }
+    /**
+     * HTTP PUT /alarm/assets
+     * Java method: org.openremote.model.alarm.AlarmResource.setAssetLinks
+     */
+    setAssetLinks(links, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `alarm/assets`, data: links, options: options });
+    }
+    /**
+     * HTTP GET /alarm/{alarmId}
+     * Java method: org.openremote.model.alarm.AlarmResource.getAlarm
+     */
+    getAlarm(alarmId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}`, options: options });
+    }
+    /**
+     * HTTP DELETE /alarm/{alarmId}
+     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarm
+     */
+    removeAlarm(alarmId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm/${alarmId}`, options: options });
+    }
+    /**
+     * HTTP PUT /alarm/{alarmId}
+     * Java method: org.openremote.model.alarm.AlarmResource.updateAlarm
+     */
+    updateAlarm(alarmId, alarm, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `alarm/${alarmId}`, data: alarm, options: options });
+    }
+    /**
+     * HTTP GET /alarm/{alarmId}/assets
+     * Java method: org.openremote.model.alarm.AlarmResource.getAssetLinks
+     */
+    getAssetLinks(alarmId, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}/assets`, queryParams: queryParams, options: options });
     }
 }
 export class GatewayClientResourceClient {
@@ -978,105 +900,183 @@ export class GatewayClientResourceClient {
         return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/connection`, options: options });
     }
     /**
-     * HTTP DELETE /gateway/connection/{realm}
-     * Java method: org.openremote.model.gateway.GatewayClientResource.deleteConnection
+     * HTTP DELETE /gateway/connection/{realm}
+     * Java method: org.openremote.model.gateway.GatewayClientResource.deleteConnection
+     */
+    deleteConnection(realm, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `gateway/connection/${realm}`, options: options });
+    }
+    /**
+     * HTTP GET /gateway/connection/{realm}
+     * Java method: org.openremote.model.gateway.GatewayClientResource.getConnection
+     */
+    getConnection(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/connection/${realm}`, options: options });
+    }
+    /**
+     * HTTP PUT /gateway/connection/{realm}
+     * Java method: org.openremote.model.gateway.GatewayClientResource.setConnection
+     */
+    setConnection(realm, connection, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `gateway/connection/${realm}`, data: connection, options: options });
+    }
+    /**
+     * HTTP GET /gateway/status/{realm}
+     * Java method: org.openremote.model.gateway.GatewayClientResource.getConnectionStatus
+     */
+    getConnectionStatus(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/status/${realm}`, options: options });
+    }
+}
+export class ConsoleResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    /**
+     * HTTP POST /console/register
+     * Java method: org.openremote.model.console.ConsoleResource.register
+     */
+    register(consoleRegistration, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `console/register`, data: consoleRegistration, options: options });
+    }
+}
+export class AgentResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    /**
+     * HTTP GET /agent/assetDiscovery/{agentId}
+     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolAssetDiscovery
+     */
+    doProtocolAssetDiscovery(agentId, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `agent/assetDiscovery/${agentId}`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP POST /agent/assetImport/{agentId}
+     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolAssetImport
+     */
+    doProtocolAssetImport(agentId, fileInfo, queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `agent/assetImport/${agentId}`, queryParams: queryParams, data: fileInfo, options: options });
+    }
+    /**
+     * HTTP GET /agent/instanceDiscovery/{agentType}
+     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolInstanceDiscovery
+     */
+    doProtocolInstanceDiscovery(agentType, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `agent/instanceDiscovery/${agentType}`, queryParams: queryParams, options: options });
+    }
+}
+export class RealmResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    /**
+     * HTTP POST /realm
+     * Java method: org.openremote.model.security.RealmResource.create
+     */
+    create(realm, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `realm`, data: realm, options: options });
+    }
+    /**
+     * HTTP GET /realm
+     * Java method: org.openremote.model.security.RealmResource.getAll
+     */
+    getAll(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `realm`, options: options });
+    }
+    /**
+     * HTTP GET /realm/accessible
+     * Java method: org.openremote.model.security.RealmResource.getAccessible
      */
-    deleteConnection(realm, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `gateway/connection/${realm}`, options: options });
+    getAccessible(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/accessible`, options: options });
     }
     /**
-     * HTTP GET /gateway/connection/{realm}
-     * Java method: org.openremote.model.gateway.GatewayClientResource.getConnection
+     * HTTP DELETE /realm/{name}
+     * Java method: org.openremote.model.security.RealmResource.delete
      */
-    getConnection(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/connection/${realm}`, options: options });
+    delete(name, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `realm/${name}`, options: options });
     }
     /**
-     * HTTP PUT /gateway/connection/{realm}
-     * Java method: org.openremote.model.gateway.GatewayClientResource.setConnection
+     * HTTP GET /realm/{name}
+     * Java method: org.openremote.model.security.RealmResource.get
      */
-    setConnection(realm, connection, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `gateway/connection/${realm}`, data: connection, options: options });
+    get(name, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/${name}`, options: options });
     }
     /**
-     * HTTP GET /gateway/status/{realm}
-     * Java method: org.openremote.model.gateway.GatewayClientResource.getConnectionStatus
+     * HTTP PUT /realm/{name}
+     * Java method: org.openremote.model.security.RealmResource.update
      */
-    getConnectionStatus(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/status/${realm}`, options: options });
+    update(name, realm, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `realm/${name}`, data: realm, options: options });
     }
 }
-export class DashboardResourceClient {
+export class FlowResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /dashboard
-     * Java method: org.openremote.model.dashboard.DashboardResource.create
+     * HTTP GET /flow
+     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitions
      */
-    create(dashboard, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard`, data: dashboard, options: options });
+    getAllNodeDefinitions(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `flow`, options: options });
     }
     /**
-     * HTTP PUT /dashboard
-     * Java method: org.openremote.model.dashboard.DashboardResource.update
+     * HTTP GET /flow/{name}
+     * Java method: org.openremote.model.rules.flow.FlowResource.getNodeDefinition
      */
-    update(dashboard, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `dashboard`, data: dashboard, options: options });
+    getNodeDefinition(name, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${name}`, options: options });
     }
     /**
-     * HTTP GET /dashboard/all/{realm}
-     * Java method: org.openremote.model.dashboard.DashboardResource.getAllRealmDashboards
+     * HTTP GET /flow/{type}
+     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitionsByType
      */
-    getAllRealmDashboards(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/all/${realm}`, options: options });
+    getAllNodeDefinitionsByType(type, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${type}`, options: options });
     }
-    /**
-     * HTTP POST /dashboard/query
-     * Java method: org.openremote.model.dashboard.DashboardResource.query
-     */
-    query(dashboardQuery, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard/query`, data: dashboardQuery, options: options });
+}
+export class GatewayServiceResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP DELETE /dashboard/{realm}/{dashboardId}
-     * Java method: org.openremote.model.dashboard.DashboardResource.delete
+     * HTTP POST /gateway/tunnel
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.startTunnel
      */
-    delete(realm, dashboardId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
+    startTunnel(tunnelInfo, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
     }
     /**
-     * HTTP GET /dashboard/{realm}/{dashboardId}
-     * Java method: org.openremote.model.dashboard.DashboardResource.get
+     * HTTP DELETE /gateway/tunnel
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.stopTunnel
      */
-    get(realm, dashboardId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
-    }
-}
-export class AppResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    stopTunnel(tunnelInfo, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
     }
     /**
-     * HTTP GET /apps
-     * Java method: org.openremote.model.apps.AppResource.getApps
+     * HTTP GET /gateway/tunnel/{realm}
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.getAllActiveTunnelInfos
      */
-    getApps(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `apps`, options: options });
+    getAllActiveTunnelInfos(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}`, options: options });
     }
     /**
-     * HTTP GET /apps/consoleConfig
-     * Java method: org.openremote.model.apps.AppResource.getConsoleConfig
+     * HTTP GET /gateway/tunnel/{realm}/{id}
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.getGatewayActiveTunnelInfos
      */
-    getConsoleConfig(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/consoleConfig`, options: options });
+    getGatewayActiveTunnelInfos(realm, id, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}`, options: options });
     }
     /**
-     * HTTP GET /apps/info
-     * Java method: org.openremote.model.apps.AppResource.getAppInfos
+     * HTTP GET /gateway/tunnel/{realm}/{id}/{target}/{targetPort}
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.getActiveTunnelInfo
      */
-    getAppInfos(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/info`, options: options });
+    getActiveTunnelInfo(realm, id, target, targetPort, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}/${target}/${targetPort}`, options: options });
     }
 }
 function uriEncoding(template, ...substitutions) {
@@ -1091,91 +1091,91 @@ function uriEncoding(template, ...substitutions) {
 // Added by 'AggregatedApiClient' extension
 export class ApiClient {
     constructor(baseURL, axiosInstance = axios.create()) {
-        this._assetModelResource = new AxiosAssetModelResourceClient(baseURL, axiosInstance);
-        this._assetDatapointResource = new AxiosAssetDatapointResourceClient(baseURL, axiosInstance);
-        this._consoleResource = new AxiosConsoleResourceClient(baseURL, axiosInstance);
-        this._gatewayServiceResource = new AxiosGatewayServiceResourceClient(baseURL, axiosInstance);
         this._provisioningResource = new AxiosProvisioningResourceClient(baseURL, axiosInstance);
+        this._assetPredictedDatapointResource = new AxiosAssetPredictedDatapointResourceClient(baseURL, axiosInstance);
+        this._dashboardResource = new AxiosDashboardResourceClient(baseURL, axiosInstance);
+        this._assetResource = new AxiosAssetResourceClient(baseURL, axiosInstance);
+        this._configurationResource = new AxiosConfigurationResourceClient(baseURL, axiosInstance);
+        this._appResource = new AxiosAppResourceClient(baseURL, axiosInstance);
         this._notificationResource = new AxiosNotificationResourceClient(baseURL, axiosInstance);
+        this._assetModelResource = new AxiosAssetModelResourceClient(baseURL, axiosInstance);
         this._rulesResource = new AxiosRulesResourceClient(baseURL, axiosInstance);
-        this._flowResource = new AxiosFlowResourceClient(baseURL, axiosInstance);
-        this._agentResource = new AxiosAgentResourceClient(baseURL, axiosInstance);
-        this._statusResource = new AxiosStatusResourceClient(baseURL, axiosInstance);
-        this._mapResource = new AxiosMapResourceClient(baseURL, axiosInstance);
-        this._configurationResource = new AxiosConfigurationResourceClient(baseURL, axiosInstance);
-        this._alarmResource = new AxiosAlarmResourceClient(baseURL, axiosInstance);
-        this._assetResource = new AxiosAssetResourceClient(baseURL, axiosInstance);
         this._syslogResource = new AxiosSyslogResourceClient(baseURL, axiosInstance);
-        this._assetPredictedDatapointResource = new AxiosAssetPredictedDatapointResourceClient(baseURL, axiosInstance);
+        this._mapResource = new AxiosMapResourceClient(baseURL, axiosInstance);
         this._userResource = new AxiosUserResourceClient(baseURL, axiosInstance);
-        this._realmResource = new AxiosRealmResourceClient(baseURL, axiosInstance);
+        this._statusResource = new AxiosStatusResourceClient(baseURL, axiosInstance);
+        this._assetDatapointResource = new AxiosAssetDatapointResourceClient(baseURL, axiosInstance);
+        this._alarmResource = new AxiosAlarmResourceClient(baseURL, axiosInstance);
         this._gatewayClientResource = new AxiosGatewayClientResourceClient(baseURL, axiosInstance);
-        this._dashboardResource = new AxiosDashboardResourceClient(baseURL, axiosInstance);
-        this._appResource = new AxiosAppResourceClient(baseURL, axiosInstance);
+        this._consoleResource = new AxiosConsoleResourceClient(baseURL, axiosInstance);
+        this._agentResource = new AxiosAgentResourceClient(baseURL, axiosInstance);
+        this._realmResource = new AxiosRealmResourceClient(baseURL, axiosInstance);
+        this._flowResource = new AxiosFlowResourceClient(baseURL, axiosInstance);
+        this._gatewayServiceResource = new AxiosGatewayServiceResourceClient(baseURL, axiosInstance);
         this._assetResource = new AxiosAssetResourceClient(baseURL, axiosInstance);
     }
-    get AssetModelResource() {
-        return this._assetModelResource;
+    get ProvisioningResource() {
+        return this._provisioningResource;
     }
-    get AssetDatapointResource() {
-        return this._assetDatapointResource;
+    get AssetPredictedDatapointResource() {
+        return this._assetPredictedDatapointResource;
     }
-    get ConsoleResource() {
-        return this._consoleResource;
+    get DashboardResource() {
+        return this._dashboardResource;
     }
-    get GatewayServiceResource() {
-        return this._gatewayServiceResource;
+    get AssetResource() {
+        return this._assetResource;
     }
-    get ProvisioningResource() {
-        return this._provisioningResource;
+    get ConfigurationResource() {
+        return this._configurationResource;
+    }
+    get AppResource() {
+        return this._appResource;
     }
     get NotificationResource() {
         return this._notificationResource;
     }
+    get AssetModelResource() {
+        return this._assetModelResource;
+    }
     get RulesResource() {
         return this._rulesResource;
     }
-    get FlowResource() {
-        return this._flowResource;
+    get SyslogResource() {
+        return this._syslogResource;
     }
-    get AgentResource() {
-        return this._agentResource;
+    get MapResource() {
+        return this._mapResource;
+    }
+    get UserResource() {
+        return this._userResource;
     }
     get StatusResource() {
         return this._statusResource;
     }
-    get MapResource() {
-        return this._mapResource;
-    }
-    get ConfigurationResource() {
-        return this._configurationResource;
+    get AssetDatapointResource() {
+        return this._assetDatapointResource;
     }
     get AlarmResource() {
         return this._alarmResource;
     }
-    get AssetResource() {
-        return this._assetResource;
-    }
-    get SyslogResource() {
-        return this._syslogResource;
+    get GatewayClientResource() {
+        return this._gatewayClientResource;
     }
-    get AssetPredictedDatapointResource() {
-        return this._assetPredictedDatapointResource;
+    get ConsoleResource() {
+        return this._consoleResource;
     }
-    get UserResource() {
-        return this._userResource;
+    get AgentResource() {
+        return this._agentResource;
     }
     get RealmResource() {
         return this._realmResource;
     }
-    get GatewayClientResource() {
-        return this._gatewayClientResource;
-    }
-    get DashboardResource() {
-        return this._dashboardResource;
+    get FlowResource() {
+        return this._flowResource;
     }
-    get AppResource() {
-        return this._appResource;
+    get GatewayServiceResource() {
+        return this._gatewayServiceResource;
     }
 }
 // Added by 'AxiosClientExtension' extension
@@ -1212,61 +1212,61 @@ class AxiosHttpClient {
         });
     }
 }
-export class AxiosAssetModelResourceClient extends AssetModelResourceClient {
+export class AxiosProvisioningResourceClient extends ProvisioningResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetDatapointResourceClient extends AssetDatapointResourceClient {
+export class AxiosAssetPredictedDatapointResourceClient extends AssetPredictedDatapointResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosConsoleResourceClient extends ConsoleResourceClient {
+export class AxiosDashboardResourceClient extends DashboardResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosGatewayServiceResourceClient extends GatewayServiceResourceClient {
+export class AxiosAssetResourceClient extends AssetResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosProvisioningResourceClient extends ProvisioningResourceClient {
+export class AxiosConfigurationResourceClient extends ConfigurationResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosNotificationResourceClient extends NotificationResourceClient {
+export class AxiosAppResourceClient extends AppResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosRulesResourceClient extends RulesResourceClient {
+export class AxiosNotificationResourceClient extends NotificationResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosFlowResourceClient extends FlowResourceClient {
+export class AxiosAssetModelResourceClient extends AssetModelResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAgentResourceClient extends AgentResourceClient {
+export class AxiosRulesResourceClient extends RulesResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosStatusResourceClient extends StatusResourceClient {
+export class AxiosSyslogResourceClient extends SyslogResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
@@ -1278,61 +1278,61 @@ export class AxiosMapResourceClient extends MapResourceClient {
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosConfigurationResourceClient extends ConfigurationResourceClient {
+export class AxiosUserResourceClient extends UserResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAlarmResourceClient extends AlarmResourceClient {
+export class AxiosStatusResourceClient extends StatusResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetResourceClient extends AssetResourceClient {
+export class AxiosAssetDatapointResourceClient extends AssetDatapointResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosSyslogResourceClient extends SyslogResourceClient {
+export class AxiosAlarmResourceClient extends AlarmResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetPredictedDatapointResourceClient extends AssetPredictedDatapointResourceClient {
+export class AxiosGatewayClientResourceClient extends GatewayClientResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosUserResourceClient extends UserResourceClient {
+export class AxiosConsoleResourceClient extends ConsoleResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosRealmResourceClient extends RealmResourceClient {
+export class AxiosAgentResourceClient extends AgentResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosGatewayClientResourceClient extends GatewayClientResourceClient {
+export class AxiosRealmResourceClient extends RealmResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosDashboardResourceClient extends DashboardResourceClient {
+export class AxiosFlowResourceClient extends FlowResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAppResourceClient extends AppResourceClient {
+export class AxiosGatewayServiceResourceClient extends GatewayServiceResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));