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

@openremote/rest 1.8.0-snapshot.20250725120001 → 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 +534 -534
package/lib/restclient.js +653 -653
package/lib/restclient.js.map +1 -1
package/package.json +3 -3

package/lib/restclient.js CHANGED Viewed

@@ -1,423 +1,605 @@
 /* tslint:disable */
 /* eslint-disable */
-// Generated using typescript-generator version 3.2.1263 on 2025-07-25 13:54:25.
-export class NotificationResourceClient {
+// 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 /notification
-     * Java method: org.openremote.model.notification.NotificationResource.getNotifications
+     * HTTP POST /provisioning
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.createProvisioningConfig
      */
-    getNotifications(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `notification`, queryParams: queryParams, options: options });
+    createProvisioningConfig(provisioningConfig, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `provisioning`, data: provisioningConfig, options: options });
     }
     /**
-     * HTTP DELETE /notification
-     * Java method: org.openremote.model.notification.NotificationResource.removeNotifications
+     * HTTP GET /provisioning
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.getProvisioningConfigs
      */
-    removeNotifications(queryParams, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification`, queryParams: queryParams, options: options });
+    getProvisioningConfigs(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `provisioning`, options: options });
     }
     /**
-     * HTTP POST /notification/alert
-     * Java method: org.openremote.model.notification.NotificationResource.sendNotification
+     * HTTP DELETE /provisioning/{id}
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.deleteProvisioningConfig
      */
-    sendNotification(notification, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `notification/alert`, data: notification, options: options });
+    deleteProvisioningConfig(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `provisioning/${id}`, options: options });
     }
     /**
-     * HTTP DELETE /notification/{notificationId}
-     * Java method: org.openremote.model.notification.NotificationResource.removeNotification
+     * HTTP PUT /provisioning/{id}
+     * Java method: org.openremote.model.provisioning.ProvisioningResource.updateProvisioningConfig
      */
-    removeNotification(notificationId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification/${notificationId}`, options: options });
+    updateProvisioningConfig(id, provisioningConfig, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `provisioning/${id}`, data: provisioningConfig, options: options });
+    }
+}
+export class AssetPredictedDatapointResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP PUT /notification/{notificationId}/acknowledged
-     * Java method: org.openremote.model.notification.NotificationResource.notificationAcknowledged
+     * HTTP POST /asset/predicted/{assetId}/{attributeName}
+     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.getPredictedDatapoints
      */
-    notificationAcknowledged(notificationId, acknowledgement, queryParams, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/acknowledged`, queryParams: queryParams, data: acknowledgement, options: options });
+    getPredictedDatapoints(assetId, attributeName, query, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: query, options: options });
     }
     /**
-     * HTTP PUT /notification/{notificationId}/delivered
-     * Java method: org.openremote.model.notification.NotificationResource.notificationDelivered
+     * HTTP PUT /asset/predicted/{assetId}/{attributeName}
+     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.writePredictedDatapoints
      */
-    notificationDelivered(notificationId, queryParams, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/delivered`, queryParams: queryParams, 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 ConfigurationResourceClient {
+export class DashboardResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /configuration/manager
-     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfig
+     * HTTP POST /dashboard
+     * Java method: org.openremote.model.dashboard.DashboardResource.create
      */
-    getManagerConfig(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager`, options: options });
+    create(dashboard, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard`, data: dashboard, options: options });
     }
     /**
-     * HTTP PUT /configuration/manager
-     * Java method: org.openremote.model.manager.ConfigurationResource.update
+     * HTTP PUT /dashboard
+     * Java method: org.openremote.model.dashboard.DashboardResource.update
      */
-    update(managerConfiguration, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `configuration/manager`, data: managerConfiguration, options: options });
+    update(dashboard, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `dashboard`, data: dashboard, options: options });
     }
     /**
-     * HTTP POST /configuration/manager/file
-     * Java method: org.openremote.model.manager.ConfigurationResource.fileUpload
+     * HTTP GET /dashboard/all/{realm}
+     * Java method: org.openremote.model.dashboard.DashboardResource.getAllRealmDashboards
      */
-    fileUpload(fileInfo, queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `configuration/manager/file`, queryParams: queryParams, data: fileInfo, options: options });
+    getAllRealmDashboards(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/all/${realm}`, options: options });
     }
     /**
-     * HTTP GET /configuration/manager/image/{filename: .+}
-     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfigImage
+     * HTTP POST /dashboard/query
+     * Java method: org.openremote.model.dashboard.DashboardResource.query
      */
-    getManagerConfigImage(filename, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager/image/${filename}`, options: options });
+    query(dashboardQuery, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard/query`, data: dashboardQuery, options: options });
+    }
+    /**
+     * HTTP DELETE /dashboard/{realm}/{dashboardId}
+     * Java method: org.openremote.model.dashboard.DashboardResource.delete
+     */
+    delete(realm, dashboardId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
+    }
+    /**
+     * HTTP GET /dashboard/{realm}/{dashboardId}
+     * Java method: org.openremote.model.dashboard.DashboardResource.get
+     */
+    get(realm, dashboardId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
     }
 }
-export class MapResourceClient {
+export class AssetResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /map
-     * Java method: org.openremote.model.map.MapResource.getSettings
+     * HTTP POST /asset
+     * Java method: org.openremote.model.asset.AssetResource.create
      */
-    getSettings(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map`, options: options });
+    create(asset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset`, data: asset, options: options });
     }
     /**
-     * HTTP PUT /map
-     * Java method: org.openremote.model.map.MapResource.saveSettings
+     * HTTP DELETE /asset
+     * Java method: org.openremote.model.asset.AssetResource.delete
      */
-    saveSettings(mapConfig, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `map`, data: mapConfig, options: options });
+    delete(queryParams, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP DELETE /map/deleteMap
-     * Java method: org.openremote.model.map.MapResource.deleteMap
+     * HTTP PUT /asset/attributes
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValues
      */
-    deleteMap(options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `map/deleteMap`, options: options });
+    writeAttributeValues(attributeStates, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes`, data: attributeStates, options: options });
     }
     /**
-     * HTTP GET /map/getCustomMapInfo
-     * Java method: org.openremote.model.map.MapResource.getCustomMapInfo
+     * HTTP PUT /asset/attributes/timestamp
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeEvents
      */
-    getCustomMapInfo(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map/getCustomMapInfo`, options: options });
+    writeAttributeEvents(attributeEvents, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes/timestamp`, data: attributeEvents, options: options });
     }
     /**
-     * HTTP GET /map/js
-     * Java method: org.openremote.model.map.MapResource.getSettingsJs
+     * HTTP DELETE /asset/parent
+     * Java method: org.openremote.model.asset.AssetResource.updateNoneParent
      */
-    getSettingsJs(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map/js`, options: options });
+    updateNoneParent(queryParams, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/parent`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /map/tile/{zoom}/{column}/{row}
-     * Java method: org.openremote.model.map.MapResource.getTile
+     * HTTP GET /asset/partial/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.getPartial
      */
-    getTile(zoom, column, row, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `map/tile/${zoom}/${column}/${row}`, options: options });
+    getPartial(assetId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/partial/${assetId}`, options: options });
     }
     /**
-     * HTTP POST /map/upload
-     * Java method: org.openremote.model.map.MapResource.uploadMap
+     * HTTP POST /asset/query
+     * Java method: org.openremote.model.asset.AssetResource.queryAssets
      */
-    uploadMap(queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `map/upload`, queryParams: queryParams, options: options });
-    }
-}
-export class AlarmResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    queryAssets(query, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/query`, data: query, options: options });
     }
     /**
-     * HTTP POST /alarm
-     * Java method: org.openremote.model.alarm.AlarmResource.createAlarm
+     * HTTP GET /asset/user/current
+     * Java method: org.openremote.model.asset.AssetResource.getCurrentUserAssets
      */
-    createAlarm(alarm, queryParams, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `alarm`, queryParams: queryParams, data: alarm, options: options });
+    getCurrentUserAssets(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/current`, options: options });
     }
     /**
-     * HTTP GET /alarm
-     * Java method: org.openremote.model.alarm.AlarmResource.getAlarms
+     * HTTP POST /asset/user/link
+     * Java method: org.openremote.model.asset.AssetResource.createUserAssetLinks
      */
-    getAlarms(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm`, queryParams: queryParams, options: options });
+    createUserAssetLinks(userAssets, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link`, data: userAssets, options: options });
     }
     /**
-     * HTTP DELETE /alarm
-     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarms
+     * HTTP GET /asset/user/link
+     * Java method: org.openremote.model.asset.AssetResource.getUserAssetLinks
      */
-    removeAlarms(ids, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm`, data: ids, options: options });
+    getUserAssetLinks(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/link`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP PUT /alarm/assets
-     * Java method: org.openremote.model.alarm.AlarmResource.setAssetLinks
+     * HTTP POST /asset/user/link/delete
+     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLinks
      */
-    setAssetLinks(links, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `alarm/assets`, data: links, options: options });
+    deleteUserAssetLinks(userAssets, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link/delete`, data: userAssets, options: options });
     }
     /**
-     * HTTP GET /alarm/{alarmId}
-     * Java method: org.openremote.model.alarm.AlarmResource.getAlarm
+     * HTTP DELETE /asset/user/link/{realm}/{userId}
+     * Java method: org.openremote.model.asset.AssetResource.deleteAllUserAssetLinks
      */
-    getAlarm(alarmId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}`, options: options });
+    deleteAllUserAssetLinks(realm, userId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}`, options: options });
     }
     /**
-     * HTTP DELETE /alarm/{alarmId}
-     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarm
+     * HTTP DELETE /asset/user/link/{realm}/{userId}/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLink
      */
-    removeAlarm(alarmId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm/${alarmId}`, options: options });
+    deleteUserAssetLink(realm, userId, assetId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}/${assetId}`, options: options });
     }
     /**
-     * HTTP PUT /alarm/{alarmId}
-     * Java method: org.openremote.model.alarm.AlarmResource.updateAlarm
+     * HTTP GET /asset/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.get
      */
-    updateAlarm(alarmId, alarm, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `alarm/${alarmId}`, data: alarm, options: options });
+    get(assetId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/${assetId}`, options: options });
     }
     /**
-     * HTTP GET /alarm/{alarmId}/assets
-     * Java method: org.openremote.model.alarm.AlarmResource.getAssetLinks
+     * HTTP PUT /asset/{assetId}
+     * Java method: org.openremote.model.asset.AssetResource.update
      */
-    getAssetLinks(alarmId, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}/assets`, queryParams: queryParams, options: options });
-    }
-}
-export class SyslogResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    update(assetId, asset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}`, data: asset, options: options });
     }
     /**
-     * HTTP GET /syslog/config
-     * Java method: org.openremote.model.syslog.SyslogResource.getConfig
+     * HTTP PUT /asset/{assetId}/attribute/{attributeName}
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
      */
-    getConfig(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `syslog/config`, 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 PUT /syslog/config
-     * Java method: org.openremote.model.syslog.SyslogResource.updateConfig
+     * HTTP PUT /asset/{assetId}/attribute/{attributeName}/{timestamp}
+     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
      */
-    updateConfig(config, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `syslog/config`, data: config, 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 /syslog/event
-     * Java method: org.openremote.model.syslog.SyslogResource.clearEvents
+     * HTTP PUT /asset/{parentAssetId}/child
+     * Java method: org.openremote.model.asset.AssetResource.updateParent
      */
-    clearEvents(options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `syslog/event`, options: options });
-    }
-    /**
-     * HTTP GET /syslog/event
-     * Java method: org.openremote.model.syslog.SyslogResource.getEvents
-     */
-    getEvents(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `syslog/event`, queryParams: queryParams, options: options });
+    updateParent(parentAssetId, queryParams, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${parentAssetId}/child`, queryParams: queryParams, options: options });
     }
 }
-export class GatewayServiceResourceClient {
+export class ConfigurationResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /gateway/tunnel
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.startTunnel
+     * HTTP GET /configuration/manager
+     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfig
      */
-    startTunnel(tunnelInfo, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
+    getManagerConfig(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager`, options: options });
     }
     /**
-     * HTTP DELETE /gateway/tunnel
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.stopTunnel
+     * HTTP PUT /configuration/manager
+     * Java method: org.openremote.model.manager.ConfigurationResource.update
      */
-    stopTunnel(tunnelInfo, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
+    update(managerConfiguration, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `configuration/manager`, data: managerConfiguration, options: options });
     }
     /**
-     * HTTP GET /gateway/tunnel/{realm}
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.getAllActiveTunnelInfos
+     * HTTP POST /configuration/manager/file
+     * Java method: org.openremote.model.manager.ConfigurationResource.fileUpload
      */
-    getAllActiveTunnelInfos(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}`, options: options });
+    fileUpload(fileInfo, queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `configuration/manager/file`, queryParams: queryParams, data: fileInfo, options: options });
     }
     /**
-     * HTTP GET /gateway/tunnel/{realm}/{id}
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.getGatewayActiveTunnelInfos
+     * HTTP GET /configuration/manager/image/{filename: .+}
+     * Java method: org.openremote.model.manager.ConfigurationResource.getManagerConfigImage
      */
-    getGatewayActiveTunnelInfos(realm, id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}`, options: options });
+    getManagerConfigImage(filename, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `configuration/manager/image/${filename}`, options: options });
+    }
+}
+export class AppResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /gateway/tunnel/{realm}/{id}/{target}/{targetPort}
-     * Java method: org.openremote.model.gateway.GatewayServiceResource.getActiveTunnelInfo
+     * HTTP GET /apps
+     * Java method: org.openremote.model.apps.AppResource.getApps
      */
-    getActiveTunnelInfo(realm, id, target, targetPort, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}/${target}/${targetPort}`, options: options });
+    getApps(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `apps`, options: options });
+    }
+    /**
+     * HTTP GET /apps/consoleConfig
+     * Java method: org.openremote.model.apps.AppResource.getConsoleConfig
+     */
+    getConsoleConfig(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/consoleConfig`, options: options });
+    }
+    /**
+     * HTTP GET /apps/info
+     * Java method: org.openremote.model.apps.AppResource.getAppInfos
+     */
+    getAppInfos(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/info`, options: options });
     }
 }
-export class DashboardResourceClient {
+export class NotificationResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /dashboard
-     * Java method: org.openremote.model.dashboard.DashboardResource.create
+     * HTTP GET /notification
+     * Java method: org.openremote.model.notification.NotificationResource.getNotifications
      */
-    create(dashboard, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard`, data: dashboard, options: options });
+    getNotifications(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `notification`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP PUT /dashboard
-     * Java method: org.openremote.model.dashboard.DashboardResource.update
+     * HTTP DELETE /notification
+     * Java method: org.openremote.model.notification.NotificationResource.removeNotifications
      */
-    update(dashboard, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `dashboard`, data: dashboard, options: options });
+    removeNotifications(queryParams, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /dashboard/all/{realm}
-     * Java method: org.openremote.model.dashboard.DashboardResource.getAllRealmDashboards
+     * HTTP POST /notification/alert
+     * Java method: org.openremote.model.notification.NotificationResource.sendNotification
      */
-    getAllRealmDashboards(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/all/${realm}`, options: options });
+    sendNotification(notification, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `notification/alert`, data: notification, options: options });
     }
     /**
-     * HTTP POST /dashboard/query
-     * Java method: org.openremote.model.dashboard.DashboardResource.query
+     * HTTP DELETE /notification/{notificationId}
+     * Java method: org.openremote.model.notification.NotificationResource.removeNotification
      */
-    query(dashboardQuery, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `dashboard/query`, data: dashboardQuery, options: options });
+    removeNotification(notificationId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `notification/${notificationId}`, options: options });
     }
     /**
-     * HTTP DELETE /dashboard/{realm}/{dashboardId}
-     * Java method: org.openremote.model.dashboard.DashboardResource.delete
+     * HTTP PUT /notification/{notificationId}/acknowledged
+     * Java method: org.openremote.model.notification.NotificationResource.notificationAcknowledged
      */
-    delete(realm, dashboardId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `dashboard/${realm}/${dashboardId}`, 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 /dashboard/{realm}/{dashboardId}
-     * Java method: org.openremote.model.dashboard.DashboardResource.get
+     * HTTP PUT /notification/{notificationId}/delivered
+     * Java method: org.openremote.model.notification.NotificationResource.notificationDelivered
      */
-    get(realm, dashboardId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `dashboard/${realm}/${dashboardId}`, options: options });
+    notificationDelivered(notificationId, queryParams, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `notification/${notificationId}/delivered`, queryParams: queryParams, options: options });
     }
 }
-export class ConsoleResourceClient {
+export class AssetModelResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /console/register
-     * Java method: org.openremote.model.console.ConsoleResource.register
+     * HTTP GET /model/assetDescriptors
+     * Java method: org.openremote.model.asset.AssetModelResource.getAssetDescriptors
      */
-    register(consoleRegistration, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `console/register`, data: consoleRegistration, options: options });
+    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
+     */
+    getAssetInfo(assetType, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfo/${assetType}`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP GET /model/assetInfos
+     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfos
+     */
+    getAssetInfos(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfos`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP GET /model/metaItemDescriptors
+     * Java method: org.openremote.model.asset.AssetModelResource.getMetaItemDescriptors
+     */
+    getMetaItemDescriptors(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/metaItemDescriptors`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP GET /model/valueDescriptors
+     * Java method: org.openremote.model.asset.AssetModelResource.getValueDescriptors
+     */
+    getValueDescriptors(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `model/valueDescriptors`, queryParams: queryParams, options: options });
     }
 }
-export class StatusResourceClient {
+export class RulesResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /health
-     * Java method: org.openremote.model.system.StatusResource.getHealthStatus
+     * HTTP POST /rules
+     * Java method: org.openremote.model.rules.RulesResource.createGlobalRuleset
+     */
+    createGlobalRuleset(ruleset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `rules`, data: ruleset, options: options });
+    }
+    /**
+     * HTTP GET /rules
+     * Java method: org.openremote.model.rules.RulesResource.getGlobalRulesets
+     */
+    getGlobalRulesets(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP POST /rules/asset
+     * Java method: org.openremote.model.rules.RulesResource.createAssetRuleset
+     */
+    createAssetRuleset(ruleset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/asset`, data: ruleset, options: options });
+    }
+    /**
+     * HTTP GET /rules/asset/for/{assetId}
+     * Java method: org.openremote.model.rules.RulesResource.getAssetRulesets
+     */
+    getAssetRulesets(assetId, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/asset/for/${assetId}`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP DELETE /rules/asset/{id}
+     * Java method: org.openremote.model.rules.RulesResource.deleteAssetRuleset
+     */
+    deleteAssetRuleset(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/asset/${id}`, 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
+     */
+    createRealmRuleset(ruleset, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/realm`, data: ruleset, options: options });
+    }
+    /**
+     * HTTP GET /rules/realm/for/{realm}
+     * Java method: org.openremote.model.rules.RulesResource.getRealmRulesets
+     */
+    getRealmRulesets(realm, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/for/${realm}`, queryParams: queryParams, options: options });
+    }
+    /**
+     * HTTP DELETE /rules/realm/{id}
+     * Java method: org.openremote.model.rules.RulesResource.deleteRealmRuleset
+     */
+    deleteRealmRuleset(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/realm/${id}`, 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 });
+    }
+    /**
+     * HTTP PUT /rules/realm/{id}
+     * Java method: org.openremote.model.rules.RulesResource.updateRealmRuleset
+     */
+    updateRealmRuleset(id, ruleset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/realm/${id}`, data: ruleset, options: options });
+    }
+    /**
+     * HTTP DELETE /rules/{id}
+     * Java method: org.openremote.model.rules.RulesResource.deleteGlobalRuleset
+     */
+    deleteGlobalRuleset(id, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/${id}`, options: options });
+    }
+    /**
+     * HTTP GET /rules/{id}
+     * Java method: org.openremote.model.rules.RulesResource.getGlobalRuleset
      */
-    getHealthStatus(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `health`, options: options });
+    getGlobalRuleset(id, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/${id}`, options: options });
     }
     /**
-     * HTTP GET /info
-     * Java method: org.openremote.model.system.StatusResource.getInfo
+     * HTTP PUT /rules/{id}
+     * Java method: org.openremote.model.rules.RulesResource.updateGlobalRuleset
      */
-    getInfo(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `info`, options: options });
+    updateGlobalRuleset(id, ruleset, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/${id}`, data: ruleset, options: options });
     }
 }
-export class ProvisioningResourceClient {
+export class SyslogResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /provisioning
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.createProvisioningConfig
+     * HTTP GET /syslog/config
+     * Java method: org.openremote.model.syslog.SyslogResource.getConfig
      */
-    createProvisioningConfig(provisioningConfig, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `provisioning`, data: provisioningConfig, options: options });
+    getConfig(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `syslog/config`, options: options });
     }
     /**
-     * HTTP GET /provisioning
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.getProvisioningConfigs
+     * HTTP PUT /syslog/config
+     * Java method: org.openremote.model.syslog.SyslogResource.updateConfig
      */
-    getProvisioningConfigs(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `provisioning`, options: options });
+    updateConfig(config, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `syslog/config`, data: config, options: options });
     }
     /**
-     * HTTP DELETE /provisioning/{id}
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.deleteProvisioningConfig
+     * HTTP DELETE /syslog/event
+     * Java method: org.openremote.model.syslog.SyslogResource.clearEvents
      */
-    deleteProvisioningConfig(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `provisioning/${id}`, options: options });
+    clearEvents(options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `syslog/event`, options: options });
     }
     /**
-     * HTTP PUT /provisioning/{id}
-     * Java method: org.openremote.model.provisioning.ProvisioningResource.updateProvisioningConfig
+     * HTTP GET /syslog/event
+     * Java method: org.openremote.model.syslog.SyslogResource.getEvents
      */
-    updateProvisioningConfig(id, provisioningConfig, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `provisioning/${id}`, data: provisioningConfig, options: options });
+    getEvents(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `syslog/event`, queryParams: queryParams, options: options });
     }
 }
-export class AssetModelResourceClient {
+export class MapResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /model/assetDescriptors
-     * Java method: org.openremote.model.asset.AssetModelResource.getAssetDescriptors
+     * HTTP GET /map
+     * Java method: org.openremote.model.map.MapResource.getSettings
      */
-    getAssetDescriptors(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetDescriptors`, queryParams: queryParams, options: options });
+    getSettings(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `map`, options: options });
     }
     /**
-     * HTTP GET /model/assetInfo/{assetType}
-     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfo
+     * HTTP PUT /map
+     * Java method: org.openremote.model.map.MapResource.saveSettings
      */
-    getAssetInfo(assetType, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfo/${assetType}`, queryParams: queryParams, options: options });
+    saveSettings(mapConfig, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `map`, data: mapConfig, options: options });
     }
     /**
-     * HTTP GET /model/assetInfos
-     * Java method: org.openremote.model.asset.AssetModelResource.getAssetInfos
+     * HTTP DELETE /map/deleteMap
+     * Java method: org.openremote.model.map.MapResource.deleteMap
      */
-    getAssetInfos(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/assetInfos`, queryParams: queryParams, options: options });
+    deleteMap(options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `map/deleteMap`, options: options });
     }
     /**
-     * HTTP GET /model/metaItemDescriptors
-     * Java method: org.openremote.model.asset.AssetModelResource.getMetaItemDescriptors
+     * HTTP GET /map/getCustomMapInfo
+     * Java method: org.openremote.model.map.MapResource.getCustomMapInfo
      */
-    getMetaItemDescriptors(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/metaItemDescriptors`, queryParams: queryParams, options: options });
+    getCustomMapInfo(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `map/getCustomMapInfo`, options: options });
     }
     /**
-     * HTTP GET /model/valueDescriptors
-     * Java method: org.openremote.model.asset.AssetModelResource.getValueDescriptors
+     * HTTP GET /map/js
+     * Java method: org.openremote.model.map.MapResource.getSettingsJs
      */
-    getValueDescriptors(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `model/valueDescriptors`, queryParams: queryParams, options: options });
+    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 {
@@ -540,221 +722,76 @@ export class UserResourceClient {
      * HTTP PUT /user/{realm}/userRoles/{userId}/{clientId}
      * Java method: org.openremote.model.security.UserResource.updateUserClientRoles
      */
-    updateUserClientRoles(realm, userId, clientId, roles, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `user/${realm}/userRoles/${userId}/${clientId}`, data: roles, options: options });
-    }
-    /**
-     * HTTP GET /user/{realm}/userSessions/{userId}
-     * Java method: org.openremote.model.security.UserResource.getUserSessions
-     */
-    getUserSessions(realm, userId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/userSessions/${userId}`, options: options });
-    }
-    /**
-     * HTTP POST /user/{realm}/users
-     * Java method: org.openremote.model.security.UserResource.create
-     */
-    create(realm, user, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `user/${realm}/users`, data: user, options: options });
-    }
-    /**
-     * HTTP PUT /user/{realm}/users
-     * Java method: org.openremote.model.security.UserResource.update
-     */
-    update(realm, user, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `user/${realm}/users`, data: user, options: options });
-    }
-    /**
-     * HTTP DELETE /user/{realm}/users/{userId}
-     * Java method: org.openremote.model.security.UserResource.delete
-     */
-    delete(realm, userId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `user/${realm}/users/${userId}`, options: options });
-    }
-    /**
-     * HTTP GET /user/{realm}/{clientId}/roles
-     * Java method: org.openremote.model.security.UserResource.getClientRoles
-     */
-    getClientRoles(realm, clientId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/${clientId}/roles`, options: options });
-    }
-    /**
-     * HTTP PUT /user/{realm}/{clientId}/roles
-     * Java method: org.openremote.model.security.UserResource.updateClientRoles
-     */
-    updateClientRoles(realm, clientId, roles, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `user/${realm}/${clientId}/roles`, data: roles, options: options });
-    }
-    /**
-     * HTTP GET /user/{realm}/{userId}
-     * Java method: org.openremote.model.security.UserResource.get
-     */
-    get(realm, userId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/${userId}`, 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 RulesResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-    }
-    /**
-     * HTTP POST /rules
-     * Java method: org.openremote.model.rules.RulesResource.createGlobalRuleset
-     */
-    createGlobalRuleset(ruleset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `rules`, data: ruleset, options: options });
-    }
-    /**
-     * HTTP GET /rules
-     * Java method: org.openremote.model.rules.RulesResource.getGlobalRulesets
-     */
-    getGlobalRulesets(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules`, queryParams: queryParams, options: options });
-    }
-    /**
-     * HTTP POST /rules/asset
-     * Java method: org.openremote.model.rules.RulesResource.createAssetRuleset
-     */
-    createAssetRuleset(ruleset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/asset`, data: ruleset, options: options });
-    }
-    /**
-     * HTTP GET /rules/asset/for/{assetId}
-     * Java method: org.openremote.model.rules.RulesResource.getAssetRulesets
-     */
-    getAssetRulesets(assetId, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/asset/for/${assetId}`, queryParams: queryParams, options: options });
-    }
-    /**
-     * HTTP DELETE /rules/asset/{id}
-     * Java method: org.openremote.model.rules.RulesResource.deleteAssetRuleset
-     */
-    deleteAssetRuleset(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/asset/${id}`, 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 });
+    updateUserClientRoles(realm, userId, clientId, roles, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `user/${realm}/userRoles/${userId}/${clientId}`, data: roles, options: options });
     }
     /**
-     * HTTP GET /rules/info/realm/{realm}
-     * Java method: org.openremote.model.rules.RulesResource.getRealmEngineInfo
+     * HTTP GET /user/{realm}/userSessions/{userId}
+     * Java method: org.openremote.model.security.UserResource.getUserSessions
      */
-    getRealmEngineInfo(realm, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/info/realm/${realm}`, options: options });
+    getUserSessions(realm, userId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/userSessions/${userId}`, options: options });
     }
     /**
-     * HTTP POST /rules/realm
-     * Java method: org.openremote.model.rules.RulesResource.createRealmRuleset
+     * HTTP POST /user/{realm}/users
+     * Java method: org.openremote.model.security.UserResource.create
      */
-    createRealmRuleset(ruleset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `rules/realm`, data: ruleset, options: options });
+    create(realm, user, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `user/${realm}/users`, data: user, options: options });
     }
     /**
-     * HTTP GET /rules/realm/for/{realm}
-     * Java method: org.openremote.model.rules.RulesResource.getRealmRulesets
+     * HTTP PUT /user/{realm}/users
+     * Java method: org.openremote.model.security.UserResource.update
      */
-    getRealmRulesets(realm, queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/for/${realm}`, queryParams: queryParams, options: options });
+    update(realm, user, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `user/${realm}/users`, data: user, options: options });
     }
     /**
-     * HTTP DELETE /rules/realm/{id}
-     * Java method: org.openremote.model.rules.RulesResource.deleteRealmRuleset
+     * HTTP DELETE /user/{realm}/users/{userId}
+     * Java method: org.openremote.model.security.UserResource.delete
      */
-    deleteRealmRuleset(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/realm/${id}`, options: options });
+    delete(realm, userId, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `user/${realm}/users/${userId}`, options: options });
     }
     /**
-     * HTTP GET /rules/realm/{id}
-     * Java method: org.openremote.model.rules.RulesResource.getRealmRuleset
+     * HTTP GET /user/{realm}/{clientId}/roles
+     * Java method: org.openremote.model.security.UserResource.getClientRoles
      */
-    getRealmRuleset(id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/realm/${id}`, options: options });
+    getClientRoles(realm, clientId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/${clientId}/roles`, options: options });
     }
     /**
-     * HTTP PUT /rules/realm/{id}
-     * Java method: org.openremote.model.rules.RulesResource.updateRealmRuleset
+     * HTTP PUT /user/{realm}/{clientId}/roles
+     * Java method: org.openremote.model.security.UserResource.updateClientRoles
      */
-    updateRealmRuleset(id, ruleset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/realm/${id}`, data: ruleset, options: options });
+    updateClientRoles(realm, clientId, roles, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `user/${realm}/${clientId}/roles`, data: roles, options: options });
     }
     /**
-     * HTTP DELETE /rules/{id}
-     * Java method: org.openremote.model.rules.RulesResource.deleteGlobalRuleset
+     * HTTP GET /user/{realm}/{userId}
+     * Java method: org.openremote.model.security.UserResource.get
      */
-    deleteGlobalRuleset(id, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `rules/${id}`, options: options });
+    get(realm, userId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `user/${realm}/${userId}`, options: options });
+    }
+}
+export class StatusResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /rules/{id}
-     * Java method: org.openremote.model.rules.RulesResource.getGlobalRuleset
+     * HTTP GET /health
+     * Java method: org.openremote.model.system.StatusResource.getHealthStatus
      */
-    getGlobalRuleset(id, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `rules/${id}`, options: options });
+    getHealthStatus(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `health`, options: options });
     }
     /**
-     * HTTP PUT /rules/{id}
-     * Java method: org.openremote.model.rules.RulesResource.updateGlobalRuleset
+     * HTTP GET /info
+     * Java method: org.openremote.model.system.StatusResource.getInfo
      */
-    updateGlobalRuleset(id, ruleset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `rules/${id}`, data: ruleset, options: options });
+    getInfo(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `info`, options: options });
     }
 }
 export class AssetDatapointResourceClient {
@@ -783,49 +820,65 @@ export class AssetDatapointResourceClient {
         return this.httpClient.request({ method: "POST", url: uriEncoding `asset/datapoint/${assetId}/${attributeName}`, data: query, options: options });
     }
 }
-export class AppResourceClient {
+export class AlarmResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /apps
-     * Java method: org.openremote.model.apps.AppResource.getApps
+     * HTTP POST /alarm
+     * Java method: org.openremote.model.alarm.AlarmResource.createAlarm
      */
-    getApps(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `apps`, options: options });
+    createAlarm(alarm, queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `alarm`, queryParams: queryParams, data: alarm, options: options });
     }
     /**
-     * HTTP GET /apps/consoleConfig
-     * Java method: org.openremote.model.apps.AppResource.getConsoleConfig
+     * HTTP GET /alarm
+     * Java method: org.openremote.model.alarm.AlarmResource.getAlarms
      */
-    getConsoleConfig(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/consoleConfig`, options: options });
+    getAlarms(queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /apps/info
-     * Java method: org.openremote.model.apps.AppResource.getAppInfos
+     * HTTP DELETE /alarm
+     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarms
      */
-    getAppInfos(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `apps/info`, options: options });
+    removeAlarms(ids, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `alarm`, data: ids, options: options });
     }
-}
-export class AssetPredictedDatapointResourceClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
+    /**
+     * 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 POST /asset/predicted/{assetId}/{attributeName}
-     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.getPredictedDatapoints
+     * HTTP GET /alarm/{alarmId}
+     * Java method: org.openremote.model.alarm.AlarmResource.getAlarm
      */
-    getPredictedDatapoints(assetId, attributeName, query, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: query, options: options });
+    getAlarm(alarmId, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `alarm/${alarmId}`, options: options });
     }
     /**
-     * HTTP PUT /asset/predicted/{assetId}/{attributeName}
-     * Java method: org.openremote.model.datapoint.AssetPredictedDatapointResource.writePredictedDatapoints
+     * HTTP DELETE /alarm/{alarmId}
+     * Java method: org.openremote.model.alarm.AlarmResource.removeAlarm
      */
-    writePredictedDatapoints(assetId, attributeName, predictedDatapoints, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/predicted/${assetId}/${attributeName}`, data: predictedDatapoints, options: options });
+    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 {
@@ -875,208 +928,155 @@ export class GatewayClientResourceClient {
         return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/status/${realm}`, options: options });
     }
 }
-export class FlowResourceClient {
+export class ConsoleResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /flow
-     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitions
-     */
-    getAllNodeDefinitions(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `flow`, options: options });
-    }
-    /**
-     * HTTP GET /flow/{name}
-     * Java method: org.openremote.model.rules.flow.FlowResource.getNodeDefinition
-     */
-    getNodeDefinition(name, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${name}`, options: options });
-    }
-    /**
-     * HTTP GET /flow/{type}
-     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitionsByType
+     * HTTP POST /console/register
+     * Java method: org.openremote.model.console.ConsoleResource.register
      */
-    getAllNodeDefinitionsByType(type, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${type}`, options: options });
+    register(consoleRegistration, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `console/register`, data: consoleRegistration, options: options });
     }
 }
-export class RealmResourceClient {
+export class AgentResourceClient {
     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
-     */
-    getAccessible(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/accessible`, options: options });
-    }
-    /**
-     * HTTP DELETE /realm/{name}
-     * Java method: org.openremote.model.security.RealmResource.delete
+     * HTTP GET /agent/assetDiscovery/{agentId}
+     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolAssetDiscovery
      */
-    delete(name, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `realm/${name}`, options: options });
+    doProtocolAssetDiscovery(agentId, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `agent/assetDiscovery/${agentId}`, queryParams: queryParams, options: options });
     }
     /**
-     * HTTP GET /realm/{name}
-     * Java method: org.openremote.model.security.RealmResource.get
+     * HTTP POST /agent/assetImport/{agentId}
+     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolAssetImport
      */
-    get(name, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/${name}`, options: options });
+    doProtocolAssetImport(agentId, fileInfo, queryParams, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `agent/assetImport/${agentId}`, queryParams: queryParams, data: fileInfo, options: options });
     }
     /**
-     * HTTP PUT /realm/{name}
-     * Java method: org.openremote.model.security.RealmResource.update
+     * HTTP GET /agent/instanceDiscovery/{agentType}
+     * Java method: org.openremote.model.asset.agent.AgentResource.doProtocolInstanceDiscovery
      */
-    update(name, realm, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `realm/${name}`, data: realm, options: options });
+    doProtocolInstanceDiscovery(agentType, queryParams, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `agent/instanceDiscovery/${agentType}`, queryParams: queryParams, options: options });
     }
 }
-export class AssetResourceClient {
+export class RealmResourceClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /asset
-     * Java method: org.openremote.model.asset.AssetResource.create
-     */
-    create(asset, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset`, data: asset, options: options });
-    }
-    /**
-     * HTTP DELETE /asset
-     * Java method: org.openremote.model.asset.AssetResource.delete
-     */
-    delete(queryParams, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset`, queryParams: queryParams, options: options });
-    }
-    /**
-     * HTTP PUT /asset/attributes
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValues
-     */
-    writeAttributeValues(attributeStates, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes`, data: attributeStates, options: options });
-    }
-    /**
-     * HTTP PUT /asset/attributes/timestamp
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeEvents
-     */
-    writeAttributeEvents(attributeEvents, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/attributes/timestamp`, data: attributeEvents, options: options });
-    }
-    /**
-     * HTTP DELETE /asset/parent
-     * Java method: org.openremote.model.asset.AssetResource.updateNoneParent
+     * HTTP POST /realm
+     * Java method: org.openremote.model.security.RealmResource.create
      */
-    updateNoneParent(queryParams, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/parent`, queryParams: queryParams, options: options });
+    create(realm, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `realm`, data: realm, options: options });
     }
     /**
-     * HTTP GET /asset/partial/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.getPartial
+     * HTTP GET /realm
+     * Java method: org.openremote.model.security.RealmResource.getAll
      */
-    getPartial(assetId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/partial/${assetId}`, options: options });
+    getAll(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `realm`, options: options });
     }
     /**
-     * HTTP POST /asset/query
-     * Java method: org.openremote.model.asset.AssetResource.queryAssets
+     * HTTP GET /realm/accessible
+     * Java method: org.openremote.model.security.RealmResource.getAccessible
      */
-    queryAssets(query, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/query`, data: query, options: options });
+    getAccessible(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/accessible`, options: options });
     }
     /**
-     * HTTP GET /asset/user/current
-     * Java method: org.openremote.model.asset.AssetResource.getCurrentUserAssets
+     * HTTP DELETE /realm/{name}
+     * Java method: org.openremote.model.security.RealmResource.delete
      */
-    getCurrentUserAssets(options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/current`, options: options });
+    delete(name, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `realm/${name}`, options: options });
     }
     /**
-     * HTTP POST /asset/user/link
-     * Java method: org.openremote.model.asset.AssetResource.createUserAssetLinks
+     * HTTP GET /realm/{name}
+     * Java method: org.openremote.model.security.RealmResource.get
      */
-    createUserAssetLinks(userAssets, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link`, data: userAssets, options: options });
+    get(name, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `realm/${name}`, options: options });
     }
     /**
-     * HTTP GET /asset/user/link
-     * Java method: org.openremote.model.asset.AssetResource.getUserAssetLinks
+     * HTTP PUT /realm/{name}
+     * Java method: org.openremote.model.security.RealmResource.update
      */
-    getUserAssetLinks(queryParams, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/user/link`, queryParams: queryParams, options: options });
+    update(name, realm, options) {
+        return this.httpClient.request({ method: "PUT", url: uriEncoding `realm/${name}`, data: realm, options: options });
+    }
+}
+export class FlowResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP POST /asset/user/link/delete
-     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLinks
+     * HTTP GET /flow
+     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitions
      */
-    deleteUserAssetLinks(userAssets, options) {
-        return this.httpClient.request({ method: "POST", url: uriEncoding `asset/user/link/delete`, data: userAssets, options: options });
+    getAllNodeDefinitions(options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `flow`, options: options });
     }
     /**
-     * HTTP DELETE /asset/user/link/{realm}/{userId}
-     * Java method: org.openremote.model.asset.AssetResource.deleteAllUserAssetLinks
+     * HTTP GET /flow/{name}
+     * Java method: org.openremote.model.rules.flow.FlowResource.getNodeDefinition
      */
-    deleteAllUserAssetLinks(realm, userId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}`, options: options });
+    getNodeDefinition(name, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${name}`, options: options });
     }
     /**
-     * HTTP DELETE /asset/user/link/{realm}/{userId}/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.deleteUserAssetLink
+     * HTTP GET /flow/{type}
+     * Java method: org.openremote.model.rules.flow.FlowResource.getAllNodeDefinitionsByType
      */
-    deleteUserAssetLink(realm, userId, assetId, options) {
-        return this.httpClient.request({ method: "DELETE", url: uriEncoding `asset/user/link/${realm}/${userId}/${assetId}`, options: options });
+    getAllNodeDefinitionsByType(type, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `flow/${type}`, options: options });
+    }
+}
+export class GatewayServiceResourceClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /**
-     * HTTP GET /asset/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.get
+     * HTTP POST /gateway/tunnel
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.startTunnel
      */
-    get(assetId, options) {
-        return this.httpClient.request({ method: "GET", url: uriEncoding `asset/${assetId}`, options: options });
+    startTunnel(tunnelInfo, options) {
+        return this.httpClient.request({ method: "POST", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
     }
     /**
-     * HTTP PUT /asset/{assetId}
-     * Java method: org.openremote.model.asset.AssetResource.update
+     * HTTP DELETE /gateway/tunnel
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.stopTunnel
      */
-    update(assetId, asset, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${assetId}`, data: asset, options: options });
+    stopTunnel(tunnelInfo, options) {
+        return this.httpClient.request({ method: "DELETE", url: uriEncoding `gateway/tunnel`, data: tunnelInfo, options: options });
     }
     /**
-     * HTTP PUT /asset/{assetId}/attribute/{attributeName}
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
+     * HTTP GET /gateway/tunnel/{realm}
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.getAllActiveTunnelInfos
      */
-    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 });
+    getAllActiveTunnelInfos(realm, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}`, options: options });
     }
     /**
-     * HTTP PUT /asset/{assetId}/attribute/{attributeName}/{timestamp}
-     * Java method: org.openremote.model.asset.AssetResource.writeAttributeValue
+     * HTTP GET /gateway/tunnel/{realm}/{id}
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.getGatewayActiveTunnelInfos
      */
-    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 });
+    getGatewayActiveTunnelInfos(realm, id, options) {
+        return this.httpClient.request({ method: "GET", url: uriEncoding `gateway/tunnel/${realm}/${id}`, options: options });
     }
     /**
-     * HTTP PUT /asset/{parentAssetId}/child
-     * Java method: org.openremote.model.asset.AssetResource.updateParent
+     * HTTP GET /gateway/tunnel/{realm}/{id}/{target}/{targetPort}
+     * Java method: org.openremote.model.gateway.GatewayServiceResource.getActiveTunnelInfo
      */
-    updateParent(parentAssetId, queryParams, options) {
-        return this.httpClient.request({ method: "PUT", url: uriEncoding `asset/${parentAssetId}/child`, queryParams: queryParams, 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._notificationResource = new AxiosNotificationResourceClient(baseURL, axiosInstance);
-        this._configurationResource = new AxiosConfigurationResourceClient(baseURL, axiosInstance);
-        this._mapResource = new AxiosMapResourceClient(baseURL, axiosInstance);
-        this._alarmResource = new AxiosAlarmResourceClient(baseURL, axiosInstance);
-        this._syslogResource = new AxiosSyslogResourceClient(baseURL, axiosInstance);
-        this._gatewayServiceResource = new AxiosGatewayServiceResourceClient(baseURL, axiosInstance);
-        this._dashboardResource = new AxiosDashboardResourceClient(baseURL, axiosInstance);
-        this._consoleResource = new AxiosConsoleResourceClient(baseURL, axiosInstance);
-        this._statusResource = new AxiosStatusResourceClient(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._userResource = new AxiosUserResourceClient(baseURL, axiosInstance);
-        this._agentResource = new AxiosAgentResourceClient(baseURL, axiosInstance);
         this._rulesResource = new AxiosRulesResourceClient(baseURL, axiosInstance);
+        this._syslogResource = new AxiosSyslogResourceClient(baseURL, axiosInstance);
+        this._mapResource = new AxiosMapResourceClient(baseURL, axiosInstance);
+        this._userResource = new AxiosUserResourceClient(baseURL, axiosInstance);
+        this._statusResource = new AxiosStatusResourceClient(baseURL, axiosInstance);
         this._assetDatapointResource = new AxiosAssetDatapointResourceClient(baseURL, axiosInstance);
-        this._appResource = new AxiosAppResourceClient(baseURL, axiosInstance);
-        this._assetPredictedDatapointResource = new AxiosAssetPredictedDatapointResourceClient(baseURL, axiosInstance);
+        this._alarmResource = new AxiosAlarmResourceClient(baseURL, axiosInstance);
         this._gatewayClientResource = new AxiosGatewayClientResourceClient(baseURL, axiosInstance);
-        this._flowResource = new AxiosFlowResourceClient(baseURL, axiosInstance);
+        this._consoleResource = new AxiosConsoleResourceClient(baseURL, axiosInstance);
+        this._agentResource = new AxiosAgentResourceClient(baseURL, axiosInstance);
         this._realmResource = new AxiosRealmResourceClient(baseURL, axiosInstance);
-        this._assetResource = new AxiosAssetResourceClient(baseURL, axiosInstance);
+        this._flowResource = new AxiosFlowResourceClient(baseURL, axiosInstance);
+        this._gatewayServiceResource = new AxiosGatewayServiceResourceClient(baseURL, axiosInstance);
         this._assetResource = new AxiosAssetResourceClient(baseURL, axiosInstance);
     }
-    get NotificationResource() {
-        return this._notificationResource;
-    }
-    get ConfigurationResource() {
-        return this._configurationResource;
-    }
-    get MapResource() {
-        return this._mapResource;
-    }
-    get AlarmResource() {
-        return this._alarmResource;
-    }
-    get SyslogResource() {
-        return this._syslogResource;
+    get ProvisioningResource() {
+        return this._provisioningResource;
     }
-    get GatewayServiceResource() {
-        return this._gatewayServiceResource;
+    get AssetPredictedDatapointResource() {
+        return this._assetPredictedDatapointResource;
     }
     get DashboardResource() {
         return this._dashboardResource;
     }
-    get ConsoleResource() {
-        return this._consoleResource;
+    get AssetResource() {
+        return this._assetResource;
     }
-    get StatusResource() {
-        return this._statusResource;
+    get ConfigurationResource() {
+        return this._configurationResource;
     }
-    get ProvisioningResource() {
-        return this._provisioningResource;
+    get AppResource() {
+        return this._appResource;
+    }
+    get NotificationResource() {
+        return this._notificationResource;
     }
     get AssetModelResource() {
         return this._assetModelResource;
     }
+    get RulesResource() {
+        return this._rulesResource;
+    }
+    get SyslogResource() {
+        return this._syslogResource;
+    }
+    get MapResource() {
+        return this._mapResource;
+    }
     get UserResource() {
         return this._userResource;
     }
-    get AgentResource() {
-        return this._agentResource;
-    }
-    get RulesResource() {
-        return this._rulesResource;
+    get StatusResource() {
+        return this._statusResource;
     }
     get AssetDatapointResource() {
         return this._assetDatapointResource;
     }
-    get AppResource() {
-        return this._appResource;
-    }
-    get AssetPredictedDatapointResource() {
-        return this._assetPredictedDatapointResource;
+    get AlarmResource() {
+        return this._alarmResource;
     }
     get GatewayClientResource() {
         return this._gatewayClientResource;
     }
-    get FlowResource() {
-        return this._flowResource;
+    get ConsoleResource() {
+        return this._consoleResource;
+    }
+    get AgentResource() {
+        return this._agentResource;
     }
     get RealmResource() {
         return this._realmResource;
     }
-    get AssetResource() {
-        return this._assetResource;
+    get FlowResource() {
+        return this._flowResource;
+    }
+    get GatewayServiceResource() {
+        return this._gatewayServiceResource;
     }
 }
 // Added by 'AxiosClientExtension' extension
@@ -1212,67 +1212,67 @@ class AxiosHttpClient {
         });
     }
 }
-export class AxiosNotificationResourceClient extends NotificationResourceClient {
+export class AxiosProvisioningResourceClient extends ProvisioningResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosConfigurationResourceClient extends ConfigurationResourceClient {
+export class AxiosAssetPredictedDatapointResourceClient extends AssetPredictedDatapointResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosMapResourceClient extends MapResourceClient {
+export class AxiosDashboardResourceClient extends DashboardResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAlarmResourceClient extends AlarmResourceClient {
+export class AxiosAssetResourceClient extends AssetResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosSyslogResourceClient extends SyslogResourceClient {
+export class AxiosConfigurationResourceClient extends ConfigurationResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosGatewayServiceResourceClient extends GatewayServiceResourceClient {
+export class AxiosAppResourceClient extends AppResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosDashboardResourceClient extends DashboardResourceClient {
+export class AxiosNotificationResourceClient extends NotificationResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosConsoleResourceClient extends ConsoleResourceClient {
+export class AxiosAssetModelResourceClient extends AssetModelResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosStatusResourceClient extends StatusResourceClient {
+export class AxiosRulesResourceClient extends RulesResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosProvisioningResourceClient extends ProvisioningResourceClient {
+export class AxiosSyslogResourceClient extends SyslogResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetModelResourceClient extends AssetModelResourceClient {
+export class AxiosMapResourceClient extends MapResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
@@ -1284,55 +1284,55 @@ export class AxiosUserResourceClient extends UserResourceClient {
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAgentResourceClient extends AgentResourceClient {
+export class AxiosStatusResourceClient extends StatusResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosRulesResourceClient extends RulesResourceClient {
+export class AxiosAssetDatapointResourceClient extends AssetDatapointResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetDatapointResourceClient extends AssetDatapointResourceClient {
+export class AxiosAlarmResourceClient extends AlarmResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAppResourceClient extends AppResourceClient {
+export class AxiosGatewayClientResourceClient extends GatewayClientResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetPredictedDatapointResourceClient extends AssetPredictedDatapointResourceClient {
+export class AxiosConsoleResourceClient extends ConsoleResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosGatewayClientResourceClient extends GatewayClientResourceClient {
+export class AxiosAgentResourceClient extends AgentResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosFlowResourceClient extends FlowResourceClient {
+export class AxiosRealmResourceClient extends RealmResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosRealmResourceClient extends RealmResourceClient {
+export class AxiosFlowResourceClient extends FlowResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));
     }
 }
-export class AxiosAssetResourceClient extends AssetResourceClient {
+export class AxiosGatewayServiceResourceClient extends GatewayServiceResourceClient {
     constructor(baseURL, axiosInstance = axios.create()) {
         axiosInstance.defaults.baseURL = baseURL;
         super(new AxiosHttpClient(axiosInstance));