@northern.tech/store 0.3.4 → 0.5.0

package/dist/deploymentsSlice/thunks.cjs

@@ -45,6 +45,15 @@ __export(thunks_exports, {
   updateDeploymentControlMap: () => updateDeploymentControlMap
 });
 module.exports = __toCommonJS(thunks_exports);
+var import_helpers10 = require("@northern.tech/utils/helpers");
+var import_tracking = __toESM(require("@northern.tech/utils/tracking"), 1);
+var import_validator = require("validator");
+
+// src/deploymentsSlice/index.ts
+var import_toolkit = require("@reduxjs/toolkit");
+
+// src/constants.ts
+var import_constants5 = require("@northern.tech/utils/constants");
 
 // src/appSlice/constants.ts
 var import_icons_material = require("@mui/icons-material");
@@ -52,16 +61,6 @@ var startingDeviceCount = {
   os: "for first 50 devices",
   professional: "for first 250 devices"
 };
-var apiRoot = "/api/management";
-var apiUrl = {
-  v1: `${apiRoot}/v1`,
-  v2: `${apiRoot}/v2`
-};
-var headerNames = {
-  link: "link",
-  location: "location",
-  total: "x-total-count"
-};
 var chartTypes = {
   bar: { key: "bar", Icon: import_icons_material.BarChart },
   pie: { key: "pie", Icon: import_icons_material.PieChartOutline }
@@ -73,28 +72,30 @@ var PLANS = {
   os: {
     id: "os",
     name: "Basic",
+    minimalDeviceCount: 50,
     offer: true,
-    price: "$32 / month",
+    price: "$34 / month",
     deviceCount: startingDeviceCount.os,
-    offerprice: "$23 / month for first 50 devices",
-    price2: "for first 6 months;\n$29/month thereafter",
+    description: "The core features of Mender. To continue using Enterprise Trial features\u2014like Delta updates, scheduled deployments, phased rollouts, device filtering, dynamic groups, RBAC, audit logs, and more\u2014please upgrade to a higher plan.",
     features: ["Access to core features of Mender", "Basic support"]
   },
   professional: {
     id: "professional",
     name: "Professional",
+    minimalDeviceCount: 250,
     offer: true,
-    price: "$269 / month",
+    price: "$291 / month",
     deviceCount: startingDeviceCount.professional,
-    offerprice: "$200 / month for first 50 devices",
-    price2: "for first 6 months;\n$249/month thereafter",
+    description: "Everything in Basic, plus enhanced update management and automation features.",
     features: ["Advanced OTA features", "Higher priority support"]
   },
   enterprise: {
     id: "enterprise",
     name: "Enterprise",
+    minimalDeviceCount: 1e3,
     price: "Custom pricing",
     deviceCount: "Unlimited devices",
+    description: "Every advanced feature of Mender, tailored for complex and large-scale deployments. Not available as a monthly subscription \u2014 ask us for a quote.",
     features: ["All Mender features", "Advanced security features", "SLA-backed support"]
   }
 };
@@ -114,21 +115,6 @@ var ADDONS = {
     },
     eligible: ["os", "professional", "enterprise"]
   },
-  troubleshoot: {
-    id: "troubleshoot",
-    title: "Troubleshoot",
-    description: "Expand your plan with device troubleshooting features",
-    needs: ["hasDeviceConnect"],
-    os: {
-      price: "$27/month",
-      deviceCount: startingDeviceCount.os
-    },
-    professional: {
-      price: "$72/month",
-      deviceCount: startingDeviceCount.professional
-    },
-    eligible: ["os", "professional", "enterprise"]
-  },
   monitor: {
     id: "monitor",
     title: "Monitor",
@@ -143,6 +129,21 @@ var ADDONS = {
       deviceCount: startingDeviceCount.professional
     },
     eligible: ["professional", "enterprise"]
+  },
+  troubleshoot: {
+    id: "troubleshoot",
+    title: "Troubleshoot",
+    description: "Expand your plan with device troubleshooting features",
+    needs: ["hasDeviceConnect"],
+    os: {
+      price: "$27/month",
+      deviceCount: startingDeviceCount.os
+    },
+    professional: {
+      price: "$72/month",
+      deviceCount: startingDeviceCount.professional
+    },
+    eligible: ["os", "professional", "enterprise"]
   }
 };
 var BENEFITS = {
@@ -180,144 +181,18 @@ var BENEFITS = {
   default: { id: "default", benefit: "gain access to this feature", requiredPlan: PLANS.enterprise.id }
 };
 var DARK_MODE = "dark";
-var APPLICATION_JSON_CONTENT_TYPE = "application/json";
-var APPLICATION_JWT_CONTENT_TYPE = "application/jwt";
 
 // src/commonConstants.tsx
 var import_js = require("@mdi/js");
+var import_MenderTypes = require("@northern.tech/types/MenderTypes");
 var import_jsx_runtime = require("react/jsx-runtime");
-var DEVICE_LIST_DEFAULTS = {
-  page: 1,
-  perPage: 20
-};
 var timeUnits = {
   days: "days",
   minutes: "minutes",
   hours: "hours"
 };
-var ALL_DEVICES = "All devices";
 var UNGROUPED_GROUP = { id: "*|=ungrouped=|*", name: "Unassigned" };
 var DEVICE_LIST_MAXIMUM_LENGTH = 50;
-var DEVICE_FILTERING_OPTIONS = {
-  $eq: { key: "$eq", title: "equals", shortform: "=" },
-  $ne: { key: "$ne", title: "not equal", shortform: "!=" },
-  $gt: {
-    key: "$gt",
-    title: ">",
-    shortform: ">",
-    help: 'The "greater than" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $gte: {
-    title: ">=",
-    shortform: ">=",
-    help: 'The "greater than or equal" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $lt: {
-    key: "$lt",
-    title: "<",
-    shortform: "<",
-    help: 'The "lesser than" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $lte: {
-    title: "<=",
-    shortform: "<=",
-    help: 'The "lesser than or equal" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $ltne: {
-    key: "$ltne",
-    title: "$ltne",
-    shortform: "ltne",
-    help: 'The "lesser than or does not exist" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $in: {
-    key: "$in",
-    title: "in",
-    shortform: "in",
-    help: 'The "in" operator accepts a list of comma-separated values. It matches if the selected field is equal to one of the specified values.'
-  },
-  $nin: {
-    key: "$nin",
-    title: "not in",
-    shortform: "not in",
-    help: `The "not in" operator accepts a list of comma-separated values. It matches if the selected field's value is not equal to any of the specified options.`
-  },
-  $exists: {
-    key: "$exists",
-    title: "exists",
-    shortform: "exists",
-    value: true,
-    help: `The "exists" operator matches if the selected field's value has a value. No value needs to be provided for this operator.`
-  },
-  $nexists: {
-    key: "$nexists",
-    title: `doesn't exist`,
-    shortform: `doesn't exist`,
-    value: true,
-    help: `The "doesn't exist" operator matches if the selected field's value has no value. No value needs to be provided for this operator.`
-  },
-  $regex: {
-    key: "$regex",
-    title: `matches regular expression`,
-    shortform: `matches`,
-    help: `The "regular expression" operator matches the selected field's value with a Perl compatible regular expression (PCRE), automatically anchored by ^. If the regular expression is not valid, the filter will produce no results. If you need to specify options and flags, you can provide the full regex in the format of /regex/flags, for example.`
-  }
-};
-var DEVICE_ISSUE_OPTIONS = {
-  issues: {
-    isCategory: true,
-    key: "issues",
-    title: "Devices with issues",
-    filterRule: {}
-  },
-  offline: {
-    issueCategory: "issues",
-    key: "offline",
-    needsFullFiltering: true,
-    needsMonitor: false,
-    needsReporting: false,
-    filterRule: {
-      scope: "system",
-      key: "check_in_time",
-      operator: DEVICE_FILTERING_OPTIONS.$ltne.key,
-      value: ({ offlineThreshold }) => offlineThreshold
-    },
-    title: "Offline devices"
-  },
-  failedLastUpdate: {
-    issueCategory: "issues",
-    key: "failedLastUpdate",
-    needsFullFiltering: false,
-    needsMonitor: false,
-    needsReporting: true,
-    filterRule: { scope: "monitor", key: "failed_last_update", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: true },
-    title: "Deployment failed"
-  },
-  monitoring: {
-    issueCategory: "issues",
-    key: "monitoring",
-    needsFullFiltering: false,
-    needsMonitor: true,
-    needsReporting: false,
-    filterRule: { scope: "monitor", key: "alerts", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: true },
-    title: "Monitoring alert"
-  },
-  authRequests: {
-    key: "authRequests",
-    needsFullFiltering: false,
-    needsMonitor: false,
-    needsReporting: true,
-    filterRule: { scope: "monitor", key: "auth_requests", operator: DEVICE_FILTERING_OPTIONS.$gt.key, value: 1 },
-    title: "Devices with new authentication requests"
-  },
-  gatewayDevices: {
-    key: "gatewayDevices",
-    needsFullFiltering: false,
-    needsMonitor: false,
-    needsReporting: true,
-    filterRule: { scope: "inventory", key: "mender_is_gateway", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: "true" },
-    title: "Gateway devices"
-  }
-};
 var oneSecond = 1e3;
 var TIMEOUTS = {
   debounceDefault: 700,
@@ -330,23 +205,12 @@ var TIMEOUTS = {
   refreshDefault: 10 * oneSecond,
   refreshLong: 60 * oneSecond
 };
-var SORTING_OPTIONS = {
-  asc: "asc",
-  desc: "desc"
-};
 var DEVICE_ONLINE_CUTOFF = { interval: 1, intervalName: timeUnits.days };
-var ATTRIBUTE_SCOPES = {
-  inventory: "inventory",
-  identity: "identity",
-  monitor: "monitor",
-  system: "system",
-  tags: "tags"
-};
-var defaultIdAttribute = Object.freeze({ attribute: "id", scope: ATTRIBUTE_SCOPES.identity });
+var defaultIdAttribute = Object.freeze({ attribute: "id", scope: import_constants5.ATTRIBUTE_SCOPES.identity });
 var credentialTypes = {
-  aws: "aws",
-  http: "http",
-  sas: "sas",
+  aws: import_MenderTypes.Credentials.type.AWS,
+  http: import_MenderTypes.Credentials.type.HTTP,
+  sas: import_MenderTypes.Credentials.type.SAS,
   x509: "x509"
 };
 var EXTERNAL_PROVIDER = {
@@ -386,32 +250,278 @@ var EXTERNAL_PROVIDER = {
   webhook: {
     credentialsType: credentialTypes.http,
     deviceTwin: false,
+    twinTitle: "",
     // disable the webhook provider here, since it is treated different than other integrations, with a custom configuration & management view, etc.
     enabled: false,
     provider: "webhook"
   }
 };
-var MAX_PAGE_SIZE = 500;
-var ALL_RELEASES = "All releases";
-var emptyUiPermissions = Object.freeze({
-  auditlog: [],
-  deployments: [],
-  groups: Object.freeze({}),
-  releases: Object.freeze({}),
-  tenantManagement: [],
-  userManagement: []
-});
-var emptyRole = Object.freeze({
-  name: void 0,
+var emptyWebhook = {
   description: "",
-  permissions: [],
-  uiPermissions: Object.freeze({ ...emptyUiPermissions })
-});
+  provider: import_MenderTypes.Integration.provider.WEBHOOK,
+  credentials: {
+    type: EXTERNAL_PROVIDER.webhook.credentialsType,
+    [EXTERNAL_PROVIDER.webhook.credentialsType]: {
+      secret: "",
+      url: ""
+    }
+  }
+};
+var MAX_PAGE_SIZE = 500;
+var regionNames = new Intl.DisplayNames(["en"], { type: "region" });
+var countries = [
+  "AD",
+  "AE",
+  "AF",
+  "AG",
+  "AI",
+  "AL",
+  "AM",
+  "AO",
+  "AQ",
+  "AR",
+  "AS",
+  "AT",
+  "AU",
+  "AW",
+  "AX",
+  "AZ",
+  "BA",
+  "BB",
+  "BD",
+  "BE",
+  "BF",
+  "BG",
+  "BH",
+  "BI",
+  "BJ",
+  "BL",
+  "BM",
+  "BN",
+  "BO",
+  "BR",
+  "BS",
+  "BT",
+  "BV",
+  "BW",
+  "BY",
+  "BZ",
+  "CA",
+  "CC",
+  "CD",
+  "CF",
+  "CG",
+  "CH",
+  "CI",
+  "CK",
+  "CL",
+  "CM",
+  "CN",
+  "CO",
+  "CR",
+  "CU",
+  "CV",
+  "CW",
+  "CX",
+  "CY",
+  "CZ",
+  "DE",
+  "DJ",
+  "DK",
+  "DM",
+  "DO",
+  "DZ",
+  "EC",
+  "EE",
+  "EG",
+  "EH",
+  "ER",
+  "ES",
+  "ET",
+  "FI",
+  "FJ",
+  "FK",
+  "FM",
+  "FO",
+  "FR",
+  "GA",
+  "GB",
+  "GD",
+  "GE",
+  "GF",
+  "GG",
+  "GH",
+  "GI",
+  "GL",
+  "GM",
+  "GN",
+  "GP",
+  "GQ",
+  "GR",
+  "GS",
+  "GT",
+  "GU",
+  "GW",
+  "GY",
+  "HK",
+  "HM",
+  "HN",
+  "HR",
+  "HT",
+  "HU",
+  "ID",
+  "IE",
+  "IL",
+  "IM",
+  "IN",
+  "IO",
+  "IQ",
+  "IR",
+  "IS",
+  "IT",
+  "JE",
+  "JM",
+  "JO",
+  "JP",
+  "KE",
+  "KG",
+  "KH",
+  "KI",
+  "KM",
+  "KN",
+  "KP",
+  "KR",
+  "KW",
+  "KY",
+  "KZ",
+  "LA",
+  "LB",
+  "LC",
+  "LI",
+  "LK",
+  "LR",
+  "LS",
+  "LT",
+  "LU",
+  "LV",
+  "LY",
+  "MA",
+  "MC",
+  "MD",
+  "ME",
+  "MF",
+  "MG",
+  "MH",
+  "MK",
+  "ML",
+  "MM",
+  "MN",
+  "MO",
+  "MP",
+  "MQ",
+  "MR",
+  "MS",
+  "MT",
+  "MU",
+  "MV",
+  "MW",
+  "MX",
+  "MY",
+  "MZ",
+  "NA",
+  "NC",
+  "NE",
+  "NF",
+  "NG",
+  "NI",
+  "NL",
+  "NO",
+  "NP",
+  "NR",
+  "NU",
+  "NZ",
+  "OM",
+  "PA",
+  "PE",
+  "PF",
+  "PG",
+  "PH",
+  "PK",
+  "PL",
+  "PM",
+  "PN",
+  "PR",
+  "PS",
+  "PT",
+  "PW",
+  "PY",
+  "QA",
+  "RE",
+  "RO",
+  "RS",
+  "RU",
+  "RW",
+  "SA",
+  "SB",
+  "SC",
+  "SD",
+  "SE",
+  "SG",
+  "SH",
+  "SI",
+  "SJ",
+  "SK",
+  "SL",
+  "SM",
+  "SN",
+  "SO",
+  "SR",
+  "SS",
+  "ST",
+  "SV",
+  "SX",
+  "SY",
+  "SZ",
+  "TC",
+  "TD",
+  "TF",
+  "TG",
+  "TH",
+  "TJ",
+  "TK",
+  "TL",
+  "TM",
+  "TN",
+  "TO",
+  "TR",
+  "TT",
+  "TV",
+  "TW",
+  "TZ",
+  "UA",
+  "UG",
+  "US",
+  "UY",
+  "UZ",
+  "VA",
+  "VC",
+  "VE",
+  "VG",
+  "VI",
+  "VN",
+  "VU",
+  "WF",
+  "WS",
+  "XK",
+  "YE",
+  "YT",
+  "ZA",
+  "ZM",
+  "ZW"
+].map((code) => ({ code, label: regionNames.of(code) })).sort((a, b) => a.label.localeCompare(b.label));
 
 // src/deploymentsSlice/constants.ts
 var alreadyInstalled = "already-installed";
-var deploymentsApiUrl = `${apiUrl.v1}/deployments`;
-var deploymentsApiUrlV2 = `${apiUrl.v2}/deployments`;
 var deploymentSubstates = {
   aborted: "aborted",
   alreadyInstalled,
@@ -484,9 +594,9 @@ var DEPLOYMENT_STATES = {
 var listDefaultsByState = {
   [DEPLOYMENT_STATES.inprogress]: { page: 1, perPage: 10 },
   [DEPLOYMENT_STATES.pending]: { page: 1, perPage: 10 },
-  [DEPLOYMENT_STATES.scheduled]: { ...DEVICE_LIST_DEFAULTS },
-  [DEPLOYMENT_STATES.finished]: { ...DEVICE_LIST_DEFAULTS },
-  sort: { direction: SORTING_OPTIONS.desc }
+  [DEPLOYMENT_STATES.scheduled]: { ...import_constants5.DEVICE_LIST_DEFAULTS },
+  [DEPLOYMENT_STATES.finished]: { ...import_constants5.DEVICE_LIST_DEFAULTS },
+  sort: { direction: import_constants5.SORTING_OPTIONS.desc }
 };
 var DEFAULT_PENDING_INPROGRESS_COUNT = 10;
 var DEPLOYMENT_ROUTES = {
@@ -547,30 +657,10 @@ var pauseMap = {
     followUp: installationSubstatesMap.reboot.pauseConfigurationIndicator
   }
 };
-var limitDefault = { min: 5, max: 100, default: 10 };
 
 // src/devicesSlice/constants.ts
-var emptyFilter = { key: null, value: "", operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "inventory" };
-var deviceAuthV2 = `${apiUrl.v2}/devauth`;
-var deviceConnect = `${apiUrl.v1}/deviceconnect`;
-var inventoryApiUrl = `${apiUrl.v1}/inventory`;
-var inventoryApiUrlV2 = `${apiUrl.v2}/inventory`;
-var deviceConfig = `${apiUrl.v1}/deviceconfig/configurations/device`;
-var reportingApiUrl = `${apiUrl.v1}/reporting`;
-var iotManagerBaseURL = `${apiUrl.v1}/iot-manager`;
-var ALL_DEVICE_STATES = "any";
-var DEVICE_STATES = {
-  accepted: "accepted",
-  pending: "pending",
-  preauth: "preauthorized",
-  rejected: "rejected"
-};
+var emptyFilter = { key: null, value: "", operator: import_constants5.DEVICE_FILTERING_OPTIONS.$eq.key, scope: "inventory" };
 var geoAttributes = ["geo-lat", "geo-lon"].map((attribute) => ({ attribute, scope: "inventory" }));
-var REPORT_CHART_SIZE_LIMIT = 6;
-
-// src/monitorSlice/constants.ts
-var alertChannels = { email: "email" };
-var monitorApiUrlv1 = `${apiUrl.v1}/devicemonitor`;
 
 // src/onboardingSlice/constants.ts
 var onboardingSteps = {
@@ -588,6 +678,7 @@ var onboardingSteps = {
   SCHEDULING_GROUP_SELECTION: "scheduling-group-selection",
   SCHEDULING_RELEASE_TO_DEVICES: "scheduling-release-to-devices",
   DEPLOYMENTS_INPROGRESS: "deployments-inprogress",
+  DEPLOYMENTS_COMPLETED: "deployments-completed",
   DEPLOYMENTS_PAST: "deployments-past",
   DEPLOYMENTS_PAST_COMPLETED: "deployments-past-completed",
   DEPLOYMENTS_PAST_COMPLETED_FAILURE: "deployments-past-completed-failure",
@@ -614,14 +705,10 @@ var orderedOnboardingSteps = [
 ];
 
 // src/organizationSlice/constants.ts
-var auditLogsApiUrl = `${apiUrl.v1}/auditlogs`;
-var tenantadmApiUrlv1 = `${apiUrl.v1}/tenantadm`;
-var tenantadmApiUrlv2 = `${apiUrl.v2}/tenantadm`;
-var ssoIdpApiUrlv1 = `${apiUrl.v1}/useradm/sso/idp/metadata`;
 var XML_METADATA_FORMAT = "xml";
 var JSON_METADATA_FORMAT = "json";
-var getSamlStartUrl = (id) => `${window.location.origin}${useradmApiUrlv1}/auth/sso/${id}/login`;
-var getOidcStartUrl = (id) => `${window.location.origin}${useradmApiUrlv1}/oidc/${id}/start`;
+var getSamlStartUrl = (id) => `${window.location.origin}${import_constants5.useradmApiUrl}/auth/sso/${id}/login`;
+var getOidcStartUrl = (id) => `${window.location.origin}${import_constants5.useradmApiUrl}/oidc/${id}/start`;
 var SSO_TYPES = {
   saml: {
     id: "saml",
@@ -632,8 +719,8 @@ var SSO_TYPES = {
     contentType: "application/samlmetadata+xml",
     getStartUrl: getSamlStartUrl,
     configDetails: [
-      { key: "entityID", label: "Entity ID", getValue: (id) => `${window.location.origin}${useradmApiUrlv1}/sso/sp/metadata/${id}` },
-      { key: "acs", label: "ACS URL", getValue: (id) => `${window.location.origin}${useradmApiUrlv1}/auth/sso/${id}/acs` },
+      { key: "entityID", label: "Entity ID", getValue: (id) => `${window.location.origin}${import_constants5.useradmApiUrl}/sso/sp/metadata/${id}` },
+      { key: "acs", label: "ACS URL", getValue: (id) => `${window.location.origin}${import_constants5.useradmApiUrl}/auth/sso/${id}/acs` },
       { key: "startURL", label: "Start URL", getValue: getSamlStartUrl }
     ]
   },
@@ -658,557 +745,29 @@ var auditlogTypes = {
 };
 var AUDIT_LOGS_TYPES = [auditlogTypes.artifact, auditlogTypes.deployment, auditlogTypes.device, auditlogTypes.user_access_token, auditlogTypes.user];
 var SP_AUDIT_LOGS_TYPES = [auditlogTypes.user, auditlogTypes.tenant];
-var emptyWebhook = {
-  description: "",
-  enabled: true,
-  credentials: {
-    type: EXTERNAL_PROVIDER.webhook.credentialsType,
-    [EXTERNAL_PROVIDER.webhook.credentialsType]: {
-      secret: "",
-      url: ""
-    }
-  }
-};
 var TENANT_LIST_DEFAULT = {
   page: 1,
   perPage: 20
 };
 
-// src/releasesSlice/constants.ts
-var rootfsImageVersion = "rootfs-image.version";
-var softwareTitleMap = { [rootfsImageVersion]: { title: "Root filesystem", priority: 0, key: rootfsImageVersion } };
-
-// src/usersSlice/constants.ts
-var useradmApiUrlv1 = `${apiUrl.v1}/useradm`;
-var useradmApiUrlv2 = `${apiUrl.v2}/useradm`;
-var staticRolesByName = {
-  admin: "RBAC_ROLE_PERMIT_ALL",
-  readOnly: "RBAC_ROLE_OBSERVER",
-  ci: "RBAC_ROLE_CI",
-  deploymentsManager: "RBAC_ROLE_DEPLOYMENTS_MANAGER",
-  terminalAccess: "RBAC_ROLE_REMOTE_TERMINAL"
-};
-var PermissionTypes = {
-  Any: "any",
-  Get: "GET",
-  Post: "POST",
-  Put: "PUT",
-  Delete: "DELETE",
-  Patch: "PATCH",
-  DeviceGroup: "DEVICE_GROUP",
-  DeviceId: "DEVICE_ID"
-};
-var permissionSetIds = {
-  Basic: "Basic",
-  ConfigureDevices: "ConfigureDevices",
-  ConnectToDevices: "ConnectToDevices",
-  DeployToDevices: "DeployToDevices",
-  ManageDevices: "ManageDevices",
-  ManageReleases: "ManageReleases",
-  ManageTenants: "ManageTenants",
-  ManageUsers: "ManageUsers",
-  ReadAuditLogs: "ReadAuditLogs",
-  ReadDevices: "ReadDevices",
-  ReadReleases: "ReadReleases",
-  ReadTenants: "ReadTenants",
-  ReadUsers: "ReadUsers",
-  SuperUser: "SuperUser",
-  UploadArtifacts: "UploadArtifacts"
-};
-var uiPermissionsById = {
-  configure: {
-    explanations: { groups: `'Configure' allows the user to use mender-configure features and apply configurations.` },
-    permissionLevel: 2,
-    permissionSets: { groups: permissionSetIds.ConfigureDevices },
-    title: "Configure",
-    value: "configure",
-    verbs: [PermissionTypes.Get, PermissionTypes.Put, PermissionTypes.Post]
-  },
-  connect: {
-    explanations: { groups: `'Connect' allows the user to use mender-connect features and Troubleshoot add-ons.` },
-    permissionLevel: 2,
-    permissionSets: { groups: permissionSetIds.ConnectToDevices },
-    title: "Connect",
-    value: "connect",
-    verbs: [PermissionTypes.Get, PermissionTypes.Put]
-  },
-  deploy: {
-    explanations: { groups: `'Deploy' allows the user to deploy software or configuration updates to devices.` },
-    permissionLevel: 2,
-    permissionSets: { deployments: permissionSetIds.DeployToDevices, groups: permissionSetIds.DeployToDevices },
-    title: "Deploy",
-    value: "deploy",
-    verbs: [PermissionTypes.Post]
-  },
-  manage: {
-    explanations: {
-      groups: `'Manage' allows the user to edit device name, notes, and manage authentication status. For 'All devices' it also allows the user to edit and create device groups.`,
-      releases: `'Manage' allows the user to upload new artifacts, edit release descriptions and remove artifacts.`
-    },
-    permissionLevel: 2,
-    permissionSets: {
-      groups: permissionSetIds.ManageDevices,
-      releases: permissionSetIds.ManageReleases,
-      tenantManagement: permissionSetIds.ManageTenants,
-      userManagement: permissionSetIds.ManageUsers
-    },
-    title: "Manage",
-    value: "manage",
-    verbs: [PermissionTypes.Post, PermissionTypes.Put, PermissionTypes.Patch]
-  },
-  read: {
-    explanations: { groups: `'Read' allows the user to view devices.` },
-    permissionLevel: 1,
-    permissionSets: {
-      auditlog: permissionSetIds.ReadAuditLogs,
-      groups: permissionSetIds.ReadDevices,
-      releases: permissionSetIds.ReadReleases,
-      tenantManagement: permissionSetIds.ReadTenants,
-      userManagement: permissionSetIds.ReadUsers
-    },
-    title: "Read",
-    value: "read",
-    verbs: [PermissionTypes.Get, PermissionTypes.Post]
-  },
-  upload: {
-    explanations: { groups: `'Upload' allows the user to upload new Artifacts.` },
-    unscopedOnly: { releases: true },
-    permissionLevel: 1,
-    permissionSets: { releases: permissionSetIds.UploadArtifacts },
-    title: "Upload",
-    value: "upload",
-    verbs: [PermissionTypes.Post, PermissionTypes.Put, PermissionTypes.Patch]
-  }
-};
-var scopedPermissionAreas = {
-  groups: { key: "groups", excessiveAccessSelector: ALL_DEVICES, scopeType: "DeviceGroups" },
-  releases: { key: "releases", excessiveAccessSelector: ALL_RELEASES, scopeType: "Releases" }
-};
-var uiPermissionsByArea = {
-  auditlog: {
-    endpoints: [{ path: /\/(auditlog)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] }],
-    explanation: "Granting access to the audit log will allow tracing changes to devices, releases and user accounts, as well as providing information about deployments.",
-    key: "auditlog",
-    uiPermissions: [uiPermissionsById.read],
-    title: "System Audit Log"
-  },
-  deployments: {
-    endpoints: [
-      { path: /\/(deployments\/deployments)/i, types: [PermissionTypes.Post, PermissionTypes.Put], uiPermissions: [uiPermissionsById.deploy] },
-      { path: /\/(deployments\/deployments)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      { path: /\/(deployments\/config)/i, types: [PermissionTypes.Get, PermissionTypes.Put], uiPermissions: [uiPermissionsById.manage] }
-    ],
-    explanation: "Providing deploy permissions will allow deployments to be created using the releases and devices a user has access to.",
-    key: "deployments",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.deploy],
-    title: "Deployments"
-  },
-  groups: {
-    endpoints: [
-      {
-        path: /\/(devauth|inventory|deviceconfig|devicemonitor|deviceconnect\/devices)/i,
-        types: [PermissionTypes.Get],
-        uiPermissions: [uiPermissionsById.read]
-      },
-      { path: /\/(devauth|inventory)/i, types: [PermissionTypes.Put, PermissionTypes.Post], uiPermissions: [uiPermissionsById.manage] },
-      { path: /\/(deviceconfig)/i, types: [PermissionTypes.Get, PermissionTypes.Put, PermissionTypes.Post], uiPermissions: [uiPermissionsById.configure] },
-      { path: /\/(deviceconnect\/devices)/i, types: [PermissionTypes.Get, PermissionTypes.Post], uiPermissions: [uiPermissionsById.connect] }
-    ],
-    explanation: "Device group management permissions control the degree to which devices in a group can be accessed and moved to other groups.",
-    key: "groups",
-    scope: scopedPermissionAreas.groups.scopeType,
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage, uiPermissionsById.deploy, uiPermissionsById.configure, uiPermissionsById.connect],
-    title: "Group Management"
-  },
-  releases: {
-    endpoints: [
-      { path: /\/(deployments\/artifacts|deployments\/deployments\/releases)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      {
-        path: /\/(deployments\/artifacts|deployments\/deployments\/releases)/i,
-        types: [PermissionTypes.Post, PermissionTypes.Put],
-        uiPermissions: [uiPermissionsById.read, uiPermissionsById.upload]
-      },
-      {
-        path: /\/(deployments\/artifacts|deployments\/deployments\/releases)/i,
-        types: [PermissionTypes.Delete],
-        uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage]
-      }
-    ],
-    explanation: "Release permissions can be granted to allow artifact & release modifications, as well as the creation of new releases.",
-    key: "releases",
-    scope: "ReleaseTags",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage, uiPermissionsById.upload],
-    title: "Release Management"
-  },
-  tenantManagement: {
-    endpoints: [
-      { path: /\/(tenantadm\/tenants)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      { path: /\/(tenantadm\/tenants)/i, types: [PermissionTypes.Post, PermissionTypes.Put], uiPermissions: [uiPermissionsById.manage] },
-      { path: /\/(users\/exists)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.manage] }
-    ],
-    explanation: "Tenant management permissions allow listing, creating and modifying child tenants",
-    key: "tenantManagement",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage],
-    title: "Tenant Management"
-  },
-  userManagement: {
-    endpoints: [
-      { path: /\/(useradm)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      { path: /\/(useradm)/i, types: [PermissionTypes.Post], uiPermissions: [uiPermissionsById.manage] }
-    ],
-    explanation: "User management permissions should be granted carefully, as these allow privilege increases for any users managed by a user with user management permissions",
-    key: "userManagement",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage],
-    title: "User Management"
-  }
-};
-var permissionMapper = (permission) => permission.value;
-var itemUiPermissionsReducer = (accu, { item, uiPermissions }) => item ? { ...accu, [item]: uiPermissions } : accu;
-var rolesById = Object.freeze({
-  [staticRolesByName.admin]: {
-    name: "Admin",
-    value: staticRolesByName.admin,
-    description: "Full access",
-    permissions: [],
-    // permissions refers to the values returned from the backend
-    uiPermissions: {
-      ...emptyUiPermissions,
-      auditlog: uiPermissionsByArea.auditlog.uiPermissions.map(permissionMapper),
-      deployments: uiPermissionsByArea.deployments.uiPermissions.map(permissionMapper),
-      groups: { [ALL_DEVICES]: uiPermissionsByArea.groups.uiPermissions.map(permissionMapper) },
-      releases: { [ALL_RELEASES]: uiPermissionsByArea.releases.uiPermissions.map(permissionMapper) },
-      userManagement: uiPermissionsByArea.userManagement.uiPermissions.map(permissionMapper)
-    }
-  },
-  [staticRolesByName.readOnly]: {
-    name: "Read Access",
-    value: staticRolesByName.readOnly,
-    description: "",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      deployments: [uiPermissionsById.read.value],
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value] },
-      releases: { [ALL_RELEASES]: [uiPermissionsById.read.value] },
-      userManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [staticRolesByName.ci]: {
-    name: "Releases Manager",
-    value: staticRolesByName.ci,
-    description: "",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      releases: { [ALL_RELEASES]: uiPermissionsByArea.releases.uiPermissions.map(permissionMapper) }
-    }
-  },
-  [staticRolesByName.deploymentsManager]: {
-    name: "Deployments Manager",
-    value: staticRolesByName.deploymentsManager,
-    description: "",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      deployments: uiPermissionsByArea.deployments.uiPermissions.map(permissionMapper),
-      groups: { [ALL_DEVICES]: [uiPermissionsById.deploy.value, uiPermissionsById.read.value] },
-      releases: { [ALL_RELEASES]: [uiPermissionsById.read.value] }
-    }
-  },
-  [staticRolesByName.terminalAccess]: {
-    name: "Troubleshooting",
-    value: staticRolesByName.terminalAccess,
-    description: "Access to the troubleshooting features: Remote Terminal, File Transfer, Port Forwarding",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      groups: { [ALL_DEVICES]: [uiPermissionsById.connect.value] }
-    }
-  }
-});
-var serviceProviderRolesById = {
-  admin: {
-    name: "Admin",
-    value: staticRolesByName.admin,
-    description: "Full access",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      auditlog: uiPermissionsByArea.auditlog.uiPermissions.map(permissionMapper),
-      userManagement: uiPermissionsByArea.userManagement.uiPermissions.map(permissionMapper),
-      tenantManagement: uiPermissionsByArea.tenantManagement.uiPermissions.map(permissionMapper)
-    }
-  },
-  readOnly: {
-    name: "Read access",
-    value: staticRolesByName.readOnly,
-    description: "This role can see all linked organizations but cannot make any changes",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      auditlog: [uiPermissionsById.read.value],
-      userManagement: [uiPermissionsById.read.value],
-      tenantManagement: [uiPermissionsById.read.value]
-    }
-  }
-};
-var defaultPermissionSets = {
-  [permissionSetIds.Basic]: {
-    name: permissionSetIds.Basic,
-    result: {
-      // this is needed to prevent the detailed permissions of the basic permission set from being interpreted as allowing read & management access to user endpoints
-      userManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.SuperUser]: {
-    name: permissionSetIds.SuperUser,
-    result: {
-      ...rolesById[staticRolesByName.admin].uiPermissions
-    }
-  },
-  [permissionSetIds.ManageUsers]: {
-    name: permissionSetIds.ManageUsers,
-    result: {
-      userManagement: [uiPermissionsById.manage.value]
-    }
-  },
-  [permissionSetIds.ReadAuditLogs]: {
-    name: permissionSetIds.ReadAuditLogs,
-    result: {
-      auditlog: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.ReadReleases]: {
-    name: permissionSetIds.ReadReleases,
-    result: {
-      releases: { [ALL_RELEASES]: [uiPermissionsById.read.value] }
-    }
-  },
-  [permissionSetIds.ReadTenants]: {
-    name: permissionSetIds.ReadTenants,
-    result: {
-      tenantManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.ManageTenants]: {
-    name: permissionSetIds.ManageTenants,
-    result: {
-      tenantManagement: [uiPermissionsById.manage.value]
-    }
-  },
-  [permissionSetIds.ReadUsers]: {
-    name: permissionSetIds.ReadUsers,
-    result: {
-      userManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.UploadArtifacts]: {
-    name: permissionSetIds.UploadArtifacts,
-    result: {
-      releases: { [ALL_RELEASES]: [uiPermissionsById.upload.value] }
-    }
-  },
-  [permissionSetIds.ManageReleases]: {
-    name: permissionSetIds.ManageReleases,
-    result: {
-      releases: { [ALL_RELEASES]: [uiPermissionsById.manage.value] }
-    }
-  },
-  [permissionSetIds.ConfigureDevices]: {
-    name: permissionSetIds.ConfigureDevices,
-    result: {
-      deployments: [uiPermissionsById.read.value, uiPermissionsById.deploy.value],
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.configure.value] }
-    }
-  },
-  [permissionSetIds.ConnectToDevices]: {
-    name: permissionSetIds.ConnectToDevices,
-    result: {
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.connect.value] }
-    }
-  },
-  [permissionSetIds.DeployToDevices]: {
-    name: permissionSetIds.DeployToDevices,
-    result: {
-      deployments: [uiPermissionsById.deploy.value, uiPermissionsById.manage.value, uiPermissionsById.read.value],
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.deploy.value] }
-    }
-  },
-  [permissionSetIds.ManageDevices]: {
-    name: permissionSetIds.ManageDevices,
-    result: {
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.manage.value] }
-    }
-  },
-  [permissionSetIds.ReadDevices]: {
-    name: permissionSetIds.ReadDevices,
-    result: {
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value] }
-    }
-  }
-};
-var USER_LOGOUT = "USER_LOGOUT";
-var OWN_USER_ID = "me";
-var rolesByName = {
-  ...staticRolesByName,
-  deploymentCreation: { action: "CREATE_DEPLOYMENT", object: { type: "DEVICE_GROUP", value: void 0 } },
-  groupAccess: { action: "VIEW_DEVICE", object: { type: "DEVICE_GROUP", value: void 0 } },
-  userManagement: { action: "http", object: { type: "any", value: `${useradmApiUrlv1}/.*` } }
-};
-var twoFAStates = {
-  enabled: "enabled",
-  disabled: "disabled",
-  unverified: "unverified"
-};
-var settingsKeys = { initialized: "settings-initialized" };
-var READ_STATES = {
-  read: "read",
-  seen: "seen",
-  unread: "unread"
-};
-
-// src/appSlice/index.ts
-var import_toolkit = require("@reduxjs/toolkit");
-var sliceName = "app";
-var getYesterday = () => {
-  const today = /* @__PURE__ */ new Date();
-  today.setDate(today.getDate() - 1);
-  return today.toISOString();
-};
-var initialState = {
-  cancelSource: void 0,
-  demoArtifactLink: "https://dgsbl4vditpls.cloudfront.net/mender-demo-artifact.mender",
-  hostAddress: null,
-  snackbar: {
-    open: false,
-    message: "",
-    maxWidth: 900,
-    autoHideDuration: void 0,
-    action: void 0,
-    children: void 0,
-    onClick: void 0,
-    onClose: void 0
-  },
-  // return boolean rather than organization details
-  features: {
-    hasAuditlogs: false,
-    hasDeltaProgress: false,
-    hasMultitenancy: false,
-    hasDeviceConfig: false,
-    hasDeviceConnect: false,
-    hasFeedbackEnabled: false,
-    hasMonitor: false,
-    hasReporting: false,
-    isDemoMode: false,
-    isHosted: false,
-    isEnterprise: false
-  },
-  feedbackProbability: 0.3,
-  firstLoginAfterSignup: false,
-  hostedAnnouncement: "",
-  docsVersion: "",
-  recaptchaSiteKey: "",
-  searchState: {
-    deviceIds: [],
-    searchTerm: "",
-    searchTotal: 0,
-    sort: {
-      direction: SORTING_OPTIONS.desc
-      // key: null,
-      // scope: null
-    }
-  },
-  stripeAPIKey: "",
-  trackerCode: "",
-  uploadsById: {
-    // id: { uploading: false, uploadProgress: 0, cancelSource: undefined }
-  },
-  newThreshold: getYesterday(),
-  offlineThreshold: getYesterday(),
-  versionInformation: {
-    Integration: "",
-    "Mender-Client": "",
-    "Mender-Artifact": "",
-    "Meta-Mender": "",
-    Deployments: "",
-    Deviceauth: "",
-    Inventory: "",
-    GUI: "latest"
-  },
-  yesterday: void 0
-};
-var appSlice = (0, import_toolkit.createSlice)({
-  name: sliceName,
-  initialState,
-  reducers: {
-    setFeatures: (state, action) => {
-      state.features = {
-        ...state.features,
-        ...action.payload
-      };
-    },
-    setSnackbar: (state, { payload }) => {
-      let { message, autoHideDuration, action, children, onClick, onClose } = payload;
-      if (typeof payload === "string" || payload instanceof String) {
-        message = payload;
-      }
-      state.snackbar = {
-        open: message ? true : false,
-        message,
-        maxWidth: 900,
-        autoHideDuration,
-        action,
-        children,
-        onClick,
-        onClose
-      };
-    },
-    setFirstLoginAfterSignup: (state, action) => {
-      state.firstLoginAfterSignup = action.payload;
-    },
-    setAnnouncement: (state, action) => {
-      state.hostedAnnouncement = action.payload;
-    },
-    setSearchState: (state, action) => {
-      state.searchState = {
-        ...state.searchState,
-        ...action.payload
-      };
-    },
-    setOfflineThreshold: (state, action) => {
-      state.offlineThreshold = action.payload;
-    },
-    initUpload: (state, action) => {
-      const { id, upload } = action.payload;
-      state.uploadsById[id] = upload;
-    },
-    uploadProgress: (state, action) => {
-      const { id, progress: progress2 } = action.payload;
-      state.uploadsById[id] = {
-        ...state.uploadsById[id],
-        progress: progress2
-      };
-    },
-    cleanUpUpload: (state, action) => {
-      const { [action.payload]: current, ...remainder } = state.uploadsById;
-      state.uploadsById = remainder;
-    },
-    setVersionInformation: (state, action) => {
-      state.versionInformation = {
-        ...state.versionInformation,
-        ...action.payload
-      };
-    },
-    setEnvironmentData: (state, action) => ({ ...state, ...action.payload })
-  }
-});
-var actions = appSlice.actions;
-var appSlice_default = appSlice.reducer;
+// src/releasesSlice/constants.ts
+var rootfsImageVersion = "rootfs-image.version";
+var softwareTitleMap = { [rootfsImageVersion]: { title: "Root filesystem", priority: 0, key: rootfsImageVersion } };
+
+// src/usersSlice/constants.ts
+var itemUiPermissionsReducer = (accu, { item, uiPermissions }) => item ? { ...accu, [item]: uiPermissions } : accu;
+var USER_LOGOUT = "USER_LOGOUT";
+var OWN_USER_ID = "me";
+var settingsKeys = { initialized: "settings-initialized" };
+var READ_STATES = {
+  read: "read",
+  seen: "seen",
+  unread: "unread"
+};
 
 // src/deploymentsSlice/index.ts
-var import_toolkit2 = require("@reduxjs/toolkit");
-var sliceName2 = "deployments";
-var initialState2 = {
+var sliceName = "deployments";
+var initialState = {
   byId: {
     // [id]: { statistics: { status: {}, total_size }, devices: { [deploymentId]: { id, log } }, totalDeviceCount }
   },
@@ -1230,20 +789,20 @@ var initialState2 = {
       sourceWindow: -1
     },
     binaryDeltaLimits: {
-      timeout: { ...limitDefault, default: 60, max: 3600, min: 60 },
-      sourceWindow: limitDefault,
-      inputWindow: limitDefault,
-      duplicatesWindow: limitDefault,
-      instructionBuffer: limitDefault
+      timeout: { ...import_constants5.limitDefault, default: 60, max: 3600, min: 60 },
+      sourceWindow: import_constants5.limitDefault,
+      inputWindow: import_constants5.limitDefault,
+      duplicatesWindow: import_constants5.limitDefault,
+      instructionBuffer: import_constants5.limitDefault
     }
   },
   deploymentDeviceLimit: 5e3,
   selectedDeviceIds: [],
   selectionState: {
-    finished: { ...DEVICE_LIST_DEFAULTS, endDate: void 0, search: "", selection: [], startDate: void 0, total: 0, type: "" },
-    inprogress: { ...DEVICE_LIST_DEFAULTS, perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] },
-    pending: { ...DEVICE_LIST_DEFAULTS, perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] },
-    scheduled: { ...DEVICE_LIST_DEFAULTS, selection: [] },
+    finished: { ...import_constants5.DEVICE_LIST_DEFAULTS, endDate: void 0, search: "", selection: [], startDate: void 0, total: 0, type: "" },
+    inprogress: { ...import_constants5.DEVICE_LIST_DEFAULTS, perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] },
+    pending: { ...import_constants5.DEVICE_LIST_DEFAULTS, perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] },
+    scheduled: { ...import_constants5.DEVICE_LIST_DEFAULTS, selection: [] },
     general: {
       state: DEPLOYMENT_ROUTES.active.key,
       showCreationDialog: false,
@@ -1254,9 +813,9 @@ var initialState2 = {
     selectedId: void 0
   }
 };
-var deploymentsSlice = (0, import_toolkit2.createSlice)({
-  name: sliceName2,
-  initialState: initialState2,
+var deploymentsSlice = (0, import_toolkit.createSlice)({
+  name: sliceName,
+  initialState,
   reducers: {
     createdDeployment: (state, action) => {
       state.byId[action.payload.id] = {
@@ -1265,7 +824,8 @@ var deploymentsSlice = (0, import_toolkit2.createSlice)({
       };
       state.byStatus[DEPLOYMENT_STATES.pending].total = state.byStatus[DEPLOYMENT_STATES.pending].total + 1;
       state.byStatus[DEPLOYMENT_STATES.pending].deploymentIds = [...state.byStatus.pending.deploymentIds, action.payload.id];
-      state.selectionState[DEPLOYMENT_STATES.pending].selection = [action.payload.id, ...state.selectionState[DEPLOYMENT_STATES.pending].selection], state.selectionState[DEPLOYMENT_STATES.pending].total = state.selectionState[DEPLOYMENT_STATES.pending].total + 1;
+      state.selectionState[DEPLOYMENT_STATES.pending].selection = [action.payload.id, ...state.selectionState[DEPLOYMENT_STATES.pending].selection];
+      state.selectionState[DEPLOYMENT_STATES.pending].total = (state.selectionState[DEPLOYMENT_STATES.pending].total || 0) + 1;
     },
     removedDeployment: (state, action) => {
       const { [action.payload]: removedDeployment, ...remainder } = state.byId;
@@ -1327,9 +887,145 @@ var deploymentsSlice = (0, import_toolkit2.createSlice)({
     }
   }
 });
-var actions2 = deploymentsSlice.actions;
+var actions = deploymentsSlice.actions;
 var deploymentsSlice_default = deploymentsSlice.reducer;
 
+// src/appSlice/index.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+var sliceName2 = "app";
+var getYesterday = () => {
+  const today = /* @__PURE__ */ new Date();
+  today.setDate(today.getDate() - 1);
+  return today.toISOString();
+};
+var initialState2 = {
+  cancelSource: void 0,
+  commit: "",
+  demoArtifactLink: "https://dgsbl4vditpls.cloudfront.net/mender-demo-artifact.mender",
+  hostAddress: null,
+  snackbar: {
+    action: void 0,
+    autoHideDuration: void 0,
+    message: "",
+    open: false,
+    preventClickToCopy: false
+  },
+  // return boolean rather than organization details
+  features: {
+    hasAuditlogs: false,
+    hasDeltaProgress: false,
+    hasMultitenancy: false,
+    hasDeviceConfig: false,
+    hasDeviceConnect: false,
+    hasFeedbackEnabled: false,
+    hasMonitor: false,
+    hasReporting: false,
+    isDemoMode: false,
+    isHosted: true,
+    isEnterprise: false
+  },
+  feedbackProbability: 0.3,
+  firstLoginAfterSignup: false,
+  hostedAnnouncement: "",
+  docsVersion: "",
+  recaptchaSiteKey: "",
+  searchState: {
+    deviceIds: [],
+    searchTerm: "",
+    searchTotal: 0,
+    isSearching: false,
+    sort: {
+      direction: import_constants5.SORTING_OPTIONS.desc
+      // key: null,
+      // scope: null
+    }
+  },
+  sentry: {
+    location: "",
+    replaysSessionSampleRate: 0.1,
+    tracesSampleRate: 1
+  },
+  stripeAPIKey: "",
+  trackerCode: "",
+  uploadsById: {
+    // id: { progress: 0, cancelSource: undefined }
+  },
+  newThreshold: getYesterday(),
+  offlineThreshold: getYesterday(),
+  versionInformation: {
+    Integration: "",
+    "Mender-Client": "",
+    "Mender-Artifact": "",
+    "Meta-Mender": ""
+  },
+  yesterday: void 0
+};
+var appSlice = (0, import_toolkit2.createSlice)({
+  name: sliceName2,
+  initialState: initialState2,
+  reducers: {
+    setFeatures: (state, action) => {
+      state.features = {
+        ...state.features,
+        ...action.payload
+      };
+    },
+    setSnackbar: (state, { payload }) => {
+      if (typeof payload === "string") {
+        state.snackbar.message = payload;
+        return;
+      }
+      const { message, autoHideDuration, action, preventClickToCopy = false } = payload;
+      state.snackbar = {
+        message,
+        autoHideDuration,
+        action,
+        preventClickToCopy,
+        open: !!message
+      };
+    },
+    setFirstLoginAfterSignup: (state, action) => {
+      state.firstLoginAfterSignup = action.payload;
+    },
+    setAnnouncement: (state, action) => {
+      state.hostedAnnouncement = action.payload;
+    },
+    setSearchState: (state, action) => {
+      state.searchState = {
+        ...state.searchState,
+        ...action.payload
+      };
+    },
+    setOfflineThreshold: (state, action) => {
+      state.offlineThreshold = action.payload;
+    },
+    initUpload: (state, action) => {
+      const { id, upload } = action.payload;
+      state.uploadsById[id] = upload;
+    },
+    uploadProgress: (state, action) => {
+      const { id, progress: progress2 } = action.payload;
+      state.uploadsById[id] = {
+        ...state.uploadsById[id],
+        progress: progress2
+      };
+    },
+    cleanUpUpload: (state, action) => {
+      const { [action.payload]: current, ...remainder } = state.uploadsById;
+      state.uploadsById = remainder;
+    },
+    setVersionInformation: (state, action) => {
+      state.versionInformation = {
+        ...state.versionInformation,
+        ...action.payload
+      };
+    },
+    setEnvironmentData: (state, action) => ({ ...state, ...action.payload })
+  }
+});
+var actions2 = appSlice.actions;
+var appSlice_default = appSlice.reducer;
+
 // src/devicesSlice/index.ts
 var import_helpers = require("@northern.tech/utils/helpers");
 var import_toolkit3 = require("@reduxjs/toolkit");
@@ -1342,26 +1038,30 @@ var initialState3 = {
     // }
   },
   byStatus: {
-    [DEVICE_STATES.accepted]: { deviceIds: [], total: 0 },
+    [import_constants5.DEVICE_STATES.accepted]: { deviceIds: [], total: 0 },
     active: { deviceIds: [], total: 0 },
     inactive: { deviceIds: [], total: 0 },
-    [DEVICE_STATES.pending]: { deviceIds: [], total: 0 },
-    [DEVICE_STATES.preauth]: { deviceIds: [], total: 0 },
-    [DEVICE_STATES.rejected]: { deviceIds: [], total: 0 }
+    [import_constants5.DEVICE_STATES.pending]: { deviceIds: [], total: 0 },
+    [import_constants5.DEVICE_STATES.preauth]: { deviceIds: [], total: 0 },
+    [import_constants5.DEVICE_STATES.rejected]: { deviceIds: [], total: 0 }
   },
   deviceList: {
     deviceIds: [],
-    ...DEVICE_LIST_DEFAULTS,
+    ...import_constants5.DEVICE_LIST_DEFAULTS,
     selectedAttributes: [],
     selectedIssues: [],
     selection: [],
     sort: {
-      direction: SORTING_OPTIONS.desc
+      direction: import_constants5.SORTING_OPTIONS.desc
       // key: null,
       // scope: null
     },
-    state: DEVICE_STATES.accepted,
-    total: 0
+    state: import_constants5.DEVICE_STATES.accepted,
+    total: 0,
+    refreshTrigger: false,
+    isLoading: false,
+    detailsTab: "",
+    open: false
   },
   filters: [
     // { key: 'device_type', value: 'raspberry', operator: '$eq', scope: 'inventory' }
@@ -1433,7 +1133,7 @@ var devicesSlice = (0, import_toolkit3.createSlice)({
       };
     },
     selectGroup: (state, { payload: group }) => {
-      state.deviceList.deviceIds = state.groups.byId[group] && state.groups.byId[group].deviceIds.length > 0 ? state.groups.byId[group].deviceIds : [];
+      state.deviceList.deviceIds = group && state.groups.byId[group] && state.groups.byId[group].deviceIds && state.groups.byId[group].deviceIds.length > 0 ? state.groups.byId[group].deviceIds : [];
       state.groups.selectedGroup = group;
     },
     removeGroup: (state, action) => {
@@ -1485,9 +1185,6 @@ var devicesSlice = (0, import_toolkit3.createSlice)({
       const { count, status } = action.payload;
       state.byStatus[status].total = count;
     },
-    setTotalDevices: (state, action) => {
-      state.total = action.payload;
-    },
     setDeviceLimit: (state, action) => {
       state.limit = action.payload;
     },
@@ -1500,8 +1197,8 @@ var devicesSlice = (0, import_toolkit3.createSlice)({
     maybeUpdateDevicesByStatus: (state, action) => {
       const { deviceId, authId } = action.payload;
       const device = state.byId[deviceId];
-      const hasMultipleAuthSets = authId ? device.auth_sets.filter((authset) => authset.id !== authId).length > 0 : false;
-      if (!hasMultipleAuthSets && Object.values(DEVICE_STATES).includes(device.status)) {
+      const hasMultipleAuthSets = authId && device.auth_sets ? device.auth_sets.filter((authset) => authset.id !== authId).length > 0 : false;
+      if (!hasMultipleAuthSets && Object.values(import_constants5.DEVICE_STATES).includes(device.status)) {
         const deviceIds = state.byStatus[device.status].deviceIds.filter((id) => id !== deviceId);
         state.byStatus[device.status] = { deviceIds, total: Math.max(0, state.byStatus[device.status].total - 1) };
       }
@@ -1516,16 +1213,16 @@ var import_toolkit4 = require("@reduxjs/toolkit");
 var sliceName4 = "monitor";
 var initialState4 = {
   alerts: {
-    alertList: { ...DEVICE_LIST_DEFAULTS, total: 0 },
+    alertList: { ...import_constants5.DEVICE_LIST_DEFAULTS, total: 0 },
     byDeviceId: {}
   },
   issueCounts: {
-    byType: Object.values(DEVICE_ISSUE_OPTIONS).reduce((accu, { key }) => ({ ...accu, [key]: { filtered: 0, total: 0 } }), {})
+    byType: Object.keys(import_constants5.DEVICE_ISSUE_OPTIONS).reduce((accu, key) => ({ ...accu, [key]: { filtered: 0, total: 0 } }), {})
   },
   settings: {
     global: {
       channels: {
-        ...Object.keys(alertChannels).reduce((accu, item) => ({ ...accu, [item]: { enabled: true } }), {})
+        ...Object.keys(import_constants5.alertChannels).reduce((accu, item) => ({ ...accu, [item]: { enabled: true } }), {})
       }
     }
   }
@@ -1617,7 +1314,7 @@ var initialState6 = {
     tenants: [],
     selectedTenant: null,
     sort: {
-      direction: SORTING_OPTIONS.desc,
+      direction: import_constants5.SORTING_OPTIONS.desc,
       key: "name"
     }
   },
@@ -1627,15 +1324,16 @@ var initialState6 = {
   auditlog: {
     events: [],
     selectionState: {
-      ...DEVICE_LIST_DEFAULTS,
+      ...import_constants5.DEVICE_LIST_DEFAULTS,
       detail: void 0,
       endDate: void 0,
       selectedIssue: void 0,
-      sort: { direction: SORTING_OPTIONS.desc },
+      sort: { direction: import_constants5.SORTING_OPTIONS.desc },
       startDate: void 0,
       total: 0,
       type: void 0,
-      user: void 0
+      user: void 0,
+      isLoading: false
     }
   },
   externalDeviceIntegrations: [
@@ -1673,6 +1371,12 @@ var organizationSlice = (0, import_toolkit6.createSlice)({
     setOrganization: (state, action) => {
       state.organization = { ...state.organization, ...action.payload };
     },
+    setSubscription: (state, action) => {
+      state.organization.subscription = { ...state.organization.subscription, ...action.payload };
+    },
+    setBillingProfile: (state, action) => {
+      state.organization.billing_profile = action.payload;
+    },
     setTenantListState: (state, action) => {
       state.tenantList = action.payload;
     },
@@ -1735,12 +1439,12 @@ var initialState7 = {
     */
   },
   releasesList: {
-    ...DEVICE_LIST_DEFAULTS,
+    ...import_constants5.DEVICE_LIST_DEFAULTS,
     searchedIds: [],
     releaseIds: [],
     selection: [],
     sort: {
-      direction: SORTING_OPTIONS.desc,
+      direction: import_constants5.SORTING_OPTIONS.desc,
       key: "modified"
     },
     isLoading: void 0,
@@ -1809,11 +1513,12 @@ var initialState8 = {
     retries: 0
   },
   permissionSetsById: {
-    ...defaultPermissionSets
+    ...import_constants5.defaultPermissionSets
   },
   rolesById: {
-    ...rolesById
+    ...import_constants5.rolesById
   },
+  rolesInitialized: false,
   settingsInitialized: false,
   showConnectDeviceDialog: false,
   showFeedbackDialog: false,
@@ -1849,9 +1554,6 @@ var usersSlice = (0, import_toolkit8.createSlice)({
       state.byId[action.payload.id] = action.payload;
       state.currentUser = action.payload.id;
     },
-    createdUser: (state, action) => {
-      state.byId[0] = action.payload;
-    },
     removedUser: (state, action) => {
       const { [action.payload]: removedUser, ...byId } = state.byId;
       state.byId = byId;
@@ -1868,6 +1570,10 @@ var usersSlice = (0, import_toolkit8.createSlice)({
     },
     receivedRoles: (state, action) => {
       state.rolesById = action.payload;
+      state.rolesInitialized = true;
+    },
+    finishedRoleInitialization: (state, action) => {
+      state.rolesInitialized = action.payload;
     },
     createdRole: (state, action) => {
       state.rolesById[action.payload.name] = {
@@ -1898,7 +1604,7 @@ var usersSlice = (0, import_toolkit8.createSlice)({
     },
     setTooltipState: (state, action) => {
       const { id, readState = READ_STATES.read } = action.payload;
-      state.tooltips.byId[id].readState = readState;
+      state.tooltips.byId[id] = { ...state.tooltips.byId[id], readState };
     },
     setTooltipsState: (state, action) => {
       state.tooltips.byId = {
@@ -1922,8 +1628,8 @@ var usersSlice_default = usersSlice.reducer;
 
 // src/actions.ts
 var actions_default = {
-  ...actions,
   ...actions2,
+  ...actions,
   ...actions3,
   ...actions4,
   ...actions5,
@@ -1938,7 +1644,7 @@ var import_axios = __toESM(require("axios"), 1);
 // src/auth.ts
 var import_universal_cookie = __toESM(require("universal-cookie"), 1);
 var cookies = new import_universal_cookie.default();
-var emptySession = Object.freeze({ token: "", exiresAt: void 0 });
+var emptySession = Object.freeze({ token: "", expiresAt: void 0 });
 var tokenCache = "";
 var getSessionInfo = () => {
   let sessionInfo = { ...emptySession };
@@ -1951,15 +1657,15 @@ var getSessionInfo = () => {
     return { ...emptySession };
   }
   if (!sessionInfo.token) {
-    let jwtTokenFromCookie = cookies.get("JWT", { doNotParse: true }) ?? "";
+    const jwtTokenFromCookie = cookies.get("JWT", { doNotParse: true }) ?? "";
     if (jwtTokenFromCookie) {
-      setSessionInfo({ token: jwtTokenFromCookie, undefined: void 0 });
+      setSessionInfo({ token: jwtTokenFromCookie });
       sessionInfo.token = jwtTokenFromCookie;
       cookies.remove("JWT");
       cookies.remove("JWT", { path: "/" });
     }
   }
-  sessionInfo.token = sessionInfo.token || void 0;
+  sessionInfo.token = sessionInfo.token || "";
   tokenCache = sessionInfo.token;
   return sessionInfo;
 };
@@ -1975,7 +1681,6 @@ var cleanUp = () => {
   window.localStorage.removeItem("JWT");
   window.localStorage.removeItem("oauth");
 };
-var maxSessionAge = 900;
 
 // src/api/general-api.ts
 var unauthorizedRedirect = (error) => {
@@ -2017,20 +1722,17 @@ var general_api_default = Api;
 // src/appSlice/selectors.ts
 var import_helpers2 = require("@northern.tech/utils/helpers");
 var import_toolkit9 = require("@reduxjs/toolkit");
-var getAppDocsVersion = (state) => state.app.docsVersion;
 var getFeatures = (state) => state.app.features;
 var getFullVersionInformation = (state) => state.app.versionInformation;
-var getDocsVersion = (0, import_toolkit9.createSelector)([getAppDocsVersion, getFeatures], (appDocsVersion, { isHosted }) => {
-  const docsVersion = appDocsVersion ? `${appDocsVersion}/` : "development/";
-  return isHosted ? "" : docsVersion;
-});
 var getSearchState = (state) => state.app.searchState;
+var getUploads = (state) => state.app.uploadsById;
+var getIsUploading = (0, import_toolkit9.createSelector)([getUploads], (uploadsById) => !!Object.keys(uploadsById).length);
 var getSearchedDevices = (0, import_toolkit9.createSelector)([getSearchState], ({ deviceIds }) => deviceIds);
 var getVersionInformation = (0, import_toolkit9.createSelector)(
   [getFullVersionInformation, getFeatures],
-  ({ Integration, ...remainder }, { isHosted }) => isHosted && Integration !== "next" ? remainder : { ...remainder, Integration }
+  ({ Integration: Integration2, ...remainder }, { isHosted }) => isHosted && Integration2 !== "next" ? remainder : { ...remainder, Integration: Integration2 }
 );
-var getIsPreview = (0, import_toolkit9.createSelector)([getFullVersionInformation], ({ Integration }) => (0, import_helpers2.versionCompare)(Integration, "next") > -1);
+var getIsPreview = (0, import_toolkit9.createSelector)([getFullVersionInformation], ({ Integration: Integration2 }) => (0, import_helpers2.versionCompare)(Integration2, "next") > -1);
 
 // src/commonSelectors.ts
 var import_helpers5 = require("@northern.tech/utils/helpers");
@@ -2082,6 +1784,7 @@ var import_toolkit11 = require("@reduxjs/toolkit");
 var getAcceptedDevices = (state) => state.devices.byStatus.accepted;
 var getDevicesByStatus = (state) => state.devices.byStatus;
 var getDevicesById = (state) => state.devices.byId;
+var getDeviceReports = (state) => state.devices.reports;
 var getGroupsById = (state) => state.devices.groups.byId;
 var getSelectedGroup = (state) => state.devices.groups.selectedGroup;
 var getDeviceListState = (state) => state.devices.deviceList;
@@ -2113,7 +1816,7 @@ var getDeviceIdentityAttributes = (0, import_toolkit11.createSelector)(
 );
 var getDeviceCountsByStatus = (0, import_toolkit11.createSelector)(
   [getDevicesByStatus],
-  (byStatus) => Object.values(DEVICE_STATES).reduce((accu, state) => {
+  (byStatus) => Object.values(import_constants5.DEVICE_STATES).reduce((accu, state) => {
     accu[state] = byStatus[state].total || 0;
     return accu;
   }, {})
@@ -2125,7 +1828,7 @@ var getSelectedGroupInfo = (0, import_toolkit11.createSelector)(
     let groupCount = acceptedDeviceTotal;
     let groupFilters = [];
     if (selectedGroup && groupsById[selectedGroup]) {
-      groupCount = groupsById[selectedGroup].total;
+      groupCount = groupsById[selectedGroup].total || 0;
       groupFilters = groupsById[selectedGroup].filters || [];
     }
     return { groupCount, selectedGroup, groupFilters };
@@ -2136,13 +1839,18 @@ var getLimitMaxed = (0, import_toolkit11.createSelector)(
   ({ total: acceptedDevices = 0 }, deviceLimit) => Boolean(deviceLimit && deviceLimit <= acceptedDevices)
 );
 var getGroupsByIdWithoutUngrouped = (0, import_toolkit11.createSelector)([getGroupsById], ({ [UNGROUPED_GROUP.id]: ungrouped, ...groups }) => groups);
+var getGroupData = (0, import_toolkit11.createSelector)([getGroupsByIdWithoutUngrouped], (groups) => {
+  const createdGroup = Object.keys(groups).length ? Object.keys(groups)[0] : void 0;
+  const hasDynamicGroups = Object.values(groups).some((group) => !!group.id);
+  return { createdGroup, hasDynamicGroups, groups };
+});
 var getGroups = (0, import_toolkit11.createSelector)([getGroupsById], (groupsById) => {
   const groupNames = Object.keys(groupsById).sort();
   const groupedGroups = Object.entries(groupsById).sort((a, b) => a[0].localeCompare(b[0])).reduce(
     (accu, [groupname, group]) => {
       const name = groupname === UNGROUPED_GROUP.id ? UNGROUPED_GROUP.name : groupname;
       const groupItem = { ...group, groupId: name, name: groupname };
-      if (group.filters?.length > 0) {
+      if ((group.filters ?? []).length > 0) {
         if (groupname !== UNGROUPED_GROUP.id) {
           accu.dynamic.push(groupItem);
         } else {
@@ -2185,12 +1893,14 @@ var getOnboarding = (state) => state.onboarding;
 
 // src/organizationSlice/selectors.ts
 var import_toolkit12 = require("@reduxjs/toolkit");
+var import_dayjs = __toESM(require("dayjs"), 1);
+var import_relativeTime = __toESM(require("dayjs/plugin/relativeTime.js"), 1);
 var getOrganization = (state) => state.organization.organization;
 var getExternalIntegrations = (state) => state.organization.externalDeviceIntegrations;
 var getAuditLog = (state) => state.organization.auditlog.events;
 var getAuditLogSelectionState = (state) => state.organization.auditlog.selectionState;
 var getWebhookEvents = (state) => state.organization.webhooks.events;
-var getWebhookEventTotal = (state) => state.organization.webhooks.eventTotal;
+var getWebhookEventTotal = (state) => state.organization.webhooks.eventsTotal;
 var getDeviceTwinIntegrations = (0, import_toolkit12.createSelector)(
   [getExternalIntegrations],
   (integrations) => integrations.filter((integration) => integration.id && EXTERNAL_PROVIDER[integration.provider]?.deviceTwin)
@@ -2211,22 +1921,31 @@ var getAuditLogEntry = (0, import_toolkit12.createSelector)([getAuditLog, getAud
   const [eventAction, eventTime] = atob(selectedId).split("|");
   return events.find((item) => item.action === eventAction && item.time === eventTime);
 });
+import_dayjs.default.extend(import_relativeTime.default);
+var newPricingIntroduction = (0, import_dayjs.default)("2025-06-03T00:00");
+var getHasCurrentPricing = (0, import_toolkit12.createSelector)(
+  [getOrganization],
+  ({ id }) => !!id && (0, import_dayjs.default)(parseInt(id.substring(0, 8), 16) * 1e3) >= newPricingIntroduction
+);
+
+// src/releasesSlice/selectors.ts
+var import_toolkit13 = require("@reduxjs/toolkit");
 
 // src/utils.ts
 var import_helpers4 = require("@northern.tech/utils/helpers");
 var filterProcessors = {
-  [DEVICE_FILTERING_OPTIONS.$gt.key]: (val) => Number(val) || val,
-  [DEVICE_FILTERING_OPTIONS.$gte.key]: (val) => Number(val) || val,
-  [DEVICE_FILTERING_OPTIONS.$lt.key]: (val) => Number(val) || val,
-  [DEVICE_FILTERING_OPTIONS.$lte.key]: (val) => Number(val) || val,
-  [DEVICE_FILTERING_OPTIONS.$ltne.key]: (val) => Number(val) || val,
-  [DEVICE_FILTERING_OPTIONS.$in.key]: (val) => ("" + val).split(",").map((i) => i.trim()),
-  [DEVICE_FILTERING_OPTIONS.$nin.key]: (val) => ("" + val).split(",").map((i) => i.trim()),
-  [DEVICE_FILTERING_OPTIONS.$exists.key]: import_helpers4.yes,
-  [DEVICE_FILTERING_OPTIONS.$nexists.key]: () => false
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$gt.key]: (val) => Number(val) || val,
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$gte.key]: (val) => Number(val) || val,
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$lt.key]: (val) => Number(val) || val,
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$lte.key]: (val) => Number(val) || val,
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$ltne.key]: (val) => Number(val) || val,
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$in.key]: (val) => ("" + val).split(",").map((i) => i.trim()),
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$nin.key]: (val) => ("" + val).split(",").map((i) => i.trim()),
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$exists.key]: import_helpers4.yes,
+  [import_constants5.DEVICE_FILTERING_OPTIONS.$nexists.key]: () => false
 };
 var filterAliases = {
-  $nexists: { alias: DEVICE_FILTERING_OPTIONS.$exists.key, value: false }
+  $nexists: { alias: import_constants5.DEVICE_FILTERING_OPTIONS.$exists.key, value: false }
 };
 var mapFiltersToTerms = (filters) => filters.map((filter) => ({
   scope: filter.scope,
@@ -2242,38 +1961,45 @@ var mapTermsToFilters = (terms) => terms.map((term) => {
   return { scope: term.scope, key: term.attribute, operator, value: term.value };
 });
 var convertIssueOptionsToFilters = (issuesSelection, filtersState = {}) => issuesSelection.map((item) => {
-  if (typeof DEVICE_ISSUE_OPTIONS[item].filterRule.value === "function") {
-    return { ...DEVICE_ISSUE_OPTIONS[item].filterRule, value: DEVICE_ISSUE_OPTIONS[item].filterRule.value(filtersState) };
+  if (typeof import_constants5.DEVICE_ISSUE_OPTIONS[item].filterRule.value === "function") {
+    return { ...import_constants5.DEVICE_ISSUE_OPTIONS[item].filterRule, value: import_constants5.DEVICE_ISSUE_OPTIONS[item].filterRule.value(filtersState) };
   }
-  return DEVICE_ISSUE_OPTIONS[item].filterRule;
+  return import_constants5.DEVICE_ISSUE_OPTIONS[item].filterRule;
 });
-var convertDeviceListStateToFilters = ({ filters = [], group, groups = { byId: {} }, offlineThreshold, selectedIssues = [], status }) => {
+var convertDeviceListStateToFilters = ({
+  filters = [],
+  group,
+  groups = { byId: {} },
+  offlineThreshold,
+  selectedIssues = [],
+  status
+}) => {
   let applicableFilters = [...filters];
   if (typeof group === "string" && !(groups.byId[group]?.filters || applicableFilters).length) {
-    applicableFilters.push({ key: "group", value: group, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "system" });
+    applicableFilters.push({ key: "group", value: group, operator: import_constants5.DEVICE_FILTERING_OPTIONS.$eq.key, scope: "system" });
   }
   const nonMonitorFilters = applicableFilters.filter(
-    (filter) => !Object.values(DEVICE_ISSUE_OPTIONS).some(
+    (filter) => !Object.values(import_constants5.DEVICE_ISSUE_OPTIONS).some(
       ({ filterRule }) => filter.scope !== "inventory" && filterRule.scope === filter.scope && filterRule.key === filter.key
     )
   );
   const deviceIssueFilters = convertIssueOptionsToFilters(selectedIssues, { offlineThreshold });
   applicableFilters = [...nonMonitorFilters, ...deviceIssueFilters];
-  const effectiveFilters = status ? [...applicableFilters, { key: "status", value: status, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }] : applicableFilters;
+  const effectiveFilters = status ? [...applicableFilters, { key: "status", value: status, operator: import_constants5.DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }] : applicableFilters;
   return { applicableFilters: nonMonitorFilters, filterTerms: mapFiltersToTerms(effectiveFilters) };
 };
-var filterCompare = (filter, item) => Object.keys(emptyFilter).every((key) => item[key].toString() === filter[key].toString());
+var filterCompare = (filter, item) => Object.keys(emptyFilter).every((key) => item[key]?.toString() === filter[key]?.toString());
 var filtersFilter = (item, index, array) => {
   const firstIndex = array.findIndex((filter) => filterCompare(filter, item));
   return firstIndex === index;
 };
-var listItemMapper = (byId, ids, { defaultObject = {}, cutOffSize = DEVICE_LIST_MAXIMUM_LENGTH }) => ids.slice(0, cutOffSize).reduce((accu, id) => {
+var listItemMapper = (byId, ids, { cutOffSize = DEVICE_LIST_MAXIMUM_LENGTH, defaultObject = {} }) => ids.slice(0, cutOffSize).reduce((accu, id) => {
   if (id && byId[id]) {
     accu.push({ ...defaultObject, ...byId[id] });
   }
   return accu;
 }, []);
-var mergePermissions = (existingPermissions = { ...emptyUiPermissions }, addedPermissions) => Object.entries(existingPermissions).reduce(
+var mergePermissions = (existingPermissions = { ...import_constants5.emptyUiPermissions }, addedPermissions) => Object.entries(existingPermissions).reduce(
   (accu, [key, value]) => {
     let values;
     if (!accu[key]) {
@@ -2297,23 +2023,24 @@ var mapUserRolesToUiPermissions = (userRoles, roles) => userRoles.reduce(
     }
     return mergePermissions(accu, roles[roleId].uiPermissions);
   },
-  { ...emptyUiPermissions }
+  { ...import_constants5.emptyUiPermissions }
 );
 var progress = ({ loaded, total }) => {
   let uploadProgress3 = loaded / total * 100;
   return uploadProgress3 = uploadProgress3 < 50 ? Math.ceil(uploadProgress3) : Math.round(uploadProgress3);
 };
+var extractErrorMessage = (err, fallback = "") => err.response?.data?.error?.message || err.response?.data?.error || err.error || err.message || fallback;
 var getComparisonCompatibleVersion = (version) => isNaN(version.charAt(0)) && version !== "next" ? "master" : version;
 var mapDeviceAttributes = (attributes = []) => attributes.reduce(
   (accu, attribute) => {
-    if (!(attribute.value && attribute.name) && attribute.scope === ATTRIBUTE_SCOPES.inventory) {
+    if (!(attribute.value && attribute.name) && attribute.scope === import_constants5.ATTRIBUTE_SCOPES.inventory) {
       return accu;
     }
-    accu[attribute.scope || ATTRIBUTE_SCOPES.inventory] = {
-      ...accu[attribute.scope || ATTRIBUTE_SCOPES.inventory],
+    accu[attribute.scope || import_constants5.ATTRIBUTE_SCOPES.inventory] = {
+      ...accu[attribute.scope || import_constants5.ATTRIBUTE_SCOPES.inventory],
       [attribute.name]: attribute.value
     };
-    if (attribute.name === "device_type" && attribute.scope === ATTRIBUTE_SCOPES.inventory) {
+    if (attribute.name === "device_type" && attribute.scope === import_constants5.ATTRIBUTE_SCOPES.inventory) {
       accu.inventory.device_type = [].concat(attribute.value);
     }
     return accu;
@@ -2323,39 +2050,44 @@ var mapDeviceAttributes = (attributes = []) => attributes.reduce(
 var isDarkMode = (mode) => mode === DARK_MODE;
 
 // src/releasesSlice/selectors.ts
-var import_toolkit13 = require("@reduxjs/toolkit");
 var getSelectedReleaseId = (state) => state.releases.selectedRelease;
 var getReleasesById = (state) => state.releases.byId;
 var getReleaseTags = (state) => state.releases.tags;
 var getReleaseListState = (state) => state.releases.releasesList;
 var getListedReleases = (state) => state.releases.releasesList.releaseIds;
-var getReleaseMappingDefaults = () => ({});
+var releaseDefaults = {};
+var getReleaseMappingDefaults = () => releaseDefaults;
 var getReleasesList = (0, import_toolkit13.createSelector)([getReleasesById, getListedReleases, getReleaseMappingDefaults], listItemMapper);
 var getReleaseTagsById = (0, import_toolkit13.createSelector)([getReleaseTags], (releaseTags) => releaseTags.reduce((accu, key) => ({ ...accu, [key]: key }), {}));
 var getHasReleases = (0, import_toolkit13.createSelector)(
   [getReleaseListState, getReleasesById],
   ({ searchTotal, total }, byId) => !!(Object.keys(byId).length || total || searchTotal)
 );
-var getSelectedRelease = (0, import_toolkit13.createSelector)([getReleasesById, getSelectedReleaseId], (byId, id) => byId[id] ?? {});
+var getSelectedRelease = (0, import_toolkit13.createSelector)([getReleasesById, getSelectedReleaseId], (byId, id) => byId[id || ""] ?? {});
+var getSelectedReleases = (0, import_toolkit13.createSelector)([getReleaseListState, getReleasesList], ({ selection }, releases) => selection.map((index) => releases[index]));
 
 // src/usersSlice/selectors.ts
 var import_toolkit14 = require("@reduxjs/toolkit");
+var emptyObject = {};
 var getRolesById = (state) => state.users.rolesById;
 var getTooltipsById = (state) => state.users.tooltips.byId;
 var getGlobalSettings = (state) => state.users.globalSettings;
 var getCurrentUserId = (state) => state.users.currentUser;
 var getUsersById = (state) => state.users.byId;
 var getUsersList = (0, import_toolkit14.createSelector)([getUsersById], (usersById) => Object.values(usersById));
-var getCurrentUser = (0, import_toolkit14.createSelector)([getUsersById, getCurrentUserId], (usersById, userId) => usersById[userId] ?? {});
+var getCurrentUser = (0, import_toolkit14.createSelector)(
+  [getUsersById, getCurrentUserId],
+  (usersById, userId) => userId ? usersById[userId] ?? emptyObject : emptyObject
+);
 var getUserSettings = (state) => state.users.userSettings;
 var getSelectedDeviceAttribute = (0, import_toolkit14.createSelector)(
   [getUserSettings],
   ({ columnSelection }) => columnSelection.map((attribute) => ({ attribute: attribute.key, scope: attribute.scope }))
 );
 var getIsDarkMode = (0, import_toolkit14.createSelector)([getUserSettings], ({ mode }) => isDarkMode(mode));
-var getShowHelptips = (0, import_toolkit14.createSelector)(
+var getReadAllHelptips = (0, import_toolkit14.createSelector)(
   [getTooltipsById],
-  (tooltips) => Object.values(tooltips).reduce((accu, { readState }) => accu || readState === READ_STATES.unread, false)
+  (tooltips) => Object.values(tooltips).every(({ readState }) => readState === READ_STATES.read)
 );
 var getTooltipsState = (0, import_toolkit14.createSelector)(
   [getTooltipsById, getUserSettings],
@@ -2369,7 +2101,7 @@ var getTooltipsState = (0, import_toolkit14.createSelector)(
 );
 var getHas2FA = (0, import_toolkit14.createSelector)(
   [getCurrentUser],
-  (currentUser) => currentUser.hasOwnProperty("tfa_status") && currentUser.tfa_status === twoFAStates.enabled
+  (currentUser) => currentUser.hasOwnProperty("tfa_status") && currentUser.tfa_status === import_constants5.twoFAStates.enabled
 );
 var getIdAttribute = (0, import_toolkit14.createSelector)([getGlobalSettings], ({ id_attribute = { ...defaultIdAttribute } }) => id_attribute);
 var getOfflineThresholdSettings = (0, import_toolkit14.createSelector)([getGlobalSettings], ({ offlineThreshold }) => ({
@@ -2385,37 +2117,34 @@ var getIsEnterprise = (0, import_toolkit15.createSelector)(
 );
 var getAttrsEndpoint = (0, import_toolkit15.createSelector)(
   [getFeatures],
-  ({ hasReporting }) => hasReporting ? `${reportingApiUrl}/devices/search/attributes` : `${inventoryApiUrlV2}/filters/attributes`
+  ({ hasReporting }) => hasReporting ? `${import_constants5.reportingApiUrl}/devices/search/attributes` : `${import_constants5.inventoryApiUrlV2}/filters/attributes`
 );
 var getSearchEndpoint = (0, import_toolkit15.createSelector)(
   [getFeatures],
-  ({ hasReporting }) => hasReporting ? `${reportingApiUrl}/devices/search` : `${inventoryApiUrlV2}/filters/search`
-);
-var getUserRoles = (0, import_toolkit15.createSelector)(
-  [getCurrentUser, getRolesById, getIsEnterprise, getFeatures, getOrganization],
-  (currentUser, rolesById2, isEnterprise, { isHosted, hasMultitenancy }, { plan = PLANS.os.id }) => {
-    const isAdmin = currentUser.roles?.length ? currentUser.roles.some((role) => role === rolesByName.admin) : !(hasMultitenancy || isEnterprise || isHosted && plan !== PLANS.os.id);
-    const uiPermissions = isAdmin ? mapUserRolesToUiPermissions([rolesByName.admin], rolesById2) : mapUserRolesToUiPermissions(currentUser.roles || [], rolesById2);
-    return { isAdmin, uiPermissions };
-  }
+  ({ hasReporting }) => hasReporting ? `${import_constants5.reportingApiUrl}/devices/search` : `${import_constants5.inventoryApiUrlV2}/filters/search`
 );
+var getUserRoles = (0, import_toolkit15.createSelector)([getCurrentUser, getRolesById, getIsEnterprise], (currentUser, rolesById2, isEnterprise) => {
+  const isAdmin = currentUser.roles?.length ? currentUser.roles.some((role) => role === import_constants5.rolesByName.admin) : !isEnterprise;
+  const uiPermissions = isAdmin ? mapUserRolesToUiPermissions([import_constants5.rolesByName.admin], rolesById2) : mapUserRolesToUiPermissions(currentUser.roles || [], rolesById2);
+  return { isAdmin, uiPermissions };
+});
 var hasPermission = (thing, permission) => Object.values(thing).some((permissions) => permissions.includes(permission));
 var getUserCapabilities = (0, import_toolkit15.createSelector)([getUserRoles, getIsServiceProvider], ({ uiPermissions }, isServiceProvider) => {
-  const canManageReleases = hasPermission(uiPermissions.releases, uiPermissionsById.manage.value);
-  const canReadReleases = canManageReleases || hasPermission(uiPermissions.releases, uiPermissionsById.read.value);
-  const canUploadReleases = canManageReleases || hasPermission(uiPermissions.releases, uiPermissionsById.upload.value);
-  const canAuditlog = uiPermissions.auditlog.includes(uiPermissionsById.read.value);
-  const canReadUsers = uiPermissions.userManagement.includes(uiPermissionsById.read.value);
-  const canManageUsers = uiPermissions.userManagement.includes(uiPermissionsById.manage.value);
-  const canReadDevices = hasPermission(uiPermissions.groups, uiPermissionsById.read.value);
+  const canManageReleases = hasPermission(uiPermissions.releases, import_constants5.uiPermissionsById.manage.value);
+  const canReadReleases = canManageReleases || hasPermission(uiPermissions.releases, import_constants5.uiPermissionsById.read.value);
+  const canUploadReleases = canManageReleases || hasPermission(uiPermissions.releases, import_constants5.uiPermissionsById.upload.value);
+  const canAuditlog = uiPermissions.auditlog.includes(import_constants5.uiPermissionsById.read.value);
+  const canReadUsers = uiPermissions.userManagement.includes(import_constants5.uiPermissionsById.read.value);
+  const canManageUsers = uiPermissions.userManagement.includes(import_constants5.uiPermissionsById.manage.value);
+  const canReadDevices = hasPermission(uiPermissions.groups, import_constants5.uiPermissionsById.read.value);
   const canWriteDevices = Object.values(uiPermissions.groups).some(
-    (groupPermissions) => groupPermissions.includes(uiPermissionsById.read.value) && groupPermissions.length > 1
+    (groupPermissions) => groupPermissions.includes(import_constants5.uiPermissionsById.read.value) && groupPermissions.length > 1
   );
-  const canTroubleshoot = hasPermission(uiPermissions.groups, uiPermissionsById.connect.value);
-  const canManageDevices = hasPermission(uiPermissions.groups, uiPermissionsById.manage.value);
-  const canConfigure = hasPermission(uiPermissions.groups, uiPermissionsById.configure.value);
-  const canDeploy = uiPermissions.deployments.includes(uiPermissionsById.deploy.value) || hasPermission(uiPermissions.groups, uiPermissionsById.deploy.value);
-  const canReadDeployments = uiPermissions.deployments.includes(uiPermissionsById.read.value);
+  const canTroubleshoot = hasPermission(uiPermissions.groups, import_constants5.uiPermissionsById.connect.value);
+  const canManageDevices = hasPermission(uiPermissions.groups, import_constants5.uiPermissionsById.manage.value);
+  const canConfigure = hasPermission(uiPermissions.groups, import_constants5.uiPermissionsById.configure.value);
+  const canDeploy = uiPermissions.deployments.includes(import_constants5.uiPermissionsById.deploy.value) || hasPermission(uiPermissions.groups, import_constants5.uiPermissionsById.deploy.value);
+  const canReadDeployments = uiPermissions.deployments.includes(import_constants5.uiPermissionsById.read.value);
   return {
     canAuditlog,
     canConfigure,
@@ -2466,11 +2195,11 @@ var getTenantCapabilities = (0, import_toolkit15.createSelector)(
 var getFilterAttributes = (0, import_toolkit15.createSelector)(
   [getGlobalSettings, getFilteringAttributes],
   ({ previousFilters }, { identityAttributes, inventoryAttributes, systemAttributes, tagAttributes }) => {
-    const deviceNameAttribute = { key: "name", value: "Name", scope: ATTRIBUTE_SCOPES.tags, category: ATTRIBUTE_SCOPES.tags, priority: 1 };
-    const deviceIdAttribute = { key: "id", value: "Device ID", scope: ATTRIBUTE_SCOPES.identity, category: ATTRIBUTE_SCOPES.identity, priority: 1 };
-    const checkInAttribute = { key: "check_in_time", value: "Latest activity", scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 };
+    const deviceNameAttribute = { key: "name", value: "Name", scope: import_constants5.ATTRIBUTE_SCOPES.tags, category: import_constants5.ATTRIBUTE_SCOPES.tags, priority: 1 };
+    const deviceIdAttribute = { key: "id", value: "Device ID", scope: import_constants5.ATTRIBUTE_SCOPES.identity, category: import_constants5.ATTRIBUTE_SCOPES.identity, priority: 1 };
+    const checkInAttribute = { key: "check_in_time", value: "Latest activity", scope: import_constants5.ATTRIBUTE_SCOPES.system, category: import_constants5.ATTRIBUTE_SCOPES.system, priority: 4 };
     const updateAttribute = { ...checkInAttribute, key: "updated_ts", value: "Last inventory update" };
-    const firstRequestAttribute = { key: "created_ts", value: "First request", scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 };
+    const firstRequestAttribute = { key: "created_ts", value: "First request", scope: import_constants5.ATTRIBUTE_SCOPES.system, category: import_constants5.ATTRIBUTE_SCOPES.system, priority: 4 };
     const attributes = [
       ...previousFilters.map((item) => ({
         ...item,
@@ -2480,13 +2209,13 @@ var getFilterAttributes = (0, import_toolkit15.createSelector)(
       })),
       deviceNameAttribute,
       deviceIdAttribute,
-      ...identityAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.identity, category: ATTRIBUTE_SCOPES.identity, priority: 1 })),
-      ...inventoryAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.inventory, category: ATTRIBUTE_SCOPES.inventory, priority: 2 })),
-      ...tagAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.tags, category: ATTRIBUTE_SCOPES.tags, priority: 3 })),
+      ...identityAttributes.map((item) => ({ key: item, value: item, scope: import_constants5.ATTRIBUTE_SCOPES.identity, category: import_constants5.ATTRIBUTE_SCOPES.identity, priority: 1 })),
+      ...inventoryAttributes.map((item) => ({ key: item, value: item, scope: import_constants5.ATTRIBUTE_SCOPES.inventory, category: import_constants5.ATTRIBUTE_SCOPES.inventory, priority: 2 })),
+      ...tagAttributes.map((item) => ({ key: item, value: item, scope: import_constants5.ATTRIBUTE_SCOPES.tags, category: import_constants5.ATTRIBUTE_SCOPES.tags, priority: 3 })),
       checkInAttribute,
       updateAttribute,
       firstRequestAttribute,
-      ...systemAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 }))
+      ...systemAttributes.map((item) => ({ key: item, value: item, scope: import_constants5.ATTRIBUTE_SCOPES.system, category: import_constants5.ATTRIBUTE_SCOPES.system, priority: 4 }))
     ];
     return (0, import_helpers5.attributeDuplicateFilter)(attributes, "key");
   }
@@ -2528,7 +2257,7 @@ var getSelectedDeploymentData = (0, import_toolkit15.createSelector)(
 );
 var getAvailableIssueOptionsByType = (0, import_toolkit15.createSelector)(
   [getFeatures, getTenantCapabilities, getIssueCountsByType],
-  ({ hasReporting }, { hasFullFiltering, hasMonitor }, issueCounts) => Object.values(DEVICE_ISSUE_OPTIONS).reduce((accu, { isCategory, key, needsFullFiltering, needsMonitor, needsReporting, title }) => {
+  ({ hasReporting }, { hasFullFiltering, hasMonitor }, issueCounts) => Object.values(import_constants5.DEVICE_ISSUE_OPTIONS).reduce((accu, { isCategory, key, needsFullFiltering, needsMonitor, needsReporting, title }) => {
     if (isCategory || needsReporting && !hasReporting || needsFullFiltering && !hasFullFiltering || needsMonitor && !hasMonitor) {
       return accu;
     }
@@ -2536,14 +2265,11 @@ var getAvailableIssueOptionsByType = (0, import_toolkit15.createSelector)(
     return accu;
   }, {})
 );
-var getGroupNames = (0, import_toolkit15.createSelector)([getGroupsById, getUserRoles, (_, options = {}) => options], (groupsById, { uiPermissions }, { staticOnly }) => {
+var getGroupNames = (0, import_toolkit15.createSelector)([getGroupsById, getUserRoles], (groupsById, { uiPermissions }) => {
   const { [UNGROUPED_GROUP.id]: ungrouped, ...groups } = groupsById;
-  if (staticOnly) {
-    return Object.keys(uiPermissions.groups).sort();
-  }
   return Object.keys(
     Object.entries(groups).reduce((accu, [groupName, group]) => {
-      if (group.filterId || uiPermissions.groups[ALL_DEVICES]) {
+      if (group.filterId || uiPermissions.groups[import_constants5.ALL_DEVICES]) {
         accu[groupName] = group;
       }
       return accu;
@@ -2576,14 +2302,14 @@ var getAuditlogDevice = (0, import_toolkit15.createSelector)([getAuditLogEntry,
 var getRelevantRoles = (0, import_toolkit15.createSelector)([getOrganization, getRolesList], ({ service_provider }, roles) => {
   if (service_provider) {
     return roles.reduce((accu, role) => {
-      if (rolesById[role.value]) {
+      if (import_constants5.rolesById[role.value]) {
         return accu;
       }
       accu.push(role);
       return accu;
-    }, Object.values(serviceProviderRolesById));
+    }, Object.values(import_constants5.serviceProviderRolesById));
   }
-  return Object.keys(rolesById).reverse().reduce((accu, key) => {
+  return Object.keys(import_constants5.rolesById).reverse().reduce((accu, key) => {
     const index = accu.findIndex(({ value }) => value === key);
     accu = [accu[index], ...accu.filter((item, itemIndex) => index !== itemIndex)];
     return accu;
@@ -2594,6 +2320,7 @@ var getRelevantRoles = (0, import_toolkit15.createSelector)([getOrganization, ge
 var import_react_redux = require("react-redux");
 var import_helpers6 = require("@northern.tech/utils/helpers");
 var import_toolkit16 = require("@reduxjs/toolkit");
+var import_react = require("@sentry/react");
 var { setSnackbar, uploadProgress } = actions_default;
 var keys = ["sessionDeploymentChecker", settingsKeys.initialized];
 var resetEnvironment = () => keys.forEach((key) => window.sessionStorage.removeItem(key));
@@ -2630,20 +2357,50 @@ var rejectionLoggerMiddleware = () => (next) => (action) => {
   }
   return next(action);
 };
+var tracingActionIgnoreList = [actions8.successfullyLoggedIn.type, "users/loginUser/pending", "users/loginUser/fulfilled", "users/loginUser/rejected"];
+var sentryReduxEnhancer = (0, import_react.createReduxEnhancer)({
+  actionTransformer: (action) => {
+    if (tracingActionIgnoreList.includes(action.type)) {
+      return null;
+    }
+    return action;
+  },
+  // Transform the state to remove sensitive information
+  stateTransformer: (state) => {
+    const transformedState = {
+      ...state,
+      users: { ...state.users, currentSession: null },
+      organization: {
+        ...state.organization,
+        organization: {
+          ...state.organization.organization,
+          tenant_token: null
+        }
+      }
+    };
+    return transformedState;
+  }
+});
 var getConfiguredStore = (options = {}) => {
   const { preloadedState = {}, ...config } = options;
   return (0, import_toolkit16.configureStore)({
     ...config,
     preloadedState,
+    enhancers: (getDefaultEnhancers) => {
+      if (window.mender_environment?.sentry?.isReduxEnabled) {
+        return getDefaultEnhancers().concat(sentryReduxEnhancer);
+      }
+      return getDefaultEnhancers();
+    },
     reducer: sessionReducer,
     middleware: (getDefaultMiddleware) => getDefaultMiddleware({
       immutableCheck: {
         ignoredPaths: ["app.uploadsById"]
       },
       serializableCheck: {
-        ignoredActions: [actions6.receiveExternalDeviceIntegrations.name, setSnackbar.name, uploadProgress.name],
-        ignoredActionPaths: ["uploads", "snackbar", /payload\..*$/],
-        ignoredPaths: ["app.uploadsById", "app.snackbar", "organization.externalDeviceIntegrations"]
+        ignoredActions: [actions6.receiveExternalDeviceIntegrations.name, uploadProgress.name],
+        ignoredActionPaths: ["uploads", /payload\..*$/, "meta.arg.file", "meta.arg.integration.configHint"],
+        ignoredPaths: ["app.uploadsById", "organization.externalDeviceIntegrations"]
       }
     }).concat(rejectionLoggerMiddleware)
   });
@@ -2651,21 +2408,21 @@ var getConfiguredStore = (options = {}) => {
 var store = getConfiguredStore({
   preloadedState: {}
 });
+var createAppAsyncThunk = import_toolkit16.createAsyncThunk.withTypes();
 
 // src/appSlice/thunks.ts
 var import_helpers7 = require("@northern.tech/utils/helpers");
-var import_toolkit17 = require("@reduxjs/toolkit");
 var import_universal_cookie2 = __toESM(require("universal-cookie"), 1);
 var cookies2 = new import_universal_cookie2.default();
-var setFirstLoginAfterSignup = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/setFirstLoginAfterSignup`, (firstLoginAfterSignup, { dispatch }) => {
+var setFirstLoginAfterSignup = createAppAsyncThunk(`${sliceName2}/setFirstLoginAfterSignup`, (firstLoginAfterSignup, { dispatch }) => {
   cookies2.set("firstLoginAfterSignup", !!firstLoginAfterSignup, { maxAge: 60, path: "/", domain: ".mender.io", sameSite: false });
-  dispatch(actions.setFirstLoginAfterSignup(!!firstLoginAfterSignup));
+  dispatch(actions2.setFirstLoginAfterSignup(!!firstLoginAfterSignup));
 });
 var dateFunctionMap = {
   getDays: "getDate",
   setDays: "setDate"
 };
-var setOfflineThreshold = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/setOfflineThreshold`, (_, { dispatch, getState }) => {
+var setOfflineThreshold = createAppAsyncThunk(`${sliceName2}/setOfflineThreshold`, (_, { dispatch, getState }) => {
   const { interval, intervalUnit } = getOfflineThresholdSettings(getState());
   const today = /* @__PURE__ */ new Date();
   const intervalName = `${intervalUnit.charAt(0).toUpperCase()}${intervalUnit.substring(1)}`;
@@ -2676,9 +2433,9 @@ var setOfflineThreshold = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/s
   try {
     value = today.toISOString();
   } catch {
-    return Promise.resolve(dispatch(actions.setSnackbar("There was an error saving the offline threshold, please check your settings.")));
+    return Promise.resolve(dispatch(actions2.setSnackbar("There was an error saving the offline threshold, please check your settings.")));
   }
-  return Promise.resolve(dispatch(actions.setOfflineThreshold(value)));
+  return Promise.resolve(dispatch(actions2.setOfflineThreshold(value)));
 });
 var versionRegex = new RegExp(/\d+\.\d+/);
 var getLatestRelease = (thing) => {
@@ -2690,12 +2447,11 @@ var repoKeyMap = {
   mender: "Mender-Client",
   "mender-artifact": "Mender-Artifact"
 };
-var deductSaasState = (latestRelease, guiTags, saasReleases) => {
+var deductSaasState = (latestRelease, guiTags) => {
   const latestGuiTag = guiTags.length ? guiTags[0].name : "";
-  const latestSaasRelease = latestGuiTag.startsWith("saas-v") ? { date: latestGuiTag.split("-v")[1].replaceAll(".", "-"), tag: latestGuiTag } : saasReleases[0];
-  return latestSaasRelease.date > latestRelease.release_date ? latestSaasRelease.tag : latestRelease.release;
+  return latestGuiTag ? latestGuiTag : latestRelease.release;
 };
-var getLatestReleaseInfo = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/getLatestReleaseInfo`, (_, { dispatch, getState }) => {
+var getLatestReleaseInfo = createAppAsyncThunk(`${sliceName2}/getLatestReleaseInfo`, (_, { dispatch, getState }) => {
   if (!getFeatures(getState()).isHosted) {
     return Promise.resolve();
   }
@@ -2706,7 +2462,7 @@ var getLatestReleaseInfo = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/
     if (!guiTags.length) {
       return Promise.resolve();
     }
-    const { releases, saas } = data;
+    const { releases } = data;
     const latestRelease = getLatestRelease(getLatestRelease(releases));
     const { latestRepos, latestVersions } = latestRelease.repos.reduce(
       (accu, item) => {
@@ -2718,13 +2474,12 @@ var getLatestReleaseInfo = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/
       },
       { latestVersions: { ...getState().app.versionInformation }, latestRepos: {} }
     );
-    const info = deductSaasState(latestRelease, guiTags, saas);
+    const info = deductSaasState(latestRelease, guiTags);
     return Promise.resolve(
       dispatch(
-        actions.setVersionInformation({
+        actions2.setVersionInformation({
           ...latestVersions,
-          backend: info,
-          GUI: info,
+          Server: info,
           latestRelease: {
             releaseDate: latestRelease.release_date,
             repos: latestRepos
@@ -2734,9 +2489,9 @@ var getLatestReleaseInfo = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/
     );
   });
 });
-var setSearchState = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/setSearchState`, (searchState, { dispatch, getState }) => {
+var setSearchState = createAppAsyncThunk(`${sliceName2}/setSearchState`, (searchState, { dispatch, getState }) => {
   const currentState = getSearchState(getState());
-  let nextState = {
+  const nextState = {
     ...currentState,
     ...searchState,
     sort: {
@@ -2744,7 +2499,7 @@ var setSearchState = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/setSea
       ...searchState.sort
     }
   };
-  let tasks = [];
+  const tasks = [];
   const { isSearching: currentSearching, deviceIds: currentDevices, searchTotal: currentTotal, ...currentRequestState } = currentState;
   const { isSearching: nextSearching, deviceIds: nextDevices, searchTotal: nextTotal, ...nextRequestState } = nextState;
   if (nextRequestState.searchTerm && !(0, import_helpers7.deepCompare)(currentRequestState, nextRequestState)) {
@@ -2752,24 +2507,23 @@ var setSearchState = (0, import_toolkit17.createAsyncThunk)(`${sliceName}/setSea
     tasks.push(
       dispatch(searchDevices(nextState)).unwrap().then((results) => {
         const searchResult = results[results.length - 1];
-        return dispatch(actions.setSearchState({ ...searchResult, isSearching: false }));
-      }).catch(() => dispatch(actions.setSearchState({ isSearching: false, searchTotal: 0 })))
+        return dispatch(actions2.setSearchState({ ...searchResult, isSearching: false }));
+      }).catch(() => dispatch(actions2.setSearchState({ isSearching: false, searchTotal: 0 })))
     );
   }
-  tasks.push(dispatch(actions.setSearchState(nextState)));
+  tasks.push(dispatch(actions2.setSearchState(nextState)));
   return Promise.all(tasks);
 });
 
 // src/devicesSlice/thunks.tsx
 var import_react_router_dom = require("react-router-dom");
 var import_helpers8 = require("@northern.tech/utils/helpers");
-var import_toolkit18 = require("@reduxjs/toolkit");
 var import_axios2 = require("axios");
 var import_pluralize = __toESM(require("pluralize"), 1);
 var import_uuid = require("uuid");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var { cleanUpUpload, initUpload, setSnackbar: setSnackbar2, uploadProgress: uploadProgress2 } = actions_default;
-var { page: defaultPage, perPage: defaultPerPage } = DEVICE_LIST_DEFAULTS;
+var { page: defaultPage, perPage: defaultPerPage } = import_constants5.DEVICE_LIST_DEFAULTS;
 var defaultAttributes = [
   { scope: "identity", attribute: "status" },
   { scope: "inventory", attribute: "artifact_name" },
@@ -2784,9 +2538,9 @@ var defaultAttributes = [
   { scope: "system", attribute: "group" },
   { scope: "tags", attribute: "name" }
 ];
-var getGroups2 = (0, import_toolkit18.createAsyncThunk)(
+var getGroups2 = createAppAsyncThunk(
   `${sliceName3}/getGroups`,
-  (_, { dispatch, getState }) => general_api_default.get(`${inventoryApiUrl}/groups`).then((res) => {
+  (_, { dispatch, getState }) => general_api_default.get(`${import_constants5.inventoryApiUrl}/groups`).then((res) => {
     const state = getGroupsById(getState());
     const dynamicGroups = Object.entries(state).reduce((accu, [id, group]) => {
       if (group.id || group.filters?.length && id !== UNGROUPED_GROUP.id) {
@@ -2798,10 +2552,10 @@ var getGroups2 = (0, import_toolkit18.createAsyncThunk)(
       accu[group] = { deviceIds: [], filters: [], total: 0, ...state[group] };
       return accu;
     }, dynamicGroups);
-    const filters = [{ key: "group", value: res.data, operator: DEVICE_FILTERING_OPTIONS.$nin.key, scope: "system" }];
+    const filters = [{ key: "group", value: res.data, operator: import_constants5.DEVICE_FILTERING_OPTIONS.$nin.key, scope: "system" }];
     return Promise.all([
       dispatch(actions3.receivedGroups(groups)),
-      dispatch(getDevicesByStatus2({ filterSelection: filters, group: 0, page: 1, perPage: 1, status: void 0 }))
+      dispatch(getDevicesByStatus2({ filterSelection: filters, group: "", page: 1, perPage: 1, status: void 0 }))
     ]).then((promises) => {
       const devicesRetrieval = promises[promises.length - 1] || [];
       const { payload } = devicesRetrieval || {};
@@ -2813,46 +2567,49 @@ var getGroups2 = (0, import_toolkit18.createAsyncThunk)(
         dispatch(
           actions3.addGroup({
             groupName: UNGROUPED_GROUP.id,
-            group: { filters: [{ key: "group", value: res.data, operator: DEVICE_FILTERING_OPTIONS.$nin.key, scope: "system" }] }
+            group: { filters: [{ key: "group", value: res.data, operator: import_constants5.DEVICE_FILTERING_OPTIONS.$nin.key, scope: "system" }] }
           })
         )
       );
     });
   })
 );
-var addDevicesToGroup = (0, import_toolkit18.createAsyncThunk)(
+var addDevicesToGroup = createAppAsyncThunk(
   `${sliceName3}/addDevicesToGroup`,
-  ({ group, deviceIds, isCreation }, { dispatch }) => general_api_default.patch(`${inventoryApiUrl}/groups/${group}/devices`, deviceIds).then(() => dispatch(actions3.addToGroup({ group, deviceIds }))).finally(() => isCreation ? Promise.resolve(dispatch(getGroups2())) : {})
+  ({ group, deviceIds, isCreation }, { dispatch }) => general_api_default.patch(`${import_constants5.inventoryApiUrl}/groups/${group}/devices`, deviceIds).then(() => dispatch(actions3.addToGroup({ group, deviceIds }))).finally(() => isCreation ? Promise.resolve(dispatch(getGroups2())) : {})
 );
-var removeDevicesFromGroup = (0, import_toolkit18.createAsyncThunk)(
+var removeDevicesFromGroup = createAppAsyncThunk(
   `${sliceName3}/removeDevicesFromGroup`,
-  ({ group, deviceIds }, { dispatch }) => general_api_default.delete(`${inventoryApiUrl}/groups/${group}/devices`, deviceIds).then(
+  ({ group, deviceIds }, { dispatch }) => general_api_default.delete(`${import_constants5.inventoryApiUrl}/groups/${group}/devices`, deviceIds).then(
     () => Promise.all([
       dispatch(actions3.removeFromGroup({ group, deviceIds })),
-      dispatch(setSnackbar2(`The ${(0, import_pluralize.default)("devices", deviceIds.length)} ${(0, import_pluralize.default)("were", deviceIds.length)} removed from the group`, TIMEOUTS.fiveSeconds))
+      dispatch(
+        setSnackbar2({
+          message: `The ${(0, import_pluralize.default)("devices", deviceIds.length)} ${(0, import_pluralize.default)("were", deviceIds.length)} removed from the group`,
+          autoHideDuration: TIMEOUTS.fiveSeconds
+        })
+      )
     ])
   )
 );
 var getGroupNotification = (newGroup, selectedGroup) => {
   const successMessage = "The group was updated successfully";
   if (newGroup === selectedGroup) {
-    return [successMessage, TIMEOUTS.fiveSeconds];
+    return { message: successMessage, autoHideDuration: TIMEOUTS.fiveSeconds };
   }
-  return [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+  return {
+    action: "",
+    autoHideDuration: TIMEOUTS.fiveSeconds,
+    message: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
       successMessage,
       " - ",
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_router_dom.Link, { to: `/devices?inventory=group:eq:${newGroup}`, children: "click here" }),
       " to see it."
     ] }),
-    5e3,
-    void 0,
-    void 0,
-    () => {
-    }
-  ];
+    preventClickToCopy: true
+  };
 };
-var addStaticGroup = (0, import_toolkit18.createAsyncThunk)(
+var addStaticGroup = createAppAsyncThunk(
   `${sliceName3}/addStaticGroup`,
   ({ group, devices }, { dispatch, getState }) => Promise.resolve(dispatch(addDevicesToGroup({ group, deviceIds: devices.map(({ id }) => id), isCreation: true }))).then(
     () => Promise.resolve(
@@ -2866,24 +2623,24 @@ var addStaticGroup = (0, import_toolkit18.createAsyncThunk)(
       () => Promise.all([
         dispatch(setDeviceListState({ setOnly: true })),
         dispatch(getGroups2()),
-        dispatch(setSnackbar2(...getGroupNotification(group, getState().devices.groups.selectedGroup)))
+        dispatch(setSnackbar2(getGroupNotification(group, getState().devices.groups.selectedGroup)))
       ])
     )
   ).catch((err) => commonErrorHandler(err, `Group could not be updated:`, dispatch))
 );
-var removeStaticGroup = (0, import_toolkit18.createAsyncThunk)(
+var removeStaticGroup = createAppAsyncThunk(
   `${sliceName3}/removeStaticGroup`,
-  (groupName, { dispatch }) => general_api_default.delete(`${inventoryApiUrl}/groups/${groupName}`).then(
+  (groupName, { dispatch }) => general_api_default.delete(`${import_constants5.inventoryApiUrl}/groups/${groupName}`).then(
     () => Promise.all([
       dispatch(actions3.removeGroup(groupName)),
       dispatch(getGroups2()),
-      dispatch(setSnackbar2("Group was removed successfully", TIMEOUTS.fiveSeconds))
+      dispatch(setSnackbar2({ message: "Group was removed successfully", autoHideDuration: TIMEOUTS.fiveSeconds }))
     ])
   )
 );
-var getDynamicGroups = (0, import_toolkit18.createAsyncThunk)(
+var getDynamicGroups = createAppAsyncThunk(
   `${sliceName3}/getDynamicGroups`,
-  (_, { dispatch, getState }) => general_api_default.get(`${inventoryApiUrlV2}/filters?per_page=${MAX_PAGE_SIZE}`).then(({ data: filters }) => {
+  (_, { dispatch, getState }) => general_api_default.get(`${import_constants5.inventoryApiUrlV2}/filters?per_page=${MAX_PAGE_SIZE}`).then(({ data: filters }) => {
     const state = getGroupsById(getState());
     const staticGroups = Object.entries(state).reduce((accu, [id, group]) => {
       if (!(group.id || group.filters?.length)) {
@@ -2904,15 +2661,15 @@ var getDynamicGroups = (0, import_toolkit18.createAsyncThunk)(
     return Promise.resolve(dispatch(actions3.receivedGroups(groups)));
   }).catch(() => console.log("Dynamic group retrieval failed - likely accessing a non-enterprise backend"))
 );
-var addDynamicGroup = (0, import_toolkit18.createAsyncThunk)(
+var addDynamicGroup = createAppAsyncThunk(
   `${sliceName3}/addDynamicGroup`,
-  ({ groupName, filterPredicates }, { dispatch, getState }) => general_api_default.post(`${inventoryApiUrlV2}/filters`, { name: groupName, terms: mapFiltersToTerms(filterPredicates) }).then(
+  ({ groupName, filterPredicates }, { dispatch, getState }) => general_api_default.post(`${import_constants5.inventoryApiUrlV2}/filters`, { name: groupName, terms: mapFiltersToTerms(filterPredicates) }).then(
     (res) => Promise.resolve(
       dispatch(
         actions3.addGroup({
           groupName,
           group: {
-            id: res.headers[headerNames.location].substring(res.headers[headerNames.location].lastIndexOf("/") + 1),
+            id: res.headers[import_constants5.headerNames.location].substring(res.headers[import_constants5.headerNames.location].lastIndexOf("/") + 1),
             filters: filterPredicates
           }
         })
@@ -2921,45 +2678,56 @@ var addDynamicGroup = (0, import_toolkit18.createAsyncThunk)(
       const { cleanedFilters } = getGroupFilters(groupName, getState().devices.groups);
       return Promise.all([
         dispatch(actions3.setDeviceFilters(cleanedFilters)),
-        dispatch(setSnackbar2(...getGroupNotification(groupName, getState().devices.groups.selectedGroup))),
+        dispatch(setSnackbar2(getGroupNotification(groupName, getState().devices.groups.selectedGroup))),
         dispatch(getDynamicGroups())
       ]);
     })
   ).catch((err) => commonErrorHandler(err, `Group could not be updated:`, dispatch))
 );
-var updateDynamicGroup = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/updateDynamicGroup`, ({ groupName, filterPredicates }, { dispatch, getState }) => {
-  const filterId = getState().devices.groups.byId[groupName].id;
-  return general_api_default.delete(`${inventoryApiUrlV2}/filters/${filterId}`).then(() => Promise.resolve(dispatch(addDynamicGroup({ groupName, filterPredicates }))));
-});
-var removeDynamicGroup = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/removeDynamicGroup`, (groupName, { dispatch, getState }) => {
+var updateDynamicGroup = createAppAsyncThunk(
+  `${sliceName3}/updateDynamicGroup`,
+  ({ groupName, filterPredicates }, { dispatch, getState }) => {
+    const filterId = getState().devices.groups.byId[groupName].id;
+    return general_api_default.delete(`${import_constants5.inventoryApiUrlV2}/filters/${filterId}`).then(
+      () => Promise.resolve(dispatch(addDynamicGroup({ groupName, filterPredicates })))
+    );
+  }
+);
+var removeDynamicGroup = createAppAsyncThunk(`${sliceName3}/removeDynamicGroup`, (groupName, { dispatch, getState }) => {
   const filterId = getState().devices.groups.byId[groupName].id;
-  return general_api_default.delete(`${inventoryApiUrlV2}/filters/${filterId}`).then(
-    () => Promise.all([dispatch(actions3.removeGroup(groupName)), dispatch(setSnackbar2("Group was removed successfully", TIMEOUTS.fiveSeconds))])
+  return general_api_default.delete(`${import_constants5.inventoryApiUrlV2}/filters/${filterId}`).then(
+    () => Promise.all([
+      dispatch(actions3.removeGroup(groupName)),
+      dispatch(setSnackbar2({ message: "Group was removed successfully", autoHideDuration: TIMEOUTS.fiveSeconds }))
+    ])
   );
 });
 var getGroupFilters = (group, groupsState, filters = []) => {
   const groupName = group === UNGROUPED_GROUP.id || group === UNGROUPED_GROUP.name ? UNGROUPED_GROUP.id : group;
   const selectedGroup = groupsState.byId[groupName];
   const groupFilterLength = selectedGroup?.filters?.length || 0;
-  const cleanedFilters = groupFilterLength ? [...filters, ...selectedGroup.filters].filter(filtersFilter) : filters;
+  const cleanedFilters = groupFilterLength ? [...filters, ...selectedGroup.filters || []].filter(filtersFilter) : filters;
   return { cleanedFilters, groupName, selectedGroup, groupFilterLength };
 };
-var selectGroup = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/selectGroup`, ({ group, filters = [] }, { dispatch, getState }) => {
-  const { cleanedFilters, groupName, selectedGroup, groupFilterLength } = getGroupFilters(group, getState().devices.groups, filters);
-  if (getSelectedGroup(getState()) === groupName && (filters.length === 0 && !groupFilterLength || filters.length === cleanedFilters.length)) {
-    return Promise.resolve();
-  }
-  let tasks = [];
-  if (groupFilterLength) {
-    tasks.push(dispatch(actions3.setDeviceFilters(cleanedFilters)));
-  } else {
-    tasks.push(dispatch(actions3.setDeviceFilters(filters)));
-    tasks.push(dispatch(getGroupDevices({ group: groupName, perPage: 1, shouldIncludeAllStates: true })));
+var selectGroup = createAppAsyncThunk(
+  `${sliceName3}/selectGroup`,
+  ({ group, filters = [] }, { dispatch, getState }) => {
+    const { cleanedFilters, groupName, selectedGroup, groupFilterLength } = getGroupFilters(group, getState().devices.groups, filters);
+    if (getSelectedGroup(getState()) === groupName && (filters.length === 0 && !groupFilterLength || filters.length === cleanedFilters.length)) {
+      return Promise.resolve();
+    }
+    const tasks = [];
+    if (groupFilterLength) {
+      tasks.push(dispatch(actions3.setDeviceFilters(cleanedFilters)));
+    } else {
+      tasks.push(dispatch(actions3.setDeviceFilters(filters)));
+      tasks.push(dispatch(getGroupDevices({ group: groupName, perPage: 1, shouldIncludeAllStates: true })));
+    }
+    const selectedGroupName = selectedGroup || !Object.keys(getGroupsById(getState())).length ? groupName : void 0;
+    tasks.push(dispatch(actions3.selectGroup(selectedGroupName)));
+    return Promise.all(tasks);
   }
-  const selectedGroupName = selectedGroup || !Object.keys(getGroupsById(getState())).length ? groupName : void 0;
-  tasks.push(dispatch(actions3.selectGroup(selectedGroupName)));
-  return Promise.all(tasks);
-});
+);
 var getEarliestTs = (dateA = "", dateB = "") => !dateA || !dateB ? dateA || dateB : dateA < dateB ? dateA : dateB;
 var reduceReceivedDevices = (devices, ids, state, status) => devices.reduce(
   (accu, device) => {
@@ -2990,11 +2758,16 @@ var reduceReceivedDevices = (devices, ids, state, status) => devices.reduce(
   },
   { ids, devicesById: {} }
 );
-var getGroupDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getGroupDevices`, (options, { dispatch, getState }) => {
+var getGroupDevices = createAppAsyncThunk(`${sliceName3}/getGroupDevices`, (options, { dispatch, getState }) => {
   const { group, shouldIncludeAllStates, ...remainder } = options;
   const { cleanedFilters: filterSelection } = getGroupFilters(group, getState().devices.groups);
-  return Promise.resolve(
-    dispatch(getDevicesByStatus2({ ...remainder, filterSelection, group, status: shouldIncludeAllStates ? void 0 : DEVICE_STATES.accepted }))
+  return dispatch(
+    getDevicesByStatus2({
+      ...remainder,
+      filterSelection,
+      group,
+      status: shouldIncludeAllStates ? void 0 : import_constants5.DEVICE_STATES.accepted
+    })
   ).unwrap().then((results) => {
     if (!group) {
       return Promise.resolve();
@@ -3008,7 +2781,7 @@ var getGroupDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getG
       dispatch(
         actions3.addGroup({
           group: {
-            deviceIds: deviceAccu.ids.length === total || deviceAccu.ids.length > stateGroup?.deviceIds ? deviceAccu.ids : stateGroup.deviceIds,
+            deviceIds: deviceAccu.ids.length === total || stateGroup && stateGroup.deviceIds && deviceAccu.ids.length > stateGroup.deviceIds ? deviceAccu.ids : stateGroup.deviceIds,
             total
           },
           groupName: group
@@ -3017,63 +2790,71 @@ var getGroupDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getG
     );
   });
 });
-var getAllGroupDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getAllGroupDevices`, (group, { dispatch, getState }) => {
-  if (!group || !!group && (!getGroupsById(getState())[group] || getGroupsById(getState())[group].filters.length)) {
-    return Promise.resolve();
-  }
-  const { attributes, filterTerms } = prepareSearchArguments({
-    filters: [],
-    group,
-    state: getState(),
-    status: DEVICE_STATES.accepted
-  });
-  const getAllDevices = (perPage = MAX_PAGE_SIZE, page = defaultPage, devices = []) => general_api_default.post(getSearchEndpoint(getState()), {
-    page,
-    per_page: perPage,
-    filters: filterTerms,
-    attributes
-  }).then((res) => {
-    const state = getState();
-    const deviceAccu = reduceReceivedDevices(res.data, devices, state);
-    dispatch(actions3.receivedDevices(deviceAccu.devicesById));
-    const total = Number(res.headers[headerNames.total]);
-    if (total > perPage * page) {
-      return getAllDevices(perPage, page + 1, deviceAccu.ids);
+var getAllGroupDevices = createAppAsyncThunk(
+  `${sliceName3}/getAllGroupDevices`,
+  ({ group, attribute }, { dispatch, getState }) => {
+    if (!group || !!group && (!getGroupsById(getState())[group] || getGroupsById(getState())[group].filters.length)) {
+      return Promise.resolve();
     }
-    return Promise.resolve(dispatch(actions3.addGroup({ group: { deviceIds: deviceAccu.ids, total: deviceAccu.ids.length }, groupName: group })));
-  });
-  return getAllDevices();
-});
-var getAllDynamicGroupDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getAllDynamicGroupDevices`, (group, { dispatch, getState }) => {
-  if (!!group && (!getGroupsById(getState())[group] || !getGroupsById(getState())[group].filters.length)) {
-    return Promise.resolve();
+    const { attributes, filterTerms } = prepareSearchArguments({
+      filters: [],
+      group,
+      state: getState(),
+      status: import_constants5.DEVICE_STATES.accepted
+    });
+    const getAllDevices = (perPage = MAX_PAGE_SIZE, page = defaultPage, devices = []) => general_api_default.post(getSearchEndpoint(getState()), {
+      page,
+      per_page: perPage,
+      filters: filterTerms,
+      attributes: [...attributes, { scope: "inventory", attribute }]
+    }).then((res) => {
+      const state = getState();
+      const deviceAccu = reduceReceivedDevices(res.data, devices, state);
+      dispatch(actions3.receivedDevices(deviceAccu.devicesById));
+      const total = Number(res.headers[import_constants5.headerNames.total]);
+      if (total > perPage * page) {
+        return getAllDevices(perPage, page + 1, deviceAccu.ids);
+      }
+      return Promise.resolve(dispatch(actions3.addGroup({ group: { deviceIds: deviceAccu.ids, total: deviceAccu.ids.length }, groupName: group })));
+    });
+    return getAllDevices();
   }
-  const { attributes, filterTerms: filters } = prepareSearchArguments({
-    filters: getState().devices.groups.byId[group].filters,
-    state: getState(),
-    status: DEVICE_STATES.accepted
-  });
-  const getAllDevices = (perPage = MAX_PAGE_SIZE, page = defaultPage, devices = []) => general_api_default.post(getSearchEndpoint(getState()), { page, per_page: perPage, filters, attributes }).then((res) => {
-    const state = getState();
-    const deviceAccu = reduceReceivedDevices(res.data, devices, state);
-    dispatch(actions3.receivedDevices(deviceAccu.devicesById));
-    const total = Number(res.headers[headerNames.total]);
-    if (total > deviceAccu.ids.length) {
-      return getAllDevices(perPage, page + 1, deviceAccu.ids);
+);
+var getAllDynamicGroupDevices = createAppAsyncThunk(
+  `${sliceName3}/getAllDynamicGroupDevices`,
+  ({ group, attribute }, { dispatch, getState }) => {
+    if (!!group && (!getGroupsById(getState())[group] || !getGroupsById(getState())[group].filters.length)) {
+      return Promise.resolve();
     }
-    return Promise.resolve(dispatch(actions3.addGroup({ group: { deviceIds: deviceAccu.ids, total }, groupName: group })));
-  });
-  return getAllDevices();
-});
-var getDeviceById2 = (0, import_toolkit18.createAsyncThunk)(
+    const { attributes, filterTerms: filters } = prepareSearchArguments({
+      filters: getState().devices.groups.byId[group].filters,
+      state: getState(),
+      status: import_constants5.DEVICE_STATES.accepted
+    });
+    const getAllDevices = (perPage = MAX_PAGE_SIZE, page = defaultPage, devices = []) => general_api_default.post(getSearchEndpoint(getState()), { page, per_page: perPage, filters, attributes: [...attributes, { scope: "inventory", attribute }] }).then(
+      (res) => {
+        const state = getState();
+        const deviceAccu = reduceReceivedDevices(res.data, devices, state);
+        dispatch(actions3.receivedDevices(deviceAccu.devicesById));
+        const total = Number(res.headers[import_constants5.headerNames.total]);
+        if (total > deviceAccu.ids.length) {
+          return getAllDevices(perPage, page + 1, deviceAccu.ids);
+        }
+        return Promise.resolve(dispatch(actions3.addGroup({ group: { deviceIds: deviceAccu.ids, total }, groupName: group })));
+      }
+    );
+    return getAllDevices();
+  }
+);
+var getDeviceById2 = createAppAsyncThunk(
   `${sliceName3}/getDeviceById`,
-  (id, { dispatch, getState }) => general_api_default.get(`${inventoryApiUrl}/devices/${id}`).then((res) => {
+  (id, { dispatch, getState }) => general_api_default.get(`${import_constants5.inventoryApiUrl}/devices/${id}`).then((res) => {
     const device = reduceReceivedDevices([res.data], [], getState()).devicesById[id];
     device.etag = res.headers.etag;
     dispatch(actions3.receivedDevice(device));
     return Promise.resolve(device);
   }).catch((err) => {
-    const errMsg = (0, import_helpers8.extractErrorMessage)(err);
+    const errMsg = extractErrorMessage(err);
     if (errMsg.includes("Not Found")) {
       console.log(`${id} does not have any inventory information`);
       const device = reduceReceivedDevices(
@@ -3083,7 +2864,8 @@ var getDeviceById2 = (0, import_toolkit18.createAsyncThunk)(
             attributes: [
               { name: "status", value: "decomissioned", scope: "identity" },
               { name: "decomissioned", value: "true", scope: "inventory" }
-            ]
+            ],
+            log: false
           }
         ],
         [],
@@ -3093,17 +2875,20 @@ var getDeviceById2 = (0, import_toolkit18.createAsyncThunk)(
     }
   })
 );
-var getDeviceInfo = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getDeviceInfo`, (deviceId, { dispatch, getState }) => {
+var getDeviceInfo = createAppAsyncThunk(`${sliceName3}/getDeviceInfo`, (deviceId, { dispatch, getState }) => {
   const device = getDeviceById(getState(), deviceId);
   const { hasDeviceConfig, hasDeviceConnect, hasMonitor } = getTenantCapabilities(getState());
   const { canConfigure } = getUserCapabilities(getState());
   const integrations = getDeviceTwinIntegrations(getState());
-  let tasks = [dispatch(getDeviceAuth(deviceId)), ...integrations.map((integration) => dispatch(getDeviceTwin({ deviceId, integration })))];
-  if (hasDeviceConfig && canConfigure && [DEVICE_STATES.accepted, DEVICE_STATES.preauth].includes(device.status)) {
+  const tasks = [
+    dispatch(getDeviceAuth(deviceId)),
+    dispatch(getDeviceById2(deviceId)),
+    ...integrations.map((integration) => dispatch(getDeviceTwin({ deviceId, integration })))
+  ];
+  if (hasDeviceConfig && canConfigure && (device.status === import_constants5.DEVICE_STATES.accepted || device.status === import_constants5.DEVICE_STATES.preauth)) {
     tasks.push(dispatch(getDeviceConfig(deviceId)));
   }
-  if (device.status === DEVICE_STATES.accepted) {
-    tasks.push(dispatch(getDeviceById2(deviceId)));
+  if (device.status === import_constants5.DEVICE_STATES.accepted) {
     if (hasDeviceConnect) {
       tasks.push(dispatch(getDeviceConnect(deviceId)));
     }
@@ -3114,156 +2899,136 @@ var getDeviceInfo = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getDev
   }
   return Promise.all(tasks);
 });
-var deriveInactiveDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/deriveInactiveDevices`, (deviceIds, { dispatch, getState }) => {
-  const yesterday = /* @__PURE__ */ new Date();
-  yesterday.setDate(yesterday.getDate() - 1);
-  const yesterdaysIsoString = yesterday.toISOString();
-  const devices = deviceIds.reduce(
-    (accu, id) => {
-      const device = getDeviceById(getState(), id);
-      if (device && device.updated_ts > yesterdaysIsoString) {
-        accu.active.push(id);
-      } else {
-        accu.inactive.push(id);
-      }
-      return accu;
-    },
-    { active: [], inactive: [] }
-  );
-  return dispatch(actions3.setInactiveDevices({ activeDeviceTotal: devices.active.length, inactiveDeviceTotal: devices.inactive.length }));
-});
-var getDeviceCount = (0, import_toolkit18.createAsyncThunk)(
+var getDeviceCount = createAppAsyncThunk(
   `${sliceName3}/getDeviceCount`,
   (status, { dispatch, getState }) => general_api_default.post(getSearchEndpoint(getState()), {
     page: 1,
     per_page: 1,
-    filters: mapFiltersToTerms([{ key: "status", value: status, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }]),
+    filters: mapFiltersToTerms([{ key: "status", value: status, operator: import_constants5.DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }]),
     attributes: defaultAttributes
   }).then((response) => {
-    const count = Number(response.headers[headerNames.total]);
-    if (status) {
-      return dispatch(actions3.setDevicesCountByStatus({ count, status }));
-    }
-    return dispatch(actions3.setTotalDevices(count));
+    const count = Number(response.headers[import_constants5.headerNames.total]);
+    return dispatch(actions3.setDevicesCountByStatus({ count, status }));
   })
 );
-var getAllDeviceCounts = (0, import_toolkit18.createAsyncThunk)(
+var getAllDeviceCounts = createAppAsyncThunk(
   `${sliceName3}/getAllDeviceCounts`,
-  (_, { dispatch }) => Promise.all([DEVICE_STATES.accepted, DEVICE_STATES.pending].map((status) => dispatch(getDeviceCount(status))))
+  (_, { dispatch }) => Promise.all([import_constants5.DEVICE_STATES.accepted, import_constants5.DEVICE_STATES.pending].map((status) => dispatch(getDeviceCount(status))))
 );
-var getDeviceLimit2 = (0, import_toolkit18.createAsyncThunk)(
+var getDeviceLimit2 = createAppAsyncThunk(
   `${sliceName3}/getDeviceLimit`,
-  (_, { dispatch }) => general_api_default.get(`${deviceAuthV2}/limits/max_devices`).then((res) => dispatch(actions3.setDeviceLimit(res.data.limit)))
+  (_, { dispatch }) => general_api_default.get(`${import_constants5.deviceAuthV2}/limits/max_devices`).then((res) => dispatch(actions3.setDeviceLimit(res.data.limit)))
 );
-var setDeviceListState = (0, import_toolkit18.createAsyncThunk)(
+var setDeviceListState = createAppAsyncThunk(
   `${sliceName3}/setDeviceListState`,
   ({ shouldSelectDevices = true, forceRefresh, fetchAuth = true, ...selectionState }, { dispatch, getState }) => {
     const currentState = getDeviceListState(getState());
     const refreshTrigger = forceRefresh ? !currentState.refreshTrigger : selectionState.refreshTrigger;
-    let nextState = {
+    const nextState = {
       ...currentState,
       setOnly: false,
       refreshTrigger,
       ...selectionState,
       sort: { ...currentState.sort, ...selectionState.sort }
     };
-    let tasks = [];
+    const tasks = [];
     const { isLoading: currentLoading, deviceIds: currentDevices, selection: currentSelection, ...currentRequestState } = currentState;
     const { isLoading: nextLoading, deviceIds: nextDevices, selection: nextSelection, ...nextRequestState } = nextState;
     if (!nextState.setOnly && !(0, import_helpers8.deepCompare)(currentRequestState, nextRequestState)) {
-      const { direction: sortDown = SORTING_OPTIONS.desc, key: sortCol, scope: sortScope } = nextState.sort ?? {};
-      const sortBy = sortCol ? [{ attribute: sortCol, order: sortDown, scope: sortScope }] : void 0;
-      const applicableSelectedState = nextState.state === ALL_DEVICE_STATES ? void 0 : nextState.state;
-      nextState.isLoading = true;
-      tasks.push(
-        dispatch(getDevicesByStatus2({ ...nextState, status: applicableSelectedState, sortOptions: sortBy, fetchAuth })).unwrap().then((results) => {
-          const { deviceAccu, total } = results[results.length - 1];
-          const devicesState = shouldSelectDevices ? { deviceIds: deviceAccu.ids, total, isLoading: false } : { isLoading: false };
-          return Promise.resolve(dispatch(actions3.setDeviceListState(devicesState)));
-        }).catch(() => Promise.resolve({ isLoading: false }))
-      );
-    }
-    tasks.push(dispatch(actions3.setDeviceListState(nextState)));
-    return Promise.all(tasks);
-  }
-);
-var getDevicesByStatus2 = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getDevicesByStatus`, (options, { dispatch, getState }) => {
-  const {
-    status,
-    fetchAuth = true,
-    filterSelection,
-    group,
-    selectedIssues = [],
-    page = defaultPage,
-    perPage = defaultPerPage,
-    sortOptions = [],
-    selectedAttributes = getSelectedDeviceAttribute(getState())
-  } = options;
-  const state = getState();
-  const { applicableFilters, filterTerms } = convertDeviceListStateToFilters({
-    filters: filterSelection ?? getDeviceFilters(state),
-    group: group ?? getSelectedGroup(state),
-    groups: state.devices.groups,
-    offlineThreshold: state.app.offlineThreshold,
-    selectedIssues,
-    status
-  });
-  const attributes = [...defaultAttributes, getIdAttribute(getState()), ...selectedAttributes];
-  return general_api_default.post(getSearchEndpoint(getState()), {
-    page,
-    per_page: perPage,
-    filters: filterTerms,
-    sort: sortOptions,
-    attributes
-  }).then((response) => {
-    const state2 = getState();
-    const deviceAccu = reduceReceivedDevices(response.data, [], state2, status);
-    let total = !applicableFilters.length ? Number(response.headers[headerNames.total]) : null;
-    if (status && state2.devices.byStatus[status].total === deviceAccu.ids.length) {
-      total = deviceAccu.ids.length;
-    }
-    let tasks = [dispatch(actions3.receivedDevices(deviceAccu.devicesById))];
-    if (status) {
-      tasks.push(dispatch(actions3.setDevicesByStatus({ deviceIds: deviceAccu.ids, status, total })));
-    }
-    const receivedDevices = Object.values(deviceAccu.devicesById);
-    if (receivedDevices.length && fetchAuth) {
-      tasks.push(dispatch(getDevicesWithAuth(receivedDevices)));
+      const { direction: sortDown = import_constants5.SORTING_OPTIONS.desc, key: sortCol, scope: sortScope = "" } = nextState.sort ?? {};
+      const sortBy = sortCol ? [{ attribute: sortCol, order: sortDown, scope: sortScope }] : void 0;
+      const applicableSelectedState = nextState.state === import_constants5.ALL_DEVICE_STATES ? void 0 : nextState.state;
+      nextState.isLoading = true;
+      tasks.push(
+        dispatch(getDevicesByStatus2({ ...nextState, status: applicableSelectedState, sortOptions: sortBy, fetchAuth })).unwrap().then((results) => {
+          const { deviceAccu, total } = results[results.length - 1];
+          const devicesState = shouldSelectDevices ? { deviceIds: deviceAccu.ids, total, isLoading: false } : { isLoading: false };
+          return Promise.resolve(dispatch(actions3.setDeviceListState(devicesState)));
+        }).catch(() => Promise.resolve({ isLoading: false }))
+      );
     }
-    tasks.push(Promise.resolve({ deviceAccu, total: Number(response.headers[headerNames.total]) }));
+    tasks.push(dispatch(actions3.setDeviceListState(nextState)));
     return Promise.all(tasks);
-  }).catch((err) => commonErrorHandler(err, `${status} devices couldn't be loaded.`, dispatch, commonErrorFallback));
-});
-var getAllDevicesByStatus = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getAllDevicesByStatus`, (status, { dispatch, getState }) => {
-  const attributes = [...defaultAttributes, getIdAttribute(getState())];
-  const getAllDevices = (perPage = MAX_PAGE_SIZE, page = 1, devices = []) => general_api_default.post(getSearchEndpoint(getState()), {
-    page,
-    per_page: perPage,
-    filters: mapFiltersToTerms([{ key: "status", value: status, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }]),
-    attributes
-  }).then((res) => {
+  }
+);
+var getDevicesByStatus2 = createAppAsyncThunk(
+  `${sliceName3}/getDevicesByStatus`,
+  (options, { dispatch, getState }) => {
+    const {
+      status,
+      fetchAuth = true,
+      filterSelection,
+      group,
+      selectedIssues = [],
+      page = defaultPage,
+      perPage = defaultPerPage,
+      sortOptions = [],
+      selectedAttributes = getSelectedDeviceAttribute(getState())
+    } = options;
     const state = getState();
-    const deviceAccu = reduceReceivedDevices(res.data, devices, state, status);
-    dispatch(actions3.receivedDevices(deviceAccu.devicesById));
-    const total = Number(res.headers[headerNames.total]);
-    if (total > state.deployments.deploymentDeviceLimit) {
+    const { applicableFilters, filterTerms } = convertDeviceListStateToFilters({
+      filters: filterSelection ?? getDeviceFilters(state),
+      group: group ?? getSelectedGroup(state),
+      groups: state.devices.groups,
+      offlineThreshold: state.app.offlineThreshold,
+      selectedIssues,
+      status
+    });
+    const attributes = [...defaultAttributes, getIdAttribute(getState()), ...selectedAttributes];
+    return general_api_default.post(getSearchEndpoint(getState()), {
+      page,
+      per_page: perPage,
+      filters: filterTerms,
+      sort: sortOptions,
+      attributes
+    }).then((response) => {
+      const state2 = getState();
+      const deviceAccu = reduceReceivedDevices(response.data, [], state2, status);
+      let total = !applicableFilters.length ? Number(response.headers[import_constants5.headerNames.total]) : 0;
+      if (status && state2.devices.byStatus[status].total === deviceAccu.ids.length) {
+        total = deviceAccu.ids.length;
+      }
+      const tasks = [dispatch(actions3.receivedDevices(deviceAccu.devicesById))];
+      if (status) {
+        tasks.push(dispatch(actions3.setDevicesByStatus({ deviceIds: deviceAccu.ids, status, total })));
+      }
+      const receivedDevices = Object.values(deviceAccu.devicesById);
+      if (receivedDevices.length && fetchAuth) {
+        tasks.push(dispatch(getDevicesWithAuth(receivedDevices)));
+      }
+      tasks.push(Promise.resolve({ deviceAccu, total: Number(response.headers[import_constants5.headerNames.total]) }));
+      return Promise.all(tasks);
+    }).catch((err) => commonErrorHandler(err, `${status} devices couldn't be loaded.`, dispatch, commonErrorFallback));
+  }
+);
+var getAllDevicesByStatus = createAppAsyncThunk(
+  `${sliceName3}/getAllDevicesByStatus`,
+  ({ status, attribute }, { dispatch, getState }) => {
+    const attributes = [...defaultAttributes, getIdAttribute(getState())];
+    const getAllDevices = (perPage = MAX_PAGE_SIZE, page = 1, devices = []) => general_api_default.post(getSearchEndpoint(getState()), {
+      page,
+      per_page: perPage,
+      filters: mapFiltersToTerms([{ key: "status", value: status, operator: import_constants5.DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }]),
+      attributes: [...attributes, { scope: "inventory", attribute }]
+    }).then((res) => {
+      const state = getState();
+      const deviceAccu = reduceReceivedDevices(res.data, devices, state, status);
+      dispatch(actions3.receivedDevices(deviceAccu.devicesById));
+      const total = Number(res.headers[import_constants5.headerNames.total]);
+      if (total > state.deployments.deploymentDeviceLimit) {
+        return Promise.resolve();
+      }
+      if (total > perPage * page) {
+        return getAllDevices(perPage, page + 1, deviceAccu.ids);
+      }
       return Promise.resolve();
-    }
-    if (total > perPage * page) {
-      return getAllDevices(perPage, page + 1, deviceAccu.ids);
-    }
-    let tasks = [dispatch(actions3.setDevicesByStatus({ deviceIds: deviceAccu.ids, forceUpdate: true, status, total: deviceAccu.ids.length }))];
-    if (status === DEVICE_STATES.accepted && deviceAccu.ids.length === total) {
-      tasks.push(dispatch(deriveInactiveDevices(deviceAccu.ids)));
-      tasks.push(dispatch(deriveReportsData()));
-    }
-    return Promise.all(tasks);
-  });
-  return getAllDevices();
-});
-var searchDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/searchDevices`, (passedOptions = {}, { dispatch, getState }) => {
+    });
+    return getAllDevices();
+  }
+);
+var searchDevices = createAppAsyncThunk(`${sliceName3}/searchDevices`, (passedOptions = {}, { dispatch, getState }) => {
   const state = getState();
-  let options = { ...state.app.searchState, ...passedOptions };
+  const options = { ...state.app.searchState, ...passedOptions };
   const { page = defaultPage, searchTerm, sortOptions = [] } = options;
   const { columnSelection = [] } = getUserSettings(state);
   const selectedAttributes = columnSelection.map((column) => ({ attribute: column.key, scope: column.scope }));
@@ -3279,7 +3044,7 @@ var searchDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/search
     const deviceAccu = reduceReceivedDevices(response.data, [], getState());
     return Promise.all([
       dispatch(actions3.receivedDevices(deviceAccu.devicesById)),
-      Promise.resolve({ deviceIds: deviceAccu.ids, searchTotal: Number(response.headers[headerNames.total]) })
+      Promise.resolve({ deviceIds: deviceAccu.ids, searchTotal: Number(response.headers[import_constants5.headerNames.total]) })
     ]);
   }).catch((err) => commonErrorHandler(err, `devices couldn't be searched.`, dispatch, commonErrorFallback));
 });
@@ -3294,64 +3059,25 @@ var attributeReducer = (attributes = []) => attributes.slice(0, ATTRIBUTE_LIST_C
   },
   { identity: [], inventory: [], system: [], tags: [] }
 );
-var getDeviceAttributes = (0, import_toolkit18.createAsyncThunk)(
+var getDeviceAttributes = createAppAsyncThunk(
   `${sliceName3}/getDeviceAttributes`,
   (_, { dispatch, getState }) => general_api_default.get(getAttrsEndpoint(getState())).then(({ data }) => {
     const { identity: identityAttributes, inventory: inventoryAttributes, system: systemAttributes, tags: tagAttributes } = attributeReducer(data || []);
     return dispatch(actions3.setFilterAttributes({ identityAttributes, inventoryAttributes, systemAttributes, tagAttributes }));
   })
 );
-var getReportingLimits = (0, import_toolkit18.createAsyncThunk)(
-  `${sliceName3}/getReportingLimits`,
-  (_, { dispatch }) => general_api_default.get(`${reportingApiUrl}/devices/attributes`).catch((err) => commonErrorHandler(err, `filterable attributes limit & usage could not be retrieved.`, dispatch, commonErrorFallback)).then(({ data }) => {
-    const { attributes, count, limit } = data;
-    const groupedAttributes = attributeReducer(attributes);
-    return Promise.resolve(dispatch(actions3.setFilterablesConfig({ count, limit, attributes: groupedAttributes })));
-  })
-);
-var ensureVersionString = (software, fallback) => software.length && software !== "artifact_name" ? software.endsWith(".version") ? software : `${software}.version` : fallback;
-var getSingleReportData = (reportConfig, groups) => {
-  const { attribute, group, software = "" } = reportConfig;
-  const filters = [{ key: "status", scope: "identity", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: "accepted" }];
-  if (group) {
-    const staticGroupFilter = { key: "group", scope: "system", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: group };
-    const { cleanedFilters: groupFilters } = getGroupFilters(group, groups);
-    filters.push(...groupFilters.length ? groupFilters : [staticGroupFilter]);
-  }
-  const aggregationAttribute = ensureVersionString(software, attribute);
-  return general_api_default.post(`${reportingApiUrl}/devices/aggregate`, {
-    aggregations: [{ attribute: aggregationAttribute, name: "*", scope: "inventory", size: REPORT_CHART_SIZE_LIMIT }],
-    filters: mapFiltersToTerms(filters)
-  }).then(({ data }) => ({ data, reportConfig }));
-};
-var getReportsData = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getReportsData`, (_, { dispatch, getState }) => {
-  const state = getState();
-  const currentUserId = getCurrentUser(state).id;
-  const reports = getUserSettings(state).reports || getGlobalSettings(state)[`${currentUserId}-reports`] || (Object.keys(getDevicesById(state)).length ? defaultReports : []);
-  return Promise.all(reports.map((report) => getSingleReportData(report, getState().devices.groups))).then((results) => {
-    const devicesState = getState().devices;
-    const totalDeviceCount = devicesState.byStatus.accepted.total;
-    const newReports = results.map(({ data, reportConfig }) => {
-      let { items, other_count } = data[0];
-      const { attribute, group, software = "" } = reportConfig;
-      const dataCount = items.reduce((accu, item) => accu + item.count, 0);
-      const otherCount = !group && (software === rootfsImageVersion || attribute === "artifact_name") ? totalDeviceCount - dataCount : other_count;
-      return { items, otherCount, total: otherCount + dataCount };
-    });
-    return Promise.resolve(dispatch(actions3.setDeviceReports(newReports)));
-  });
-});
 var initializeDistributionData = (report, groups, devices, totalDeviceCount) => {
   const { attribute, group = "", software = "" } = report;
   const effectiveAttribute = software ? software : attribute;
   const { deviceIds, total = 0 } = groups[group] || {};
-  const relevantDevices = groups[group] ? deviceIds.map((id) => devices[id]) : Object.values(devices);
+  const relevantDevices = deviceIds ? deviceIds.map((id) => devices[id]) : Object.values(devices);
   const distributionByAttribute = relevantDevices.reduce((accu, item) => {
-    if (!item.attributes || item.status !== DEVICE_STATES.accepted) return accu;
-    if (!accu[item.attributes[effectiveAttribute]]) {
-      accu[item.attributes[effectiveAttribute]] = 0;
+    if (!item.attributes || item.status !== import_constants5.DEVICE_STATES.accepted) return accu;
+    const attributeValue = item.attributes[effectiveAttribute];
+    if (!accu[attributeValue]) {
+      accu[attributeValue] = 0;
     }
-    accu[item.attributes[effectiveAttribute]] = accu[item.attributes[effectiveAttribute]] + 1;
+    accu[attributeValue] = accu[attributeValue] + 1;
     return accu;
   }, {});
   const distributionByAttributeSorted = Object.entries(distributionByAttribute).sort((pairA, pairB) => pairB[1] - pairA[1]);
@@ -3360,90 +3086,111 @@ var initializeDistributionData = (report, groups, devices, totalDeviceCount) =>
   const otherCount = (groups[group] ? total : totalDeviceCount) - dataCount;
   return { items, otherCount, total: otherCount + dataCount };
 };
-var deriveReportsData = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/deriveReportsData`, (_, { dispatch, getState }) => {
-  const state = getState();
-  const {
-    groups: { byId: groupsById },
-    byId,
-    byStatus: {
-      accepted: { total }
-    }
-  } = state.devices;
-  const reports = getUserSettings(state).reports || state.users.globalSettings[`${state.users.currentUser}-reports`] || (Object.keys(byId).length ? defaultReports : []);
-  const newReports = reports.map((report) => initializeDistributionData(report, groupsById, byId, total));
+var updateReportData = createAppAsyncThunk(`${sliceName3}/updateReportData`, (reportIndex, { dispatch, getState }) => {
+  const reports = getDeviceReportsForUser(getState());
+  const report = reports[reportIndex];
+  const { group = "" } = report;
+  const devicesById = getDevicesById(getState());
+  const groups = getGroupsById(getState());
+  const acceptedDevices = getAcceptedDevices(getState());
+  const totalDeviceCount = groups[group] ? groups[group].total : acceptedDevices.total;
+  const reportsData = getDeviceReports(getState());
+  const newReports = [...reportsData];
+  newReports[reportIndex] = initializeDistributionData(report, groups, devicesById, totalDeviceCount);
   return Promise.resolve(dispatch(actions3.setDeviceReports(newReports)));
 });
-var getReportsDataWithoutBackendSupport = (0, import_toolkit18.createAsyncThunk)(
-  `${sliceName3}/getReportsDataWithoutBackendSupport`,
-  (_, { dispatch, getState }) => Promise.all([dispatch(getAllDevicesByStatus(DEVICE_STATES.accepted)), dispatch(getGroups2()), dispatch(getDynamicGroups())]).then(() => {
-    const { dynamic: dynamicGroups, static: staticGroups } = getGroups(getState());
-    return Promise.all([
-      ...staticGroups.map(({ groupId }) => dispatch(getAllGroupDevices(groupId))),
-      ...dynamicGroups.map(({ groupId }) => dispatch(getAllDynamicGroupDevices(groupId)))
-    ]).then(() => dispatch(deriveReportsData()));
-  })
+var getReportDataWithoutBackendSupport = createAppAsyncThunk(
+  `${sliceName3}/getReportDataWithoutBackendSupport`,
+  (reportIndex, { dispatch, getState }) => {
+    const reports = getDeviceReportsForUser(getState());
+    const report = reports[reportIndex];
+    if (!report) {
+      return;
+    }
+    const { attribute, group = "", software = "" } = report;
+    const effectiveAttribute = software ? software : attribute;
+    const devicesById = getDevicesById(getState());
+    const acceptedDevices = getAcceptedDevices(getState());
+    const groups = getGroupsById(getState());
+    const { deviceIds = [], filters = [], total = 0 } = groups[group] || {};
+    let groupDevicesRequest = Promise.resolve({
+      payload: { groupName: "", group: { deviceIds: Object.keys(devicesById), total: Object.keys(devicesById).length } }
+    });
+    if (group && (!(deviceIds.length && total) || deviceIds.length !== total || !deviceIds.every((id) => !!devicesById[id]))) {
+      groupDevicesRequest = filters.length ? dispatch(getAllDynamicGroupDevices({ group, attribute: effectiveAttribute })).unwrap() : dispatch(getAllGroupDevices({ group, attribute: effectiveAttribute })).unwrap();
+    } else if (!group && (acceptedDevices.deviceIds.length !== acceptedDevices.total || !acceptedDevices.deviceIds.every((id) => !!devicesById[id]))) {
+      groupDevicesRequest = dispatch(getAllDevicesByStatus({ status: import_constants5.DEVICE_STATES.accepted, attribute: effectiveAttribute })).unwrap();
+    }
+    return groupDevicesRequest.then(() => dispatch(updateReportData(reportIndex)));
+  }
 );
-var getDeviceConnect = (0, import_toolkit18.createAsyncThunk)(
+var getDeviceConnect = createAppAsyncThunk(
   `${sliceName3}/getDeviceConnect`,
-  (id, { dispatch }) => general_api_default.get(`${deviceConnect}/devices/${id}`).then(
+  (id, { dispatch }) => general_api_default.get(`${import_constants5.deviceConnect}/devices/${id}`).then(
     ({ data }) => Promise.all([dispatch(actions3.receivedDevice({ connect_status: data.status, connect_updated_ts: data.updated_ts, id })), Promise.resolve(data)])
   )
 );
 var updateTypeMap = { deploymentUpdate: "check-update", inventoryUpdate: "send-inventory" };
-var triggerDeviceUpdate = (0, import_toolkit18.createAsyncThunk)(
+var triggerDeviceUpdate = createAppAsyncThunk(
   `${sliceName3}/triggerDeviceUpdate`,
-  ({ id, type }, { dispatch }) => general_api_default.post(`${deviceConnect}/devices/${id}/${updateTypeMap[type] ?? updateTypeMap.deploymentUpdate}`).then(
+  ({ id, type }, { dispatch }) => general_api_default.post(`${import_constants5.deviceConnect}/devices/${id}/${updateTypeMap[type] ?? updateTypeMap.deploymentUpdate}`).then(
     () => new Promise((resolve) => setTimeout(() => resolve(dispatch(getDeviceById2(id))), TIMEOUTS.threeSeconds))
   )
 );
-var getSessionDetails = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getSessionDetails`, ({ sessionId, deviceId, userId, startDate, endDate }) => {
-  const { start: startUnix, end: endUnix } = (0, import_helpers8.dateRangeToUnix)(startDate, endDate);
-  const createdAfter = startDate ? `&created_after=${startUnix}` : "";
-  const createdBefore = endDate ? `&created_before=${endUnix}` : "";
-  const objectSearch = `&object_id=${deviceId}`;
-  return general_api_default.get(`${auditLogsApiUrl}/logs?per_page=500${createdAfter}${createdBefore}&actor_id=${userId}${objectSearch}`).then(
-    ({ data: auditLogEntries }) => {
-      const { start, end } = auditLogEntries.reduce(
-        (accu, item) => {
-          if (item.meta?.session_id?.includes(sessionId)) {
-            accu.start = new Date(item.action.startsWith("open") ? item.time : accu.start);
-            accu.end = new Date(item.action.startsWith("close") ? item.time : accu.end);
-          }
-          return accu;
-        },
-        { start: startDate || endDate, end: endDate || startDate }
-      );
-      return Promise.resolve({ start, end });
-    }
-  );
-});
-var getDeviceFileDownloadLink = (0, import_toolkit18.createAsyncThunk)(
+var getSessionDetails = createAppAsyncThunk(
+  `${sliceName3}/getSessionDetails`,
+  ({ sessionId, deviceId, userId, startDate, endDate }) => {
+    const { start: startUnix, end: endUnix } = (0, import_helpers8.dateRangeToUnix)(startDate, endDate);
+    const createdAfter = startDate ? `&created_after=${startUnix}` : "";
+    const createdBefore = endDate ? `&created_before=${endUnix}` : "";
+    const objectSearch = `&object_id=${deviceId}`;
+    return general_api_default.get(`${import_constants5.auditLogsApiUrl}/logs?per_page=500${createdAfter}${createdBefore}&actor_id=${userId}${objectSearch}`).then(
+      ({ data: auditLogEntries }) => {
+        const { start, end } = auditLogEntries.reduce(
+          (accu, item) => {
+            if (item.meta?.session_id?.includes(sessionId)) {
+              accu.start = new Date(item.action.startsWith("open") ? item.time : accu.start);
+              accu.end = new Date(item.action.startsWith("close") ? item.time : accu.end);
+            }
+            return accu;
+          },
+          { start: startDate || endDate, end: endDate || startDate }
+        );
+        return Promise.resolve({ start, end });
+      }
+    );
+  }
+);
+var getDeviceFileDownloadLink = createAppAsyncThunk(
   `${sliceName3}/getDeviceFileDownloadLink`,
-  ({ deviceId, path }) => Promise.resolve(`${window.location.origin}${deviceConnect}/devices/${deviceId}/download?path=${encodeURIComponent(path)}`)
+  ({ deviceId, path }) => Promise.resolve(`${window.location.origin}${import_constants5.deviceConnect}/devices/${deviceId}/download?path=${encodeURIComponent(path)}`)
 );
-var deviceFileUpload = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/deviceFileUpload`, ({ deviceId, path, file }, { dispatch }) => {
-  let formData = new FormData();
-  formData.append("path", path);
-  formData.append("file", file);
-  const uploadId = (0, import_uuid.v4)();
-  const cancelSource = new AbortController();
-  return Promise.all([
-    dispatch(setSnackbar2("Uploading file")),
-    dispatch(initUpload({ id: uploadId, upload: { inprogress: true, uploadProgress: 0, cancelSource } })),
-    general_api_default.uploadPut(
-      `${deviceConnect}/devices/${deviceId}/upload`,
-      formData,
-      (e) => dispatch(uploadProgress2({ id: uploadId, progress: progress(e) })),
-      cancelSource.signal
-    )
-  ]).then(() => Promise.resolve(dispatch(setSnackbar2("Upload successful", TIMEOUTS.fiveSeconds)))).catch((err) => {
-    if ((0, import_axios2.isCancel)(err)) {
-      return dispatch(setSnackbar2("The upload has been cancelled", TIMEOUTS.fiveSeconds));
-    }
-    return commonErrorHandler(err, `Error uploading file to device.`, dispatch);
-  }).finally(() => dispatch(cleanUpUpload(uploadId)));
-});
-var getDeviceAuth = (0, import_toolkit18.createAsyncThunk)(
+var deviceFileUpload = createAppAsyncThunk(
+  `${sliceName3}/deviceFileUpload`,
+  ({ deviceId, path, file }, { dispatch }) => {
+    const formData = new FormData();
+    formData.append("path", path);
+    formData.append("file", file);
+    const uploadId = (0, import_uuid.v4)();
+    const cancelSource = new AbortController();
+    return Promise.all([
+      dispatch(setSnackbar2("Uploading file")),
+      dispatch(initUpload({ id: uploadId, upload: { progress: 0, cancelSource } })),
+      general_api_default.uploadPut(
+        `${import_constants5.deviceConnect}/devices/${deviceId}/upload`,
+        formData,
+        (e) => dispatch(uploadProgress2({ id: uploadId, progress: progress(e) })),
+        cancelSource.signal
+      )
+    ]).then(() => Promise.resolve(dispatch(setSnackbar2({ message: "Upload successful", autoHideDuration: TIMEOUTS.fiveSeconds })))).catch((err) => {
+      if ((0, import_axios2.isCancel)(err)) {
+        return dispatch(setSnackbar2({ message: "The upload has been cancelled", autoHideDuration: TIMEOUTS.fiveSeconds }));
+      }
+      return commonErrorHandler(err, `Error uploading file to device.`, dispatch);
+    }).finally(() => dispatch(cleanUpUpload(uploadId)));
+  }
+);
+var getDeviceAuth = createAppAsyncThunk(
   `${sliceName3}/getDeviceAuth`,
   (id, { dispatch }) => dispatch(getDevicesWithAuth([{ id }])).unwrap().then((results) => {
     if (results[results.length - 1]) {
@@ -3452,81 +3199,86 @@ var getDeviceAuth = (0, import_toolkit18.createAsyncThunk)(
     return Promise.resolve();
   })
 );
-var getDevicesWithAuth = (0, import_toolkit18.createAsyncThunk)(
+var getDevicesWithAuth = createAppAsyncThunk(
   `${sliceName3}/getDevicesWithAuth`,
-  (devices, { dispatch, getState }) => devices.length ? general_api_default.get(`${deviceAuthV2}/devices?id=${devices.map((device) => device.id).join("&id=")}`).then(({ data: receivedDevices }) => {
+  (devices, { dispatch, getState }) => devices.length ? general_api_default.get(`${import_constants5.deviceAuthV2}/devices?id=${devices.map((device) => device.id).join("&id=")}`).then(({ data: receivedDevices }) => {
     const { devicesById } = reduceReceivedDevices(receivedDevices, [], getState());
     return Promise.all([dispatch(actions3.receivedDevices(devicesById)), Promise.resolve(receivedDevices)]);
   }).catch((err) => commonErrorHandler(err, `Error: ${err}`, dispatch)) : Promise.resolve([[], []])
 );
-var updateDeviceAuth = (0, import_toolkit18.createAsyncThunk)(
+var updateDeviceAuth = createAppAsyncThunk(
   `${sliceName3}/updateDeviceAuth`,
-  ({ deviceId, authId, status }, { dispatch, getState }) => general_api_default.put(`${deviceAuthV2}/devices/${deviceId}/auth/${authId}/status`, { status }).then(() => Promise.all([dispatch(getDeviceAuth(deviceId)), dispatch(setSnackbar2("Device authorization status was updated successfully"))])).catch((err) => commonErrorHandler(err, "There was a problem updating the device authorization status:", dispatch)).then(() => Promise.resolve(dispatch(actions3.maybeUpdateDevicesByStatus({ deviceId, authId })))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getDeviceListState(getState()).refreshTrigger })))
+  ({ deviceId, authId, status }, { dispatch, getState }) => general_api_default.put(`${import_constants5.deviceAuthV2}/devices/${deviceId}/auth/${authId}/status`, { status }).then(() => Promise.all([dispatch(getDeviceAuth(deviceId)), dispatch(setSnackbar2("Device authorization status was updated successfully"))])).catch((err) => commonErrorHandler(err, "There was a problem updating the device authorization status:", dispatch)).then(() => Promise.resolve(dispatch(actions3.maybeUpdateDevicesByStatus({ deviceId, authId })))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getDeviceListState(getState()).refreshTrigger })))
 );
-var updateDevicesAuth = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/updateDevicesAuth`, ({ deviceIds, status }, { dispatch, getState }) => {
-  let devices = getDevicesById(getState());
-  const deviceIdsWithoutAuth = deviceIds.reduce((accu, id) => devices[id].auth_sets ? accu : [...accu, { id }], []);
-  return dispatch(getDevicesWithAuth(deviceIdsWithoutAuth)).then(() => {
-    devices = getDevicesById(getState());
-    const deviceAuthUpdates = deviceIds.map((id) => {
-      const device = devices[id];
-      if (device.auth_sets.length !== 1) {
-        return Promise.reject();
-      }
-      return dispatch(updateDeviceAuth({ authId: device.auth_sets[0].id, deviceId: device.id, status })).unwrap().catch((err) => commonErrorHandler(err, "The action was stopped as there was a problem updating a device authorization status: ", dispatch, "", false));
-    });
-    return Promise.allSettled(deviceAuthUpdates).then((results) => {
-      const { skipped, count } = results.reduce(
-        (accu, item) => {
-          if (item.status === "rejected") {
-            accu.skipped = accu.skipped + 1;
-          } else {
-            accu.count = accu.count + 1;
-          }
-          return accu;
-        },
-        { skipped: 0, count: 0 }
-      );
-      const message = (0, import_helpers8.getSnackbarMessage)(skipped, count);
-      return dispatch(setSnackbar2(message));
+var updateDevicesAuth = createAppAsyncThunk(
+  `${sliceName3}/updateDevicesAuth`,
+  ({ deviceIds, status }, { dispatch, getState }) => {
+    let devices = getDevicesById(getState());
+    const deviceIdsWithoutAuth = deviceIds.reduce((accu, id) => devices[id].auth_sets ? accu : [...accu, { id }], []);
+    return dispatch(getDevicesWithAuth(deviceIdsWithoutAuth)).then(() => {
+      devices = getDevicesById(getState());
+      const deviceAuthUpdates = deviceIds.map((id) => {
+        const device = devices[id];
+        if (device.auth_sets && device.auth_sets.length !== 1) {
+          return Promise.reject();
+        }
+        return dispatch(updateDeviceAuth({ authId: device.auth_sets[0].id, deviceId: device.id, status })).unwrap().catch((err) => commonErrorHandler(err, "The action was stopped as there was a problem updating a device authorization status: ", dispatch, "", false));
+      });
+      return Promise.allSettled(deviceAuthUpdates).then((results) => {
+        const { skipped, count } = results.reduce(
+          (accu, item) => {
+            if (item.status === "rejected") {
+              accu.skipped = accu.skipped + 1;
+            } else {
+              accu.count = accu.count + 1;
+            }
+            return accu;
+          },
+          { skipped: 0, count: 0 }
+        );
+        const message = (0, import_helpers8.getSnackbarMessage)(skipped, count);
+        return dispatch(setSnackbar2(message));
+      });
     });
-  });
-});
-var deleteAuthset = (0, import_toolkit18.createAsyncThunk)(
+  }
+);
+var deleteAuthset = createAppAsyncThunk(
   `${sliceName3}/deleteAuthset`,
-  ({ deviceId, authId }, { dispatch, getState }) => general_api_default.delete(`${deviceAuthV2}/devices/${deviceId}/auth/${authId}`).then(() => Promise.all([dispatch(setSnackbar2("Device authorization status was updated successfully"))])).catch((err) => commonErrorHandler(err, "There was a problem updating the device authorization status:", dispatch)).then(() => Promise.resolve(dispatch(actions3.maybeUpdateDevicesByStatus({ deviceId, authId })))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getState().devices.deviceList.refreshTrigger })))
+  ({ deviceId, authId }, { dispatch, getState }) => general_api_default.delete(`${import_constants5.deviceAuthV2}/devices/${deviceId}/auth/${authId}`).then(() => Promise.all([dispatch(setSnackbar2("Device authorization status was updated successfully"))])).catch((err) => commonErrorHandler(err, "There was a problem updating the device authorization status:", dispatch)).then(() => Promise.resolve(dispatch(actions3.maybeUpdateDevicesByStatus({ deviceId, authId })))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getState().devices.deviceList.refreshTrigger })))
 );
-var preauthDevice = (0, import_toolkit18.createAsyncThunk)(
+var preauthDevice = createAppAsyncThunk(
   `${sliceName3}/preauthDevice`,
-  (authset, { dispatch, rejectWithValue }) => general_api_default.post(`${deviceAuthV2}/devices`, authset).then(() => Promise.resolve(dispatch(setSnackbar2("Device was successfully added to the preauthorization list", TIMEOUTS.fiveSeconds)))).catch((err) => {
+  (authset, { dispatch, rejectWithValue }) => general_api_default.post(`${import_constants5.deviceAuthV2}/devices`, authset).then(
+    () => Promise.resolve(dispatch(setSnackbar2({ message: "Device was successfully added to the preauthorization list", autoHideDuration: TIMEOUTS.fiveSeconds })))
+  ).catch((err) => {
     if (err.response.status === 409) {
       return rejectWithValue("A device with a matching identity data set already exists");
     }
     return commonErrorHandler(err, "The device could not be added:", dispatch);
   })
 );
-var decommissionDevice = (0, import_toolkit18.createAsyncThunk)(
+var decommissionDevice = createAppAsyncThunk(
   `${sliceName3}/decommissionDevice`,
-  ({ deviceId, authId }, { dispatch, getState }) => general_api_default.delete(`${deviceAuthV2}/devices/${deviceId}`).then(() => Promise.resolve(dispatch(setSnackbar2("Device was decommissioned successfully")))).catch((err) => commonErrorHandler(err, "There was a problem decommissioning the device:", dispatch)).then(() => Promise.resolve(dispatch(actions3.maybeUpdateDevicesByStatus({ deviceId, authId })))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getState().devices.deviceList.refreshTrigger })))
+  ({ deviceId, authId }, { dispatch, getState }) => general_api_default.delete(`${import_constants5.deviceAuthV2}/devices/${deviceId}`).then(() => Promise.resolve(dispatch(setSnackbar2("Device was decommissioned successfully")))).catch((err) => commonErrorHandler(err, "There was a problem decommissioning the device:", dispatch)).then(() => Promise.resolve(dispatch(actions3.maybeUpdateDevicesByStatus({ deviceId, authId })))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getState().devices.deviceList.refreshTrigger })))
 );
-var getDeviceConfig = (0, import_toolkit18.createAsyncThunk)(
+var getDeviceConfig = createAppAsyncThunk(
   `${sliceName3}/getDeviceConfig`,
-  (deviceId, { dispatch }) => general_api_default.get(`${deviceConfig}/${deviceId}`).then(({ data }) => Promise.all([dispatch(actions3.receivedDevice({ id: deviceId, config: data })), Promise.resolve(data)])).catch((err) => {
+  (deviceId, { dispatch }) => general_api_default.get(`${import_constants5.deviceConfig}/${deviceId}`).then(({ data }) => Promise.all([dispatch(actions3.receivedDevice({ id: deviceId, config: data })), Promise.resolve(data)])).catch((err) => {
     if (err.response?.data?.error.status_code !== 404) {
       return commonErrorHandler(err, `There was an error retrieving the configuration for device ${deviceId}.`, dispatch, commonErrorFallback);
     }
   })
 );
-var setDeviceConfig = (0, import_toolkit18.createAsyncThunk)(
+var setDeviceConfig = createAppAsyncThunk(
   `${sliceName3}/setDeviceConfig`,
-  ({ deviceId, config }, { dispatch }) => general_api_default.put(`${deviceConfig}/${deviceId}`, config).catch((err) => commonErrorHandler(err, `There was an error setting the configuration for device ${deviceId}.`, dispatch, commonErrorFallback)).then(() => Promise.resolve(dispatch(getDeviceConfig(deviceId))))
+  ({ deviceId, config }, { dispatch }) => general_api_default.put(`${import_constants5.deviceConfig}/${deviceId}`, config).catch((err) => commonErrorHandler(err, `There was an error setting the configuration for device ${deviceId}.`, dispatch, commonErrorFallback)).then(() => Promise.resolve(dispatch(getDeviceConfig(deviceId))))
 );
-var applyDeviceConfig = (0, import_toolkit18.createAsyncThunk)(
+var applyDeviceConfig = createAppAsyncThunk(
   `${sliceName3}/applyDeviceConfig`,
-  ({ deviceId, configDeploymentConfiguration, isDefault, config }, { dispatch, getState }) => general_api_default.post(`${deviceConfig}/${deviceId}/deploy`, configDeploymentConfiguration).catch((err) => commonErrorHandler(err, `There was an error deploying the configuration to device ${deviceId}.`, dispatch, commonErrorFallback)).then(({ data }) => {
+  ({ deviceId, configDeploymentConfiguration, isDefault, config }, { dispatch, getState }) => general_api_default.post(`${import_constants5.deviceConfig}/${deviceId}/deploy`, configDeploymentConfiguration).catch((err) => commonErrorHandler(err, `There was an error deploying the configuration to device ${deviceId}.`, dispatch, commonErrorFallback)).then(({ data }) => {
     const device = getDeviceById(getState(), deviceId);
     const { canManageUsers } = getUserCapabilities(getState());
-    let tasks = [
+    const tasks = [
       dispatch(actions3.receivedDevice({ ...device, config: { ...device.config, deployment_id: data.deployment_id } })),
       new Promise((resolve) => setTimeout(() => resolve(dispatch(getSingleDeployment(data.deployment_id))), TIMEOUTS.oneSecond))
     ];
@@ -3537,23 +3289,26 @@ var applyDeviceConfig = (0, import_toolkit18.createAsyncThunk)(
     return Promise.all(tasks);
   })
 );
-var setDeviceTags = (0, import_toolkit18.createAsyncThunk)(
+var setDeviceTags = createAppAsyncThunk(
   `${sliceName3}/setDeviceTags`,
   ({ deviceId, tags }, { dispatch }) => (
     // to prevent tag set failures, retrieve the device & use the freshest etag we can get
-    Promise.resolve(dispatch(getDeviceById2(deviceId))).then((device) => {
+    dispatch(getDeviceById2(deviceId)).unwrap().then((device) => {
       const headers = device.etag ? { "If-Match": device.etag } : {};
-      return general_api_default.put(
-        `${inventoryApiUrl}/devices/${deviceId}/tags`,
-        Object.entries(tags).map(([name, value]) => ({ name, value })),
-        { headers }
-      ).catch((err) => commonErrorHandler(err, `There was an error setting tags for device ${deviceId}.`, dispatch, "Please check your connection.")).then(() => Promise.all([dispatch(actions3.receivedDevice({ ...device, id: deviceId, tags })), dispatch(setSnackbar2("Device name changed"))]));
+      const tagList = Object.entries(tags).map(([name, value]) => ({ name, value }));
+      const isNameChange = tagList.some(({ name }) => name === "name");
+      return general_api_default.put(`${import_constants5.inventoryApiUrl}/devices/${deviceId}/tags`, tagList, { headers }).catch((err) => commonErrorHandler(err, `There was an error setting tags for device ${deviceId}.`, dispatch, "Please check your connection.")).then(
+        () => Promise.all([
+          dispatch(actions3.receivedDevice({ ...device, id: deviceId, tags })),
+          dispatch(setSnackbar2(`Device ${tagList.length === 1 && isNameChange ? "name" : "tags"} changed`))
+        ])
+      );
     })
   )
 );
-var getDeviceTwin = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getDeviceTwin`, ({ deviceId, integration }, { dispatch, getState }) => {
+var getDeviceTwin = createAppAsyncThunk(`${sliceName3}/getDeviceTwin`, ({ deviceId, integration }, { dispatch, getState }) => {
   let providerResult = {};
-  return general_api_default.get(`${iotManagerBaseURL}/devices/${deviceId}/state`).then(({ data }) => {
+  return general_api_default.get(`${import_constants5.iotManagerBaseURL}/devices/${deviceId}/state`).then(({ data }) => {
     providerResult = { ...data, twinError: "" };
   }).catch((err) => {
     providerResult = {
@@ -3564,9 +3319,9 @@ var getDeviceTwin = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getDev
     Promise.resolve(dispatch(actions3.receivedDevice({ ...device, twinsByIntegration: { ...device.twinsByIntegration, ...providerResult } })));
   });
 });
-var setDeviceTwin = (0, import_toolkit18.createAsyncThunk)(
+var setDeviceTwin = createAppAsyncThunk(
   `${sliceName3}/setDeviceTwin`,
-  ({ deviceId, integration, settings }, { dispatch, getState }) => general_api_default.put(`${iotManagerBaseURL}/devices/${deviceId}/state/${integration.id}`, { desired: settings }).catch(
+  ({ deviceId, integration, settings }, { dispatch, getState }) => general_api_default.put(`${import_constants5.iotManagerBaseURL}/devices/${deviceId}/state/${integration.id}`, { desired: settings }).catch(
     (err) => commonErrorHandler(
       err,
       `There was an error updating the ${EXTERNAL_PROVIDER[integration.provider].twinTitle.toLowerCase()} for device ${deviceId}.`,
@@ -3577,7 +3332,9 @@ var setDeviceTwin = (0, import_toolkit18.createAsyncThunk)(
     const { twinsByIntegration = {} } = device;
     const { [integration.id]: currentState = {} } = twinsByIntegration;
     return Promise.resolve(
-      dispatch(actions3.receivedDevice({ ...device, twinsByIntegration: { ...twinsByIntegration, [integration.id]: { ...currentState, desired: settings } } }))
+      dispatch(
+        actions3.receivedDevice({ ...device, twinsByIntegration: { ...twinsByIntegration, [integration.id]: { ...currentState, desired: settings } } })
+      )
     );
   })
 );
@@ -3588,7 +3345,7 @@ var prepareSearchArguments = ({ filters, group, state, status }) => {
   const attributes = [...defaultAttributes, getIdAttribute(state), ...selectedAttributes];
   return { attributes, filterTerms };
 };
-var getSystemDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getSystemDevices`, (options, { dispatch, getState }) => {
+var getSystemDevices = createAppAsyncThunk(`${sliceName3}/getSystemDevices`, (options, { dispatch, getState }) => {
   const { id, page = defaultPage, perPage = defaultPerPage, sortOptions = [] } = options;
   const state = getState();
   const { hasFullFiltering } = getTenantCapabilities(state);
@@ -3598,7 +3355,7 @@ var getSystemDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/get
   const { attributes: deviceAttributes = {} } = getDeviceById(state, id);
   const { mender_gateway_system_id = "" } = deviceAttributes;
   const filters = [
-    { ...emptyFilter, key: "mender_is_gateway", operator: DEVICE_FILTERING_OPTIONS.$ne.key, value: "true", scope: "inventory" },
+    { ...emptyFilter, key: "mender_is_gateway", operator: import_constants5.DEVICE_FILTERING_OPTIONS.$ne.key, value: "true", scope: "inventory" },
     { ...emptyFilter, key: "mender_gateway_system_id", value: mender_gateway_system_id, scope: "inventory" }
   ];
   const { attributes, filterTerms } = prepareSearchArguments({ filters, state });
@@ -3614,17 +3371,17 @@ var getSystemDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/get
     const device = {
       ...getDeviceById(state2, id),
       systemDeviceIds: ids,
-      systemDeviceTotal: Number(headers[headerNames.total])
+      systemDeviceTotal: Number(headers[import_constants5.headerNames.total])
     };
     return Promise.resolve(dispatch(actions3.receivedDevices({ ...devicesById, [id]: device })));
   });
 });
-var getGatewayDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getGatewayDevices`, (deviceId, { dispatch, getState }) => {
+var getGatewayDevices = createAppAsyncThunk(`${sliceName3}/getGatewayDevices`, (deviceId, { dispatch, getState }) => {
   const state = getState();
   const { attributes = {} } = getDeviceById(state, deviceId);
   const { mender_gateway_system_id = "" } = attributes;
   const filters = [
-    { ...emptyFilter, key: "id", operator: DEVICE_FILTERING_OPTIONS.$ne.key, value: deviceId, scope: "identity" },
+    { ...emptyFilter, key: "id", operator: import_constants5.DEVICE_FILTERING_OPTIONS.$ne.key, value: deviceId, scope: "identity" },
     { ...emptyFilter, key: "mender_is_gateway", value: "true", scope: "inventory" },
     { ...emptyFilter, key: "mender_gateway_system_id", value: mender_gateway_system_id, scope: "inventory" }
   ];
@@ -3636,100 +3393,87 @@ var getGatewayDevices = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/ge
     attributes: attributeSelection
   }).then(({ data }) => {
     const { ids } = reduceReceivedDevices(data, [], getState());
-    let tasks = ids.map((deviceId2) => dispatch(getDeviceInfo(deviceId2)));
+    const tasks = ids.map((deviceId2) => dispatch(getDeviceInfo(deviceId2)));
     tasks.push(dispatch(actions3.receivedDevice({ id: deviceId, gatewayIds: ids })));
     return Promise.all(tasks);
   });
 });
-var getDevicesInBounds = (0, import_toolkit18.createAsyncThunk)(`${sliceName3}/getDevicesInBounds`, ({ bounds, group }, { dispatch, getState }) => {
-  const state = getState();
-  const { filterTerms } = convertDeviceListStateToFilters({
-    group: group === ALL_DEVICES ? void 0 : group,
-    groups: state.devices.groups,
-    status: DEVICE_STATES.accepted
-  });
-  return general_api_default.post(getSearchEndpoint(getState()), {
-    page: 1,
-    per_page: MAX_PAGE_SIZE,
-    filters: filterTerms,
-    attributes: geoAttributes,
-    geo_bounding_box_filter: {
-      geo_bounding_box: {
-        location: {
-          top_left: { lat: bounds._northEast.lat, lon: bounds._southWest.lng },
-          bottom_right: { lat: bounds._southWest.lat, lon: bounds._northEast.lng }
-        }
-      }
-    }
-  }).then(({ data }) => {
-    const { devicesById } = reduceReceivedDevices(data, [], getState());
-    return Promise.resolve(dispatch(actions3.receivedDevices(devicesById)));
-  });
-});
 
 // src/monitorSlice/thunks.ts
-var import_toolkit19 = require("@reduxjs/toolkit");
-var { page: defaultPage2, perPage: defaultPerPage2 } = DEVICE_LIST_DEFAULTS;
+var { page: defaultPage2, perPage: defaultPerPage2 } = import_constants5.DEVICE_LIST_DEFAULTS;
 var cutoffLength = 75;
 var ellipsis = "...";
 var longTextTrimmer = (text) => text.length >= cutoffLength + ellipsis.length ? `${text.substring(0, cutoffLength + ellipsis.length)}${ellipsis}` : text;
-var sanitizeDeviceAlerts = (alerts) => alerts.map((alert) => ({ ...alert, fullName: alert.name, name: longTextTrimmer(alert.name) }));
-var getDeviceAlerts = (0, import_toolkit19.createAsyncThunk)(`${sliceName4}/getDeviceAlerts`, ({ id, config = {} }, { dispatch }) => {
+var sanitizeDeviceAlerts = (alerts) => alerts.map((alert) => ({ ...alert, fullName: alert.name, name: longTextTrimmer(alert.name || "") }));
+var getDeviceAlerts = createAppAsyncThunk(`${sliceName4}/getDeviceAlerts`, ({ id, config = {} }, { dispatch }) => {
   const { page = defaultPage2, perPage = defaultPerPage2, issuedBefore, issuedAfter, sortAscending = false } = config;
   const issued_after = issuedAfter ? `&issued_after=${issuedAfter}` : "";
   const issued_before = issuedBefore ? `&issued_before=${issuedBefore}` : "";
-  return general_api_default.get(`${monitorApiUrlv1}/devices/${id}/alerts?page=${page}&per_page=${perPage}${issued_after}${issued_before}&sort_ascending=${sortAscending}`).catch((err) => commonErrorHandler(err, `Retrieving device alerts for device ${id} failed:`, dispatch)).then(
+  return general_api_default.get(
+    `${import_constants5.monitorApiUrlv1}/devices/${id}/alerts?page=${page}&per_page=${perPage}${issued_after}${issued_before}&sort_ascending=${sortAscending}`
+  ).catch((err) => commonErrorHandler(err, `Retrieving device alerts for device ${id} failed:`, dispatch)).then(
     (res) => Promise.all([
       dispatch(actions4.receiveDeviceAlerts({ deviceId: id, alerts: sanitizeDeviceAlerts(res.data) })),
-      dispatch(actions4.setAlertListState({ total: Number(res.headers[headerNames.total]) }))
+      dispatch(actions4.setAlertListState({ total: Number(res.headers[import_constants5.headerNames.total]) }))
     ])
   );
 });
-var getLatestDeviceAlerts = (0, import_toolkit19.createAsyncThunk)(`${sliceName4}/getLatestDeviceAlerts`, ({ id, config = {} }, { dispatch }) => {
-  const { page = defaultPage2, perPage = 10 } = config;
-  return general_api_default.get(`${monitorApiUrlv1}/devices/${id}/alerts/latest?page=${page}&per_page=${perPage}`).catch((err) => commonErrorHandler(err, `Retrieving device alerts for device ${id} failed:`, dispatch)).then((res) => Promise.resolve(dispatch(actions4.receiveLatestDeviceAlerts({ deviceId: id, alerts: sanitizeDeviceAlerts(res.data) }))));
-});
-var getIssueCountsByType2 = (0, import_toolkit19.createAsyncThunk)(`${sliceName4}/getIssueCountsByType`, ({ type, options = {} }, { dispatch, getState }) => {
-  const state = getState();
-  const { filters = getDeviceFilters(state), group, status, ...remainder } = options;
-  const { applicableFilters: nonMonitorFilters, filterTerms } = convertDeviceListStateToFilters({
-    ...remainder,
-    filters,
-    group,
-    offlineThreshold: state.app.offlineThreshold,
-    selectedIssues: [type],
-    status
-  });
-  return general_api_default.post(getSearchEndpoint(getState()), {
-    page: 1,
-    per_page: 1,
-    filters: filterTerms,
-    attributes: [{ scope: "identity", attribute: "status" }]
-  }).catch((err) => commonErrorHandler(err, `Retrieving issue counts failed:`, dispatch, commonErrorFallback)).then((res) => {
-    const total = nonMonitorFilters.length ? state.monitor.issueCounts.byType[type].total : Number(res.headers[headerNames.total]);
-    const filtered = nonMonitorFilters.length ? Number(res.headers[headerNames.total]) : total;
-    if (total === state.monitor.issueCounts.byType[type].total && filtered === state.monitor.issueCounts.byType[type].filtered) {
-      return Promise.resolve();
-    }
-    return Promise.resolve(dispatch(actions4.receiveDeviceIssueCounts({ counts: { filtered, total }, issueType: type })));
-  });
-});
-var getDeviceMonitorConfig = (0, import_toolkit19.createAsyncThunk)(
+var getLatestDeviceAlerts = createAppAsyncThunk(
+  `${sliceName4}/getLatestDeviceAlerts`,
+  ({ id, config = {} }, { dispatch }) => {
+    const { page = defaultPage2, perPage = 10 } = config;
+    return general_api_default.get(`${import_constants5.monitorApiUrlv1}/devices/${id}/alerts/latest?page=${page}&per_page=${perPage}`).catch((err) => commonErrorHandler(err, `Retrieving device alerts for device ${id} failed:`, dispatch)).then((res) => Promise.resolve(dispatch(actions4.receiveLatestDeviceAlerts({ deviceId: id, alerts: sanitizeDeviceAlerts(res.data) }))));
+  }
+);
+var getIssueCountsByType2 = createAppAsyncThunk(
+  `${sliceName4}/getIssueCountsByType`,
+  ({ type, options = {} }, { dispatch, getState }) => {
+    const state = getState();
+    const { filters = getDeviceFilters(state), group, status, ...remainder } = options;
+    const { applicableFilters: nonMonitorFilters, filterTerms } = convertDeviceListStateToFilters({
+      ...remainder,
+      filters,
+      group,
+      offlineThreshold: state.app.offlineThreshold,
+      selectedIssues: [type],
+      status
+    });
+    return general_api_default.post(getSearchEndpoint(getState()), {
+      page: 1,
+      per_page: 1,
+      filters: filterTerms,
+      attributes: [{ scope: "identity", attribute: "status" }]
+    }).catch((err) => commonErrorHandler(err, `Retrieving issue counts failed:`, dispatch, commonErrorFallback)).then((res) => {
+      const total = nonMonitorFilters.length ? state.monitor.issueCounts.byType[type].total : Number(res.headers[import_constants5.headerNames.total]);
+      const filtered = nonMonitorFilters.length ? Number(res.headers[import_constants5.headerNames.total]) : total;
+      if (total === state.monitor.issueCounts.byType[type].total && filtered === state.monitor.issueCounts.byType[type].filtered) {
+        return Promise.resolve();
+      }
+      return Promise.resolve(dispatch(actions4.receiveDeviceIssueCounts({ counts: { filtered, total }, issueType: type })));
+    });
+  }
+);
+var getDeviceMonitorConfig = createAppAsyncThunk(
   `${sliceName4}/getDeviceMonitorConfig`,
-  (id, { dispatch }) => general_api_default.get(`${monitorApiUrlv1}/devices/${id}/config`).catch((err) => commonErrorHandler(err, `Retrieving device monitor config for device ${id} failed:`, dispatch)).then(({ data }) => Promise.all([dispatch(actions_default.receivedDevice({ id, monitors: data }), Promise.resolve(data))]))
+  (id, { dispatch }) => general_api_default.get(`${import_constants5.monitorApiUrlv1}/devices/${id}/config`).catch((err) => commonErrorHandler(err, `Retrieving device monitor config for device ${id} failed:`, dispatch)).then(({ data }) => Promise.all([dispatch(actions_default.receivedDevice({ id, monitors: data }), Promise.resolve(data))]))
 );
-var changeNotificationSetting = (0, import_toolkit19.createAsyncThunk)(
+var changeNotificationSetting = createAppAsyncThunk(
   `${sliceName4}/changeNotificationSetting`,
-  ({ enabled, channel = alertChannels.email }, { dispatch }) => general_api_default.put(`${monitorApiUrlv1}/settings/global/channel/alerts/${channel}/status`, { enabled }).catch((err) => commonErrorHandler(err, `${enabled ? "En" : "Dis"}abling  ${channel} alerts failed:`, dispatch)).then(
+  ({ enabled, channel = import_constants5.alertChannels.email }, { dispatch }) => general_api_default.put(`${import_constants5.monitorApiUrlv1}/settings/global/channel/alerts/${channel}/status`, { enabled }).catch((err) => commonErrorHandler(err, `${enabled ? "En" : "Dis"}abling  ${channel} alerts failed:`, dispatch)).then(
     () => Promise.all([
       dispatch(actions4.changeAlertChannel({ channel, enabled })),
-      dispatch(actions_default.setSnackbar(`Successfully ${enabled ? "en" : "dis"}abled ${channel} alerts`, TIMEOUTS.fiveSeconds))
+      dispatch(
+        actions_default.setSnackbar({ message: `Successfully ${enabled ? "en" : "dis"}abled ${channel} alerts`, autoHideDuration: TIMEOUTS.fiveSeconds })
+      )
     ])
   )
 );
 
 // src/usersSlice/thunks.ts
-var import_helptips = require("@northern.tech/common-ui/helptips");
+var import_helpers9 = require("@northern.tech/utils/helpers");
+var import_retrytimer = require("@northern.tech/utils/retrytimer");
+var import_md5 = __toESM(require("md5"), 1);
+var import_universal_cookie3 = __toESM(require("universal-cookie"), 1);
 
 // src/api/users-api.ts
 var import_axios3 = __toESM(require("axios"), 1);
@@ -3746,14 +3490,9 @@ var Api2 = {
 var users_api_default = Api2;
 
 // src/usersSlice/thunks.ts
-var import_helpers9 = require("@northern.tech/utils/helpers");
-var import_retrytimer = require("@northern.tech/utils/retrytimer");
-var import_toolkit20 = require("@reduxjs/toolkit");
-var import_md5 = __toESM(require("md5"), 1);
-var import_universal_cookie3 = __toESM(require("universal-cookie"), 1);
 var cookies3 = new import_universal_cookie3.default();
 var { setAnnouncement, setSnackbar: setSnackbar3 } = actions_default;
-var handleLoginError = (err, { token2fa: has2FA, password }, rejectWithValue) => (dispatch) => {
+var handleLoginError = (err, { token2fa: has2FA, password }, rejectWithValue) => () => {
   const errorText = (0, import_helpers9.extractErrorMessage)(err);
   const is2FABackend = errorText.includes("2fa");
   if (is2FABackend && !has2FA) {
@@ -3764,27 +3503,26 @@ var handleLoginError = (err, { token2fa: has2FA, password }, rejectWithValue) =>
   }
   const twoFAError = is2FABackend ? " and verification code" : "";
   const errorMessage = `There was a problem logging in. Please check your email${twoFAError ? "," : " and"} password${twoFAError}. If you still have problems, contact an administrator.`;
-  return Promise.reject(dispatch(setSnackbar3({ message: (0, import_helpers9.preformatWithRequestID)(err.response, errorMessage), action: "Copy to clipboard" })));
+  return rejectWithValue({ error: errorMessage });
 };
-var loginUser = (0, import_toolkit20.createAsyncThunk)(
+var loginUser = createAppAsyncThunk(
   `${sliceName8}/loginUser`,
-  ({ stayLoggedIn, ...userData }, { dispatch, rejectWithValue }) => users_api_default.postLogin(`${useradmApiUrlv1}/auth/login`, { ...userData, no_expiry: stayLoggedIn }).catch((err) => {
+  ({ stayLoggedIn, ...userData }, { dispatch, rejectWithValue }) => users_api_default.postLogin(`${import_constants5.useradmApiUrl}/auth/login`, { ...userData, no_expiry: stayLoggedIn }).catch((err) => {
     cleanUp();
     return Promise.reject(dispatch(handleLoginError(err, userData, rejectWithValue)));
-  }).then(({ text: response, contentType }) => {
-    if (contentType.includes(APPLICATION_JSON_CONTENT_TYPE)) {
-      const { id, kind } = response;
+  }).then(({ text: token, contentType }) => {
+    if (contentType.includes(import_constants5.APPLICATION_JSON_CONTENT_TYPE)) {
+      const { id, kind } = token;
       const type = kind.split("/")[1];
       const ssoLoginUrl = SSO_TYPES[type].getStartUrl(id);
       window.location.replace(ssoLoginUrl);
       return;
     }
-    const token = response;
-    if (contentType !== APPLICATION_JWT_CONTENT_TYPE || !token) {
+    if (contentType !== import_constants5.APPLICATION_JWT_CONTENT_TYPE || !token) {
       return;
     }
-    let now = /* @__PURE__ */ new Date();
-    now.setSeconds(now.getSeconds() + maxSessionAge);
+    const now = /* @__PURE__ */ new Date();
+    now.setSeconds(now.getSeconds() + import_constants5.maxSessionAge);
     const expiresAt = stayLoggedIn ? void 0 : now.toISOString();
     setSessionInfo({ token, expiresAt });
     cookies3.remove("JWT", { path: "/" });
@@ -3800,35 +3538,35 @@ var loginUser = (0, import_toolkit20.createAsyncThunk)(
     });
   })
 );
-var logoutUser = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/logoutUser`, (_, { dispatch, getState }) => {
+var logoutUser = createAppAsyncThunk(`${sliceName8}/logoutUser`, (_, { dispatch, getState }) => {
   if (Object.keys(getState().app.uploadsById).length) {
     return Promise.reject();
   }
-  return general_api_default.post(`${useradmApiUrlv1}/auth/logout`).finally(() => {
+  return general_api_default.post(`${import_constants5.useradmApiUrl}/auth/logout`).finally(() => {
     cleanUp();
     (0, import_retrytimer.clearAllRetryTimers)(setSnackbar3);
     return Promise.resolve(dispatch({ type: USER_LOGOUT }));
   });
 });
-var switchUserOrganization = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/switchUserOrganization`, (tenantId, { getState }) => {
+var switchUserOrganization = createAppAsyncThunk(`${sliceName8}/switchUserOrganization`, (tenantId, { getState }) => {
   if (Object.keys(getState().app.uploadsById).length) {
     return Promise.reject();
   }
-  return general_api_default.get(`${useradmApiUrlv1}/users/tenants/${tenantId}/token`).then(({ data: token }) => {
+  return general_api_default.get(`${import_constants5.useradmApiUrl}/users/tenants/${tenantId}/token`).then(({ data: token }) => {
     window.sessionStorage.setItem("tenantChanged", "true");
     setSessionInfo({ ...getSessionInfo(), token });
     window.location.reload();
   });
 });
-var passwordResetStart = (0, import_toolkit20.createAsyncThunk)(
+var passwordResetStart = createAppAsyncThunk(
   `${sliceName8}/passwordResetStart`,
-  (email, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/auth/password-reset/start`, { email }).catch(
+  (email, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/auth/password-reset/start`, { email }).catch(
     (err) => commonErrorHandler(err, `The password reset request cannot be processed:`, dispatch, void 0, true)
   )
 );
-var passwordResetComplete = (0, import_toolkit20.createAsyncThunk)(
+var passwordResetComplete = createAppAsyncThunk(
   `${sliceName8}/passwordResetComplete`,
-  ({ secretHash, newPassword }, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/auth/password-reset/complete`, { secret_hash: secretHash, password: newPassword }).catch((err = {}) => {
+  ({ secretHash, newPassword }, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/auth/password-reset/complete`, { secret_hash: secretHash, password: newPassword }).catch((err = {}) => {
     const { error, response = {} } = err;
     let errorMsg = "";
     if (response.status == 400) {
@@ -3840,23 +3578,23 @@ var passwordResetComplete = (0, import_toolkit20.createAsyncThunk)(
     return Promise.reject(err);
   })
 );
-var verifyEmailStart = (0, import_toolkit20.createAsyncThunk)(
+var verifyEmailStart = createAppAsyncThunk(
   `${sliceName8}/verifyEmailStart`,
-  (_, { dispatch, getState }) => general_api_default.post(`${useradmApiUrlv1}/auth/verify-email/start`, { email: getCurrentUser(getState()).email }).catch((err) => commonErrorHandler(err, "An error occured starting the email verification process:", dispatch)).finally(() => Promise.resolve(dispatch(getUser(OWN_USER_ID))))
+  (_, { dispatch, getState }) => general_api_default.post(`${import_constants5.useradmApiUrl}/auth/verify-email/start`, { email: getCurrentUser(getState()).email }).catch((err) => commonErrorHandler(err, "An error occured starting the email verification process:", dispatch)).finally(() => Promise.resolve(dispatch(getUser(OWN_USER_ID))))
 );
-var verifyEmailComplete = (0, import_toolkit20.createAsyncThunk)(
+var verifyEmailComplete = createAppAsyncThunk(
   `${sliceName8}/verifyEmailComplete`,
-  (secret_hash, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/auth/verify-email/complete`, { secret_hash }).catch((err) => commonErrorHandler(err, "An error occured completing the email verification process:", dispatch)).finally(() => Promise.resolve(dispatch(getUser(OWN_USER_ID))))
+  (secret_hash, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/auth/verify-email/complete`, { secret_hash }).catch((err) => commonErrorHandler(err, "An error occured completing the email verification process:", dispatch)).finally(() => Promise.resolve(dispatch(getUser(OWN_USER_ID))))
 );
-var verify2FA = (0, import_toolkit20.createAsyncThunk)(
+var verify2FA = createAppAsyncThunk(
   `${sliceName8}/verify2FA`,
-  (tfaData, { dispatch }) => users_api_default.putVerifyTFA(`${useradmApiUrlv1}/2faverify`, tfaData).then(() => Promise.resolve(dispatch(getUser(OWN_USER_ID)))).catch(
+  (tfaData, { dispatch }) => users_api_default.putVerifyTFA(`${import_constants5.useradmApiUrl}/2faverify`, tfaData).then(() => Promise.resolve(dispatch(getUser(OWN_USER_ID)))).catch(
     (err) => commonErrorHandler(err, "An error occured validating the verification code: failed to verify token, please try again.", dispatch, void 0, true)
   )
 );
-var getUserList = (0, import_toolkit20.createAsyncThunk)(
+var getUserList = createAppAsyncThunk(
   `${sliceName8}/getUserList`,
-  (_, { dispatch, getState }) => general_api_default.get(`${useradmApiUrlv1}/users`).then((res) => {
+  (_, { dispatch, getState }) => general_api_default.get(`${import_constants5.useradmApiUrl}/users`).then((res) => {
     const currentUsersById = getUsersById(getState());
     const users = res.data.reduce(
       (accu, item) => {
@@ -3871,9 +3609,9 @@ var getUserList = (0, import_toolkit20.createAsyncThunk)(
     return dispatch(actions8.receivedUserList(users));
   }).catch((err) => commonErrorHandler(err, `Users couldn't be loaded.`, dispatch, commonErrorFallback))
 );
-var getUser = (0, import_toolkit20.createAsyncThunk)(
+var getUser = createAppAsyncThunk(
   `${sliceName8}/getUser`,
-  (id, { dispatch, rejectWithValue }) => general_api_default.get(`${useradmApiUrlv1}/users/${id}`).then(
+  (id, { dispatch, rejectWithValue }) => general_api_default.get(`${import_constants5.useradmApiUrl}/users/${id}`).then(
     ({ data: user }) => Promise.all([
       dispatch(actions8.receivedUser(user)),
       dispatch(setHideAnnouncement({ shouldHide: false, userId: user.id })),
@@ -3882,22 +3620,25 @@ var getUser = (0, import_toolkit20.createAsyncThunk)(
     ])
   ).catch((e) => rejectWithValue(e))
 );
-var initializeSelf = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/initializeSelf`, (_, { dispatch }) => dispatch(getUser(OWN_USER_ID)));
-var updateUserColumnSettings = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/updateUserColumnSettings`, ({ columns, currentUserId }, { dispatch, getState }) => {
-  const userId = currentUserId ?? getCurrentUser(getState()).id;
-  const storageKey = `${userId}-column-widths`;
-  let customColumns = [];
-  if (!columns) {
-    try {
-      customColumns = JSON.parse(window.localStorage.getItem(storageKey)) || customColumns;
-    } catch {
+var initializeSelf = createAppAsyncThunk(`${sliceName8}/initializeSelf`, (_, { dispatch }) => dispatch(getUser(OWN_USER_ID)));
+var updateUserColumnSettings = createAppAsyncThunk(
+  `${sliceName8}/updateUserColumnSettings`,
+  ({ columns, currentUserId }, { dispatch, getState }) => {
+    const userId = currentUserId ?? getCurrentUser(getState()).id;
+    const storageKey = `${userId}-column-widths`;
+    let customColumns = [];
+    if (!columns) {
+      try {
+        customColumns = JSON.parse(window.localStorage.getItem(storageKey) || "") || customColumns;
+      } catch {
+      }
+    } else {
+      customColumns = columns;
     }
-  } else {
-    customColumns = columns;
+    window.localStorage.setItem(storageKey, JSON.stringify(customColumns));
+    return Promise.resolve(dispatch(actions8.setCustomColumns(customColumns)));
   }
-  window.localStorage.setItem(storageKey, JSON.stringify(customColumns));
-  return Promise.resolve(dispatch(actions8.setCustomColumns(customColumns)));
-});
+);
 var userActions = {
   add: {
     successMessage: "The user was added successfully.",
@@ -3917,44 +3658,48 @@ var userActions = {
   }
 };
 var userActionErrorHandler = (err, type, dispatch) => commonErrorHandler(err, `There was an error ${userActions[type].errorMessage} the user.`, dispatch);
-var createUser = (0, import_toolkit20.createAsyncThunk)(
+var createUser = createAppAsyncThunk(
   `${sliceName8}/createUser`,
-  ({ shouldResetPassword, ...userData }, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/users`, { ...userData, send_reset_password: shouldResetPassword }).then(() => Promise.all([dispatch(actions8.createdUser(userData)), dispatch(getUserList()), dispatch(setSnackbar3(userActions.create.successMessage))])).catch((err) => userActionErrorHandler(err, "create", dispatch))
+  ({ shouldResetPassword, ...userData }, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/users`, { ...userData, send_reset_password: shouldResetPassword }).then(() => Promise.all([dispatch(getUserList()), dispatch(setSnackbar3(userActions.create.successMessage))])).catch((err) => userActionErrorHandler(err, "create", dispatch))
 );
-var removeUser = (0, import_toolkit20.createAsyncThunk)(
+var removeUser = createAppAsyncThunk(
   `${sliceName8}/removeUser`,
-  (userId, { dispatch }) => general_api_default.delete(`${useradmApiUrlv1}/users/${userId}`).then(() => Promise.all([dispatch(actions8.removedUser(userId)), dispatch(getUserList()), dispatch(setSnackbar3(userActions.remove.successMessage))])).catch((err) => userActionErrorHandler(err, "remove", dispatch))
+  (userId, { dispatch }) => general_api_default.delete(`${import_constants5.useradmApiUrl}/users/${userId}`).then(() => Promise.all([dispatch(actions8.removedUser(userId)), dispatch(getUserList()), dispatch(setSnackbar3(userActions.remove.successMessage))])).catch((err) => userActionErrorHandler(err, "remove", dispatch))
 );
-var editUser = (0, import_toolkit20.createAsyncThunk)(
+var editUser = createAppAsyncThunk(
   `${sliceName8}/editUser`,
-  ({ id, ...userData }, { dispatch, getState }) => general_api_default.put(`${useradmApiUrlv1}/users/${id}`, userData).then(
+  ({ id, ...userData }, { dispatch, getState }) => general_api_default.put(`${import_constants5.useradmApiUrl}/users/${id}`, userData).then(
     () => Promise.all([
       dispatch(actions8.updatedUser({ ...userData, id: id === OWN_USER_ID ? getCurrentUser(getState()).id : id })),
       dispatch(setSnackbar3(userActions.edit.successMessage))
     ])
-  )
+  ).catch((err) => userActionErrorHandler(err, "edit", dispatch))
 );
-var addUserToCurrentTenant = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/addUserToTenant`, (userId, { dispatch, getState }) => {
+var checkEmailExists = createAppAsyncThunk(`${sliceName8}/checkEmailExists`, async (email) => {
+  const response = await general_api_default.get(`${import_constants5.useradmApiUrl}/users/exists?email=${encodeURIComponent(email)}`);
+  return response.data.exists;
+});
+var addUserToCurrentTenant = createAppAsyncThunk(`${sliceName8}/addUserToTenant`, (userId, { dispatch, getState }) => {
   const { id } = getOrganization(getState());
-  return general_api_default.post(`${useradmApiUrlv1}/users/${userId}/assign`, { tenant_ids: [id] }).catch((err) => commonErrorHandler(err, `There was an error adding the user to your organization:`, dispatch)).then(() => Promise.all([dispatch(setSnackbar3(userActions.add.successMessage)), dispatch(getUserList())]));
+  return general_api_default.post(`${import_constants5.useradmApiUrl}/users/${userId}/assign`, { tenant_ids: [id] }).catch((err) => commonErrorHandler(err, `There was an error adding the user to your organization:`, dispatch)).then(() => Promise.all([dispatch(setSnackbar3(userActions.add.successMessage)), dispatch(getUserList())]));
 });
-var enableUser2fa = (0, import_toolkit20.createAsyncThunk)(
+var enableUser2fa = createAppAsyncThunk(
   `${sliceName8}/enableUser2fa`,
-  (userId = OWN_USER_ID, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/users/${userId}/2fa/enable`).catch((err) => commonErrorHandler(err, `There was an error enabling Two Factor authentication for the user.`, dispatch)).then(() => Promise.resolve(dispatch(getUser(userId))))
+  (userId = OWN_USER_ID, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/users/${userId}/2fa/enable`).catch((err) => commonErrorHandler(err, `There was an error enabling Two Factor authentication for the user.`, dispatch)).then(() => Promise.resolve(dispatch(getUser(userId))))
 );
-var disableUser2fa = (0, import_toolkit20.createAsyncThunk)(
+var disableUser2fa = createAppAsyncThunk(
   `${sliceName8}/disableUser2fa`,
-  (userId = OWN_USER_ID, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/users/${userId}/2fa/disable`).catch((err) => commonErrorHandler(err, `There was an error disabling Two Factor authentication for the user.`, dispatch)).then(() => Promise.all([dispatch(getUser(userId)), dispatch(actions8.receivedQrCode(null))]))
+  (userId = OWN_USER_ID, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/users/${userId}/2fa/disable`).catch((err) => commonErrorHandler(err, `There was an error disabling Two Factor authentication for the user.`, dispatch)).then(() => Promise.all([dispatch(getUser(userId)), dispatch(actions8.receivedQrCode(null))]))
 );
-var mapHttpPermission = (permission) => Object.entries(uiPermissionsByArea).reduce(
+var mapHttpPermission = (permission) => Object.entries(import_constants5.uiPermissionsByArea).reduce(
   (accu, [area, definition]) => {
     const endpointMatches = definition.endpoints.filter(
-      (endpoint) => endpoint.path.test(permission.value) && (endpoint.types.includes(permission.type) || permission.type === PermissionTypes.Any)
+      (endpoint) => endpoint.path.test(permission.value) && (endpoint.types.includes(permission.type) || permission.type === import_constants5.PermissionTypes.Any)
     );
-    if (permission.value === PermissionTypes.Any || permission.value.includes(apiRoot) && endpointMatches.length) {
+    if (permission.value === import_constants5.PermissionTypes.Any || permission.value.includes(import_constants5.apiRoot) && endpointMatches.length) {
       const endpointUiPermission = endpointMatches.reduce((endpointAccu, endpoint) => [...endpointAccu, ...endpoint.uiPermissions], []);
       const collector = (endpointUiPermission || definition.uiPermissions).reduce((permissionsAccu, uiPermission) => {
-        if (permission.type === PermissionTypes.Any || !endpointMatches.length && uiPermission.verbs.some((verb) => verb === permission.type)) {
+        if (permission.type === import_constants5.PermissionTypes.Any || !endpointMatches.length && uiPermission.verbs.some((verb) => verb === permission.type)) {
           permissionsAccu.push(uiPermission.value);
         }
         return permissionsAccu;
@@ -3962,39 +3707,39 @@ var mapHttpPermission = (permission) => Object.entries(uiPermissionsByArea).redu
       if (Array.isArray(accu[area])) {
         accu[area] = [...accu[area], ...collector].filter(import_helpers9.duplicateFilter);
       } else {
-        accu[area] = mergePermissions(accu[area], { [scopedPermissionAreas[area].excessiveAccessSelector]: collector });
+        accu[area] = mergePermissions(accu[area], { [import_constants5.scopedPermissionAreas[area].excessiveAccessSelector]: collector });
       }
     }
     return accu;
   },
-  { ...emptyUiPermissions }
+  { ...import_constants5.emptyUiPermissions }
 );
 var permissionActionTypes = {
   any: mapHttpPermission,
-  CREATE_DEPLOYMENT: (permission) => permission.type === PermissionTypes.DeviceGroup ? {
-    deployments: [uiPermissionsById.deploy.value],
-    groups: { [permission.value]: [uiPermissionsById.deploy.value] }
+  CREATE_DEPLOYMENT: (permission) => permission.type === import_constants5.PermissionTypes.DeviceGroup ? {
+    deployments: [import_constants5.uiPermissionsById.deploy.value],
+    groups: { [permission.value]: [import_constants5.uiPermissionsById.deploy.value] }
   } : {},
   http: mapHttpPermission,
-  REMOTE_TERMINAL: (permission) => permission.type === PermissionTypes.DeviceGroup ? {
-    groups: { [permission.value]: [uiPermissionsById.connect.value] }
+  REMOTE_TERMINAL: (permission) => permission.type === import_constants5.PermissionTypes.DeviceGroup ? {
+    groups: { [permission.value]: [import_constants5.uiPermissionsById.connect.value] }
   } : {},
-  VIEW_DEVICE: (permission) => permission.type === PermissionTypes.DeviceGroup ? {
-    groups: { [permission.value]: [uiPermissionsById.read.value] }
+  VIEW_DEVICE: (permission) => permission.type === import_constants5.PermissionTypes.DeviceGroup ? {
+    groups: { [permission.value]: [import_constants5.uiPermissionsById.read.value] }
   } : {}
 };
 var combinePermissions = (existingPermissions, additionalPermissions = {}) => Object.entries(additionalPermissions).reduce((accu, [name, permissions]) => {
-  let maybeExistingPermissions = accu[name] || [];
+  const maybeExistingPermissions = accu[name] || [];
   accu[name] = [...permissions, ...maybeExistingPermissions].filter(import_helpers9.duplicateFilter);
   return accu;
 }, existingPermissions);
 var tryParseCustomPermission = (permission) => {
   const uiPermissions = permissionActionTypes[permission.action](permission.object);
-  const result = mergePermissions({ ...emptyUiPermissions }, uiPermissions);
+  const result = mergePermissions({ ...import_constants5.emptyUiPermissions }, uiPermissions);
   return { isCustom: true, permission, result };
 };
 var customPermissionHandler = (accu, permission) => {
-  let processor = tryParseCustomPermission(permission);
+  const processor = tryParseCustomPermission(permission);
   return {
     ...accu,
     isCustom: accu.isCustom || processor.isCustom,
@@ -4002,7 +3747,7 @@ var customPermissionHandler = (accu, permission) => {
   };
 };
 var mapPermissionSet = (permissionSetName, names, scope, existingGroupsPermissions = {}) => {
-  const permission = Object.values(uiPermissionsById).find((permission2) => permission2.permissionSets[scope] === permissionSetName).value;
+  const permission = Object.values(import_constants5.uiPermissionsById).find((permission2) => permission2.permissionSets[scope] === permissionSetName)?.value;
   const scopedPermissions = names.reduce((accu, name) => combinePermissions(accu, { [name]: [permission] }), existingGroupsPermissions);
   return Object.entries(scopedPermissions).reduce((accu, [key, permissions]) => ({ ...accu, [key]: deriveImpliedAreaPermissions(scope, permissions) }), {});
 };
@@ -4015,16 +3760,21 @@ var isEmptyPermissionSet = (permissionSet) => !Object.values(permissionSet).redu
 var parseRolePermissions = ({ permission_sets_with_scope = [], permissions = [] }, permissionSets) => {
   const preliminaryResult = permission_sets_with_scope.reduce(
     (accu, permissionSet) => {
-      let processor = permissionSets[permissionSet.name];
+      const processor = permissionSets[permissionSet.name];
       if (!processor) {
         return accu;
       }
-      const scope = Object.keys(scopedPermissionAreas).find((scope2) => uiPermissionsByArea[scope2].scope === permissionSet.scope?.type);
+      const scope = Object.keys(import_constants5.scopedPermissionAreas).find((scope2) => import_constants5.uiPermissionsByArea[scope2].scope === permissionSet.scope?.type);
       if (scope) {
-        const result = mapPermissionSet(permissionSet.name, permissionSet.scope.value, scope, accu.uiPermissions[scope]);
+        const result = mapPermissionSet(
+          permissionSet.name,
+          permissionSet.scope.value,
+          scope,
+          accu.uiPermissions[scope]
+        );
         return { ...accu, uiPermissions: { ...accu.uiPermissions, [scope]: result } };
       } else if (isEmptyPermissionSet(processor.result)) {
-        return processor.permissions.reduce(customPermissionHandler, accu);
+        return processor.permissions?.reduce(customPermissionHandler, accu);
       }
       return {
         ...accu,
@@ -4032,7 +3782,7 @@ var parseRolePermissions = ({ permission_sets_with_scope = [], permissions = []
         uiPermissions: mergePermissions(accu.uiPermissions, processor.result)
       };
     },
-    { isCustom: false, uiPermissions: { ...emptyUiPermissions, groups: {}, releases: {} } }
+    { isCustom: false, uiPermissions: { ...import_constants5.emptyUiPermissions, groups: {}, releases: {} } }
   );
   return permissions.reduce(customPermissionHandler, preliminaryResult);
 };
@@ -4051,12 +3801,12 @@ var normalizeRbacRoles = (roles, rolesById2, permissionSets) => roles.reduce(
       normalizedPermissions = result.uiPermissions;
       isCustom = result.isCustom;
     }
-    const roleState = accu[role.name] ?? { ...emptyRole };
+    const roleState = accu[role.name] ?? { ...import_constants5.emptyRole };
     accu[role.name] = {
       ...roleState,
       ...role,
       description: roleState.description ? roleState.description : role.description,
-      editable: !rolesById[role.name] && !isCustom && (typeof roleState.editable !== "undefined" ? roleState.editable : true),
+      editable: !import_constants5.rolesById[role.name] && !isCustom && (typeof roleState.editable !== "undefined" ? roleState.editable : true),
       isCustom,
       name: roleState.name ? roleState.name : role.name,
       uiPermissions: normalizedPermissions
@@ -4065,16 +3815,16 @@ var normalizeRbacRoles = (roles, rolesById2, permissionSets) => roles.reduce(
   },
   { ...rolesById2 }
 );
-var getPermissionSets = (0, import_toolkit20.createAsyncThunk)(
+var getPermissionSets = createAppAsyncThunk(
   `${sliceName8}/getPermissionSets`,
-  (_, { dispatch, getState }) => general_api_default.get(`${useradmApiUrlv2}/permission_sets?per_page=500`).then(({ data }) => {
+  (_, { dispatch, getState }) => general_api_default.get(`${import_constants5.useradmApiUrlv2}/permission_sets?per_page=500`).then(({ data }) => {
     const permissionSets = data.reduce(
       (accu, permissionSet) => {
         const permissionSetState = accu[permissionSet.name] ?? {};
         let permissionSetObject = { ...permissionSetState, ...permissionSet };
-        permissionSetObject.result = Object.values(uiPermissionsById).reduce(
+        permissionSetObject.result = Object.values(import_constants5.uiPermissionsById).reduce(
           (accu2, item) => Object.entries(item.permissionSets).reduce((collector, [area, permissionSet2]) => {
-            if (scopedPermissionAreas[area]) {
+            if (import_constants5.scopedPermissionAreas[area]) {
               return collector;
             }
             if (permissionSet2 === permissionSetObject.name) {
@@ -4082,16 +3832,19 @@ var getPermissionSets = (0, import_toolkit20.createAsyncThunk)(
             }
             return collector;
           }, accu2),
-          { ...emptyUiPermissions, ...permissionSetObject.result ?? {} }
+          { ...import_constants5.emptyUiPermissions, ...permissionSetObject.result ?? {} }
         );
-        const scopes = Object.values(scopedPermissionAreas).reduce((accu2, { key, scopeType }) => {
+        const scopes = Object.values(import_constants5.scopedPermissionAreas).reduce((accu2, { key, scopeType }) => {
           if (permissionSetObject.supported_scope_types?.includes(key) || permissionSetObject.supported_scope_types?.includes(scopeType)) {
             accu2.push(key);
           }
           return accu2;
         }, []);
         permissionSetObject = scopes.reduce((accu2, scope) => {
-          accu2.result[scope] = mapPermissionSet(permissionSetObject.name, [scopedPermissionAreas[scope].excessiveAccessSelector], scope);
+          accu2.result = {
+            ...accu2.result,
+            [scope]: mapPermissionSet(permissionSetObject.name, [import_constants5.scopedPermissionAreas[scope].excessiveAccessSelector], scope)
+          };
           return accu2;
         }, permissionSetObject);
         accu[permissionSet.name] = permissionSetObject;
@@ -4102,23 +3855,23 @@ var getPermissionSets = (0, import_toolkit20.createAsyncThunk)(
     return Promise.all([dispatch(actions8.receivedPermissionSets(permissionSets)), permissionSets]);
   }).catch(() => console.log("Permission set retrieval failed - likely accessing a non-RBAC backend"))
 );
-var getRoles = (0, import_toolkit20.createAsyncThunk)(
+var getRoles = createAppAsyncThunk(
   `${sliceName8}/getRoles`,
-  (_, { dispatch, getState }) => Promise.all([general_api_default.get(`${useradmApiUrlv2}/roles?per_page=500`), dispatch(getPermissionSets())]).then((results) => {
+  (_, { dispatch, getState }) => Promise.all([general_api_default.get(`${import_constants5.useradmApiUrlv2}/roles?per_page=500`), dispatch(getPermissionSets())]).then((results) => {
     if (!results) {
       return Promise.resolve();
     }
     const [{ data: roles }, { payload: permissionSetTasks }] = results;
     const rolesById2 = normalizeRbacRoles(roles, getRolesById(getState()), permissionSetTasks[permissionSetTasks.length - 1]);
     return Promise.resolve(dispatch(actions8.receivedRoles(rolesById2)));
-  }).catch(() => console.log("Role retrieval failed - likely accessing a non-RBAC backend"))
+  }).catch(() => console.log("Role retrieval failed - likely accessing a non-RBAC backend")).finally(() => Promise.resolve(dispatch(actions8.finishedRoleInitialization(true))))
 );
 var deriveImpliedAreaPermissions = (area, areaPermissions, skipPermissions = []) => {
   const highestAreaPermissionLevelSelected = areaPermissions.reduce(
-    (highest, current) => uiPermissionsById[current].permissionLevel > highest ? uiPermissionsById[current].permissionLevel : highest,
+    (highest, current) => import_constants5.uiPermissionsById[current].permissionLevel > highest ? import_constants5.uiPermissionsById[current].permissionLevel : highest,
     1
   );
-  return uiPermissionsByArea[area].uiPermissions.reduce((permissions, current) => {
+  return import_constants5.uiPermissionsByArea[area].uiPermissions.reduce((permissions, current) => {
     if ((current.permissionLevel < highestAreaPermissionLevelSelected || areaPermissions.includes(current.value)) && !skipPermissions.includes(current.value)) {
       permissions.push(current.value);
     }
@@ -4127,14 +3880,14 @@ var deriveImpliedAreaPermissions = (area, areaPermissions, skipPermissions = [])
 };
 var transformAreaRoleDataToScopedPermissionsSets = (area, areaPermissions, excessiveAccessSelector) => {
   const permissionSetObject = areaPermissions.reduce((accu, { item, uiPermissions }) => {
-    const skipPermissions = scopedPermissionAreas.releases.key === area && item !== ALL_RELEASES ? [uiPermissionsById.upload.value] : [];
+    const skipPermissions = import_constants5.scopedPermissionAreas.releases.key === area && item !== import_constants5.ALL_RELEASES ? [import_constants5.uiPermissionsById.upload.value] : [];
     const impliedPermissions = deriveImpliedAreaPermissions(area, uiPermissions, skipPermissions);
     accu = impliedPermissions.reduce((itemPermissionAccu, impliedPermission) => {
-      const permissionSetState = itemPermissionAccu[uiPermissionsById[impliedPermission].permissionSets[area]] ?? {
-        type: uiPermissionsByArea[area].scope,
+      const permissionSetState = itemPermissionAccu[import_constants5.uiPermissionsById[impliedPermission].permissionSets[area]] ?? {
+        type: import_constants5.uiPermissionsByArea[area].scope,
         value: []
       };
-      itemPermissionAccu[uiPermissionsById[impliedPermission].permissionSets[area]] = {
+      itemPermissionAccu[import_constants5.uiPermissionsById[impliedPermission].permissionSets[area]] = {
         ...permissionSetState,
         value: [...permissionSetState.value, item]
       };
@@ -4151,10 +3904,10 @@ var transformAreaRoleDataToScopedPermissionsSets = (area, areaPermissions, exces
 };
 var transformRoleDataToRole = (roleData, roleState = {}) => {
   const role = { ...roleState, ...roleData };
-  const { description = "", name, uiPermissions = emptyUiPermissions } = role;
-  const { maybeUiPermissions, remainderKeys } = Object.entries(emptyUiPermissions).reduce(
+  const { description = "", name, uiPermissions = import_constants5.emptyUiPermissions } = role;
+  const { maybeUiPermissions, remainderKeys } = Object.entries(import_constants5.emptyUiPermissions).reduce(
     (accu, [key, emptyPermissions]) => {
-      if (!scopedPermissionAreas[key]) {
+      if (!import_constants5.scopedPermissionAreas[key]) {
         accu.remainderKeys.push(key);
       } else if (uiPermissions[key]) {
         accu.maybeUiPermissions[key] = uiPermissions[key].reduce(itemUiPermissionsReducer, emptyPermissions);
@@ -4171,27 +3924,33 @@ var transformRoleDataToRole = (roleData, roleState = {}) => {
       }
       const impliedPermissions = deriveImpliedAreaPermissions(area, areaPermissions);
       accu.roleUiPermissions[area] = impliedPermissions;
-      const mappedPermissions = impliedPermissions.map((uiPermission) => ({ name: uiPermissionsById[uiPermission].permissionSets[area] }));
+      const mappedPermissions = impliedPermissions.map((uiPermission) => ({ name: import_constants5.uiPermissionsById[uiPermission].permissionSets[area] }));
       accu.permissionSetsWithScope.push(...mappedPermissions);
       return accu;
     },
-    { permissionSetsWithScope: [{ name: defaultPermissionSets.Basic.name }], roleUiPermissions: {} }
+    { permissionSetsWithScope: [{ name: import_constants5.defaultPermissionSets.Basic.name }], roleUiPermissions: {} }
   );
-  const scopedPermissionSets = Object.values(scopedPermissionAreas).reduce((accu, { key, excessiveAccessSelector }) => {
+  const scopedPermissionSets = Object.values(import_constants5.scopedPermissionAreas).reduce((accu, { key, excessiveAccessSelector }) => {
     if (!uiPermissions[key]) {
       return accu;
     }
-    accu.push(...transformAreaRoleDataToScopedPermissionsSets(key, uiPermissions[key], excessiveAccessSelector));
+    accu.push(
+      ...transformAreaRoleDataToScopedPermissionsSets(
+        key,
+        uiPermissions[key],
+        excessiveAccessSelector
+      )
+    );
     return accu;
   }, []);
   return {
     permissionSetsWithScope: [...permissionSetsWithScope, ...scopedPermissionSets],
     role: {
-      ...emptyRole,
+      ...import_constants5.emptyRole,
       name,
-      description: description ? description : roleState.description,
+      description: description ? description : roleState.description || "",
       uiPermissions: {
-        ...emptyUiPermissions,
+        ...import_constants5.emptyUiPermissions,
         ...roleUiPermissions,
         ...maybeUiPermissions
       }
@@ -4212,50 +3971,57 @@ var roleActions = {
     errorMessage: "removing"
   }
 };
-var roleActionErrorHandler = (err, type, dispatch) => commonErrorHandler(err, `There was an error ${roleActions[type].errorMessage} the role.`, dispatch);
-var createRole = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/createRole`, (roleData, { dispatch }) => {
+var roleActionErrorHandler = (err, type, dispatch, meta) => {
+  let errorContext = `There was an error ${roleActions[type].errorMessage} the role.`;
+  if (meta) {
+    const { permissionSetsCreated, name } = meta;
+    errorContext += ` Tried to ${type} role ${name} with ${permissionSetsCreated} permission sets.`;
+  }
+  return commonErrorHandler(err, errorContext, dispatch);
+};
+var createRole = createAppAsyncThunk(`${sliceName8}/createRole`, (roleData, { dispatch }) => {
   const { permissionSetsWithScope, role } = transformRoleDataToRole(roleData);
-  return general_api_default.post(`${useradmApiUrlv2}/roles`, {
+  return general_api_default.post(`${import_constants5.useradmApiUrlv2}/roles`, {
     name: role.name,
     description: role.description,
     permission_sets_with_scope: permissionSetsWithScope
-  }).then(() => Promise.all([dispatch(actions8.createdRole(role)), dispatch(getRoles()), dispatch(setSnackbar3(roleActions.create.successMessage))])).catch((err) => roleActionErrorHandler(err, "create", dispatch));
+  }).then(() => Promise.all([dispatch(actions8.createdRole(role)), dispatch(getRoles()), dispatch(setSnackbar3(roleActions.create.successMessage))])).catch((err) => roleActionErrorHandler(err, "create", dispatch, { permissionSetsCreated: permissionSetsWithScope.length, name: role.name }));
 });
-var editRole = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/editRole`, (roleData, { dispatch, getState }) => {
+var editRole = createAppAsyncThunk(`${sliceName8}/editRole`, (roleData, { dispatch, getState }) => {
   const { permissionSetsWithScope, role } = transformRoleDataToRole(roleData, getRolesById(getState())[roleData.name]);
-  return general_api_default.put(`${useradmApiUrlv2}/roles/${role.name}`, {
+  return general_api_default.put(`${import_constants5.useradmApiUrlv2}/roles/${role.name}`, {
     description: role.description,
     name: role.name,
     permission_sets_with_scope: permissionSetsWithScope
-  }).then(() => Promise.all([dispatch(actions8.createdRole(role)), dispatch(getRoles()), dispatch(setSnackbar3(roleActions.edit.successMessage))])).catch((err) => roleActionErrorHandler(err, "edit", dispatch));
+  }).then(() => Promise.all([dispatch(actions8.createdRole(role)), dispatch(getRoles()), dispatch(setSnackbar3(roleActions.edit.successMessage))])).catch((err) => roleActionErrorHandler(err, "edit", dispatch, { permissionSetsCreated: permissionSetsWithScope.length, name: role.name }));
 });
-var removeRole = (0, import_toolkit20.createAsyncThunk)(
+var removeRole = createAppAsyncThunk(
   `${sliceName8}/removeRole`,
-  (roleId, { dispatch }) => general_api_default.delete(`${useradmApiUrlv2}/roles/${roleId}`).then(() => Promise.all([dispatch(actions8.removedRole(roleId)), dispatch(getRoles()), dispatch(setSnackbar3(roleActions.remove.successMessage))])).catch((err) => roleActionErrorHandler(err, "remove", dispatch))
+  (roleId, { dispatch }) => general_api_default.delete(`${import_constants5.useradmApiUrlv2}/roles/${roleId}`).then(() => Promise.all([dispatch(actions8.removedRole(roleId)), dispatch(getRoles()), dispatch(setSnackbar3(roleActions.remove.successMessage))])).catch((err) => roleActionErrorHandler(err, "remove", dispatch))
 );
-var getGlobalSettings2 = (0, import_toolkit20.createAsyncThunk)(
+var getGlobalSettings2 = createAppAsyncThunk(
   `${sliceName8}/getGlobalSettings`,
-  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/settings`).then(({ data: settings, headers: { etag } }) => {
-    window.sessionStorage.setItem(settingsKeys.initialized, true);
+  (_, { dispatch }) => general_api_default.get(`${import_constants5.useradmApiUrl}/settings`).then(({ data: settings, headers: { etag } }) => {
+    window.sessionStorage.setItem(settingsKeys.initialized, "true");
     return Promise.all([dispatch(actions8.setGlobalSettings(settings)), dispatch(setOfflineThreshold()), etag]);
   })
 );
-var saveGlobalSettings = (0, import_toolkit20.createAsyncThunk)(
+var saveGlobalSettings = createAppAsyncThunk(
   `${sliceName8}/saveGlobalSettings`,
   ({ beOptimistic = false, notify = false, ...settings }, { dispatch, getState }) => {
     if (!window.sessionStorage.getItem(settingsKeys.initialized) && !beOptimistic) {
       return;
     }
     return dispatch(getGlobalSettings2()).unwrap().then((result) => {
-      let updatedSettings = { ...getState().users.globalSettings, ...settings };
+      const updatedSettings = { ...getState().users.globalSettings, ...settings };
       if (getCurrentUser(getState()).verified) {
-        updatedSettings["2fa"] = twoFAStates.enabled;
+        updatedSettings["2fa"] = import_constants5.twoFAStates.enabled;
       } else {
         delete updatedSettings["2fa"];
       }
-      let tasks = [dispatch(actions8.setGlobalSettings(updatedSettings))];
+      const tasks = [dispatch(actions8.setGlobalSettings(updatedSettings))];
       const headers = result[result.length - 1] ? { "If-Match": result[result.length - 1] } : {};
-      return general_api_default.post(`${useradmApiUrlv1}/settings`, updatedSettings, { headers }).then(() => {
+      return general_api_default.post(`${import_constants5.useradmApiUrl}/settings`, updatedSettings, { headers }).then(() => {
         if (notify) {
           tasks.push(dispatch(setSnackbar3("Settings saved successfully")));
         }
@@ -4270,54 +4036,59 @@ var saveGlobalSettings = (0, import_toolkit20.createAsyncThunk)(
     });
   }
 );
-var getUserSettings2 = (0, import_toolkit20.createAsyncThunk)(
+var getUserSettings2 = createAppAsyncThunk(
   `${sliceName8}/getUserSettings`,
-  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/settings/me`).then(({ data: settings, headers: { etag } }) => {
-    window.sessionStorage.setItem(settingsKeys.initialized, true);
+  (_, { dispatch }) => general_api_default.get(`${import_constants5.useradmApiUrl}/settings/me`).then(({ data: settings, headers: { etag } }) => {
+    window.sessionStorage.setItem(settingsKeys.initialized, "true");
     return Promise.all([dispatch(actions8.setUserSettings(settings)), etag]);
   })
 );
-var saveUserSettings = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/saveUserSettings`, (settings = { onboarding: {} }, { dispatch, getState }) => {
-  if (!getCurrentUser(getState()).id) {
-    return Promise.resolve();
+var saveUserSettings = createAppAsyncThunk(
+  `${sliceName8}/saveUserSettings`,
+  (settings = { onboarding: {} }, { dispatch, getState }) => {
+    if (!getCurrentUser(getState()).id) {
+      return Promise.resolve();
+    }
+    return dispatch(getUserSettings2()).unwrap().then((result) => {
+      const userSettings = getUserSettings(getState());
+      const onboardingState = getOnboardingState(getState());
+      const tooltipState = getTooltipsState(getState());
+      const updatedSettings = {
+        ...userSettings,
+        ...settings,
+        onboarding: {
+          ...onboardingState,
+          ...settings.onboarding
+        },
+        tooltips: tooltipState
+      };
+      const headers = result[result.length - 1] ? { "If-Match": result[result.length - 1] } : {};
+      return Promise.all([
+        Promise.resolve(dispatch(actions8.setUserSettings(updatedSettings))),
+        general_api_default.post(`${import_constants5.useradmApiUrl}/settings/me`, updatedSettings, { headers })
+      ]).catch(() => dispatch(actions8.setUserSettings(userSettings)));
+    });
   }
-  return dispatch(getUserSettings2()).unwrap().then((result) => {
-    const userSettings = getUserSettings(getState());
-    const onboardingState = getOnboardingState(getState());
-    const tooltipState = getTooltipsState(getState());
-    const updatedSettings = {
-      ...userSettings,
-      ...settings,
-      onboarding: {
-        ...onboardingState,
-        ...settings.onboarding
-      },
-      tooltips: tooltipState
-    };
-    const headers = result[result.length - 1] ? { "If-Match": result[result.length - 1] } : {};
-    return Promise.all([
-      Promise.resolve(dispatch(actions8.setUserSettings(updatedSettings))),
-      general_api_default.post(`${useradmApiUrlv1}/settings/me`, updatedSettings, { headers })
-    ]).catch(() => dispatch(actions8.setUserSettings(userSettings)));
-  });
-});
-var get2FAQRCode = (0, import_toolkit20.createAsyncThunk)(
+);
+var get2FAQRCode = createAppAsyncThunk(
   `${sliceName8}/get2FAQRCode`,
-  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/2faqr`).then((res) => dispatch(actions8.receivedQrCode(res.data.qr)))
+  (_, { dispatch }) => general_api_default.get(`${import_constants5.useradmApiUrl}/2faqr`).then((res) => dispatch(actions8.receivedQrCode(res.data.qr)))
 );
-var setHideAnnouncement = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/setHideAnnouncement`, ({ shouldHide, userId }, { dispatch, getState }) => {
-  const currentUserId = userId || getCurrentUser(getState()).id;
-  const hash = getState().app.hostedAnnouncement ? (0, import_md5.default)(getState().app.hostedAnnouncement) : "";
-  const announceCookie = cookies3.get(`${currentUserId}${hash}`);
-  if (shouldHide || hash.length && typeof announceCookie !== "undefined") {
-    cookies3.set(`${currentUserId}${hash}`, true, { maxAge: 604800 });
-    return Promise.resolve(dispatch(setAnnouncement()));
+var setHideAnnouncement = createAppAsyncThunk(
+  `${sliceName8}/setHideAnnouncement`,
+  ({ shouldHide, userId }, { dispatch, getState }) => {
+    const currentUserId = userId || getCurrentUser(getState()).id;
+    const hash = getState().app.hostedAnnouncement ? (0, import_md5.default)(getState().app.hostedAnnouncement) : "";
+    const announceCookie = cookies3.get(`${currentUserId}${hash}`);
+    if (shouldHide || hash.length && typeof announceCookie !== "undefined") {
+      cookies3.set(`${currentUserId}${hash}`, true, { maxAge: 604800 });
+      dispatch(setAnnouncement(""));
+    }
   }
-  return Promise.resolve();
-});
-var getTokens = (0, import_toolkit20.createAsyncThunk)(
+);
+var getTokens = createAppAsyncThunk(
   `${sliceName8}/getTokens`,
-  (_, { dispatch, getState }) => general_api_default.get(`${useradmApiUrlv1}/settings/tokens`).then(({ data: tokens }) => {
+  (_, { dispatch, getState }) => general_api_default.get(`${import_constants5.useradmApiUrl}/settings/tokens`).then(({ data: tokens }) => {
     const user = getCurrentUser(getState());
     const updatedUser = {
       ...user,
@@ -4327,28 +4098,33 @@ var getTokens = (0, import_toolkit20.createAsyncThunk)(
   })
 );
 var ONE_YEAR = 31536e3;
-var generateToken = (0, import_toolkit20.createAsyncThunk)(
+var generateToken = createAppAsyncThunk(
   `${sliceName8}/generateToken`,
-  ({ expiresIn = ONE_YEAR, name }, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/settings/tokens`, { name, expires_in: expiresIn }).then(({ data: token }) => Promise.all([dispatch(getTokens()), token])).catch((err) => commonErrorHandler(err, "There was an error creating the token:", dispatch))
+  ({ expiresIn = ONE_YEAR, name }, { dispatch }) => general_api_default.post(`${import_constants5.useradmApiUrl}/settings/tokens`, { name, expires_in: expiresIn }).then(({ data: token }) => Promise.all([dispatch(getTokens()), token])).catch((err) => commonErrorHandler(err, "There was an error creating the token:", dispatch))
 );
-var revokeToken = (0, import_toolkit20.createAsyncThunk)(
+var revokeToken = createAppAsyncThunk(
   `${sliceName8}/revokeToken`,
-  (token, { dispatch }) => general_api_default.delete(`${useradmApiUrlv1}/settings/tokens/${token.id}`).then(() => Promise.resolve(dispatch(getTokens())))
+  (token, { dispatch }) => general_api_default.delete(`${import_constants5.useradmApiUrl}/settings/tokens/${token.id}`).then(() => Promise.resolve(dispatch(getTokens())))
 );
-var setTooltipReadState = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/setTooltipReadState`, ({ persist, ...remainder }, { dispatch }) => {
-  let tasks = [dispatch(actions8.setTooltipState(remainder))];
-  if (persist) {
-    tasks.push(dispatch(saveUserSettings()));
+var setTooltipReadState = createAppAsyncThunk(
+  `${sliceName8}/setTooltipReadState`,
+  async ({ persist, ...remainder }, { dispatch }) => {
+    dispatch(actions8.setTooltipState(remainder));
+    if (persist) {
+      await dispatch(saveUserSettings());
+    }
   }
-  return Promise.all(tasks);
-});
-var setAllTooltipsReadState = (0, import_toolkit20.createAsyncThunk)(`${sliceName8}/toggleHelptips`, (readState = READ_STATES.read, { dispatch }) => {
-  const updatedTips = Object.keys(import_helptips.HELPTOOLTIPS).reduce((accu, id) => ({ ...accu, [id]: { readState } }), {});
-  return Promise.resolve(dispatch(actions8.setTooltipsState(updatedTips))).then(() => dispatch(saveUserSettings()));
-});
-var submitFeedback = (0, import_toolkit20.createAsyncThunk)(
+);
+var setAllTooltipsReadState = createAppAsyncThunk(
+  `${sliceName8}/toggleHelptips`,
+  ({ readState = READ_STATES.read, tooltipIds }, { dispatch }) => {
+    const updatedTips = tooltipIds.reduce((accu, id) => ({ ...accu, [id]: { readState } }), {});
+    return Promise.resolve(dispatch(actions8.setTooltipsState(updatedTips))).then(() => dispatch(saveUserSettings()));
+  }
+);
+var submitFeedback = createAppAsyncThunk(
   `${sliceName8}/submitFeedback`,
-  ({ satisfaction, feedback, ...meta }, { dispatch }) => general_api_default.post(`${tenantadmApiUrlv2}/contact/support`, {
+  ({ satisfaction, feedback, ...meta }, { dispatch }) => general_api_default.post(`${import_constants5.tenantadmApiUrlv2}/contact/support`, {
     subject: "feedback submission",
     body: JSON.stringify({ feedback, satisfaction, meta })
   }).then(() => {
@@ -4359,21 +4135,17 @@ var submitFeedback = (0, import_toolkit20.createAsyncThunk)(
 );
 
 // src/deploymentsSlice/thunks.ts
-var import_helpers10 = require("@northern.tech/utils/helpers");
-var import_tracking = __toESM(require("@northern.tech/utils/tracking"), 1);
-var import_toolkit21 = require("@reduxjs/toolkit");
-var import_validator = require("validator");
 var { receivedDevice, setSnackbar: setSnackbar4 } = actions_default;
-var { page: defaultPage3, perPage: defaultPerPage3 } = DEVICE_LIST_DEFAULTS;
-var deriveDeploymentGroup = ({ filter = {}, group, groups = [], name }) => group || groups.length === 1 && !(0, import_validator.isUUID)(name) ? groups[0] : filter.name;
+var { page: defaultPage3, perPage: defaultPerPage3 } = import_constants5.DEVICE_LIST_DEFAULTS;
+var deriveDeploymentGroup = ({ filter, group, groups = [], name }) => group || groups.length === 1 && !(0, import_validator.isUUID)(name) ? groups[0] : filter?.name;
 var transformDeployments = (deployments, deploymentsById) => deployments.sort((0, import_helpers10.customSort)(true, "created")).reduce(
   (accu, item) => {
-    const filter = item.filter ?? {};
+    const filter = item.filter;
     let deployment = {
       ...deploymentPrototype,
       ...deploymentsById[item.id],
       ...item,
-      filter: item.filter ? { ...filter, name: filter.name ?? filter.id, filters: mapTermsToFilters(filter.terms) } : void 0,
+      filter: filter ? { ...filter, name: filter.name ?? filter.id, filters: mapTermsToFilters(filter.terms) } : void 0,
       name: decodeURIComponent(item.name)
     };
     deployment = { ...deployment, group: deriveDeploymentGroup(deployment) };
@@ -4383,40 +4155,43 @@ var transformDeployments = (deployments, deploymentsById) => deployments.sort((0
   },
   { deployments: {}, deploymentIds: [] }
 );
-var getDeploymentsByStatus2 = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/getDeploymentsByStatus`, (options = {}, { dispatch, getState }) => {
-  const { status, page = defaultPage3, per_page = defaultPerPage3, startDate, endDate, group, type, shouldSelect = true, sort = SORTING_OPTIONS.desc } = options;
-  const created_after = startDate ? `&created_after=${startDate}` : "";
-  const created_before = endDate ? `&created_before=${endDate}` : "";
-  const search = group ? `&search=${group}` : "";
-  const typeFilter = type ? `&type=${type}` : "";
-  return general_api_default.get(
-    `${deploymentsApiUrl}/deployments?status=${status}&per_page=${per_page}&page=${page}${created_after}${created_before}${search}${typeFilter}&sort=${sort}`
-  ).then((res) => {
-    const { deployments, deploymentIds } = transformDeployments(res.data, getState().deployments.byId);
-    const total = Number(res.headers[headerNames.total]);
-    let tasks = [
-      dispatch(actions2.receivedDeployments(deployments)),
-      dispatch(
-        actions2.receivedDeploymentsForStatus({
-          deploymentIds,
-          status,
-          total: !(startDate || endDate || group || type) ? total : getState().deployments.byStatus[status].total
-        })
-      )
-    ];
-    tasks = deploymentIds.reduce((accu, deploymentId) => {
-      if (deployments[deploymentId].type === DEPLOYMENT_TYPES.configuration) {
-        accu.push(dispatch(getSingleDeployment(deploymentId)));
+var getDeploymentsByStatus2 = createAppAsyncThunk(
+  `${sliceName}/getDeploymentsByStatus`,
+  (options, { dispatch, getState }) => {
+    const { status, page = defaultPage3, perPage = defaultPerPage3, startDate, endDate, group, type, shouldSelect = true, sort = import_constants5.SORTING_OPTIONS.desc } = options;
+    const created_after = startDate ? `&created_after=${startDate}` : "";
+    const created_before = endDate ? `&created_before=${endDate}` : "";
+    const search = group ? `&search=${group}` : "";
+    const typeFilter = type ? `&type=${type}` : "";
+    return general_api_default.get(
+      `${import_constants5.deploymentsApiUrl}/deployments?status=${status}&per_page=${perPage}&page=${page}${created_after}${created_before}${search}${typeFilter}&sort=${sort}`
+    ).then((res) => {
+      const { deployments, deploymentIds } = transformDeployments(res.data, getState().deployments.byId);
+      const total = Number(res.headers[import_constants5.headerNames.total]);
+      let tasks = [
+        dispatch(actions.receivedDeployments(deployments)),
+        dispatch(
+          actions.receivedDeploymentsForStatus({
+            deploymentIds,
+            status,
+            total: !(startDate || endDate || group || type) ? total : getState().deployments.byStatus[status].total
+          })
+        )
+      ];
+      tasks = deploymentIds.reduce((accu, deploymentId) => {
+        if (deployments[deploymentId].type === DEPLOYMENT_TYPES.configuration) {
+          accu.push(dispatch(getSingleDeployment(deploymentId)));
+        }
+        return accu;
+      }, tasks);
+      if (shouldSelect) {
+        tasks.push(dispatch(actions.selectDeploymentsForStatus({ deploymentIds, status, total })));
       }
-      return accu;
-    }, tasks);
-    if (shouldSelect) {
-      tasks.push(dispatch(actions2.selectDeploymentsForStatus({ deploymentIds, status, total })));
-    }
-    tasks.push({ deploymentIds, total });
-    return Promise.all(tasks);
-  });
-});
+      tasks.push({ deploymentIds, total });
+      return Promise.all(tasks);
+    });
+  }
+);
 var isWithinFirstMonth = (expirationDate) => {
   if (!expirationDate) {
     return false;
@@ -4438,86 +4213,98 @@ var trackDeploymentCreation = (totalDeploymentCount, hasDeployments, trial_expir
   }
 };
 var MAX_PREVIOUS_PHASES_COUNT = 5;
-var createDeployment = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/createDeployment`, ({ newDeployment, hasNewRetryDefault = false }, { dispatch, getState }) => {
-  let request;
-  if (newDeployment.filter_id) {
-    request = general_api_default.post(`${deploymentsApiUrlV2}/deployments`, newDeployment);
-  } else if (newDeployment.group) {
-    request = general_api_default.post(`${deploymentsApiUrl}/deployments/group/${newDeployment.group}`, newDeployment);
-  } else {
-    request = general_api_default.post(`${deploymentsApiUrl}/deployments`, newDeployment);
-  }
-  const totalDeploymentCount = Object.values(getDeploymentsByStatus(getState())).reduce((accu, item) => accu + item.total, 0);
-  const { hasDeployments } = getGlobalSettings(getState());
-  const { trial_expiration } = getOrganization(getState());
-  return request.catch((err) => commonErrorHandler(err, "Error creating deployment.", dispatch)).then((data) => {
-    const lastslashindex = data.headers.location.lastIndexOf("/");
-    const deploymentId = data.headers.location.substring(lastslashindex + 1);
-    const deployment = {
-      ...newDeployment,
-      id: deploymentId,
-      devices: newDeployment.devices ? newDeployment.devices.map((id) => ({ id, status: "pending" })) : [],
-      statistics: { status: {} }
-    };
-    let tasks = [
-      dispatch(actions2.createdDeployment(deployment)),
-      dispatch(getSingleDeployment(deploymentId)),
-      dispatch(setSnackbar4("Deployment created successfully", TIMEOUTS.fiveSeconds))
-    ];
-    trackDeploymentCreation(totalDeploymentCount, hasDeployments, trial_expiration);
-    const { canManageUsers } = getUserCapabilities(getState());
-    if (canManageUsers) {
-      const { phases, retries } = newDeployment;
-      const { previousPhases = [], retries: previousRetries = 0 } = getGlobalSettings(getState());
-      let newSettings = { retries: hasNewRetryDefault ? retries : previousRetries, hasDeployments: true };
-      if (phases) {
-        const standardPhases = (0, import_helpers10.standardizePhases)(phases);
-        let prevPhases = previousPhases.map(import_helpers10.standardizePhases);
-        if (!prevPhases.find((previousPhaseList) => previousPhaseList.every((oldPhase) => standardPhases.find((phase) => (0, import_helpers10.deepCompare)(phase, oldPhase))))) {
-          prevPhases.push(standardPhases);
-        }
-        newSettings.previousPhases = prevPhases.slice(-1 * MAX_PREVIOUS_PHASES_COUNT);
-      }
-      tasks.push(dispatch(saveGlobalSettings(newSettings)));
+var createDeployment = createAppAsyncThunk(
+  `${sliceName}/createDeployment`,
+  ({
+    newDeployment,
+    hasNewRetryDefault = false
+  }, { dispatch, getState }) => {
+    let request;
+    if ("filter_id" in newDeployment && newDeployment.filter_id) {
+      request = general_api_default.post(`${import_constants5.deploymentsApiUrlV2}/deployments`, newDeployment);
+    } else if ("group" in newDeployment && newDeployment.group) {
+      request = general_api_default.post(`${import_constants5.deploymentsApiUrl}/deployments/group/${newDeployment.group}`, newDeployment);
+    } else {
+      request = general_api_default.post(`${import_constants5.deploymentsApiUrl}/deployments`, newDeployment);
     }
-    return Promise.all(tasks);
-  });
-});
-var getDeploymentDevices = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/getDeploymentDevices`, (options, { dispatch, getState }) => {
-  const { id, page = defaultPage3, perPage = defaultPerPage3 } = options;
-  return general_api_default.get(`${deploymentsApiUrl}/deployments/${id}/devices/list?&page=${page}&per_page=${perPage}`).then((response) => {
-    const { devices: deploymentDevices = {} } = getState().deployments.byId[id] || {};
-    const devices = response.data.reduce((accu, item) => {
-      accu[item.id] = item;
-      const log = (deploymentDevices[item.id] || {}).log;
-      if (log) {
-        accu[item.id].log = log;
-      }
-      return accu;
-    }, {});
-    const selectedDeviceIds = Object.keys(devices);
-    let tasks = [
-      dispatch(
-        actions2.receivedDeploymentDevices({
-          id,
-          devices,
-          selectedDeviceIds,
-          totalDeviceCount: Number(response.headers[headerNames.total])
-        })
-      )
-    ];
-    const devicesById = getDevicesById(getState());
-    const lackingData = selectedDeviceIds.reduce((accu, deviceId) => {
-      const device = devicesById[deviceId];
-      if (!device || !device.identity_data || !device.attributes || Object.keys(device.attributes).length === 0) {
-        accu.push(deviceId);
+    const totalDeploymentCount = Object.values(getDeploymentsByStatus(getState())).reduce(
+      (accu, item) => accu + item.total,
+      0
+    );
+    const { hasDeployments } = getGlobalSettings(getState());
+    const { trial_expiration } = getOrganization(getState());
+    return request.catch((err) => commonErrorHandler(err, "Error creating deployment.", dispatch)).then((data) => {
+      const lastslashindex = data.headers.location.lastIndexOf("/");
+      const deploymentId = data.headers.location.substring(lastslashindex + 1);
+      const deployment = {
+        ...newDeployment,
+        id: deploymentId,
+        devices: "devices" in newDeployment && newDeployment.devices ? newDeployment.devices.map((id) => ({ id, status: "pending" })) : [],
+        statistics: { status: {} }
+      };
+      const tasks = [
+        dispatch(actions.createdDeployment(deployment)),
+        dispatch(getSingleDeployment(deploymentId)),
+        dispatch(setSnackbar4({ message: "Deployment created successfully", autoHideDuration: TIMEOUTS.fiveSeconds }))
+      ];
+      trackDeploymentCreation(totalDeploymentCount, hasDeployments, trial_expiration);
+      const { canManageUsers } = getUserCapabilities(getState());
+      if (canManageUsers) {
+        const { phases, retries } = newDeployment;
+        const { previousPhases = [], retries: previousRetries = 0 } = getGlobalSettings(getState());
+        const newSettings = { retries: hasNewRetryDefault ? retries : previousRetries, hasDeployments: true };
+        if (phases) {
+          const standardPhases = (0, import_helpers10.standardizePhases)(phases);
+          const prevPhases = previousPhases.map(import_helpers10.standardizePhases);
+          if (!prevPhases.find((previousPhaseList) => previousPhaseList.every((oldPhase) => standardPhases.find((phase) => (0, import_helpers10.deepCompare)(phase, oldPhase))))) {
+            prevPhases.push(standardPhases);
+          }
+          newSettings.previousPhases = prevPhases.slice(-1 * MAX_PREVIOUS_PHASES_COUNT);
+        }
+        tasks.push(dispatch(saveGlobalSettings(newSettings)));
       }
-      return accu;
-    }, []);
-    tasks = lackingData.reduce((accu, deviceId) => [...accu, dispatch(getDeviceById2(deviceId)), dispatch(getDeviceAuth(deviceId))], tasks);
-    return Promise.all(tasks);
-  });
-});
+      return Promise.all(tasks);
+    });
+  }
+);
+var getDeploymentDevices = createAppAsyncThunk(
+  `${sliceName}/getDeploymentDevices`,
+  (options, { dispatch, getState }) => {
+    const { id, page = defaultPage3, perPage = defaultPerPage3 } = options;
+    return general_api_default.get(`${import_constants5.deploymentsApiUrl}/deployments/${id}/devices/list?&page=${page}&per_page=${perPage}`).then((response) => {
+      const { devices: deploymentDevices = {} } = getState().deployments.byId[id] || {};
+      const devices = response.data.reduce((accu, item) => {
+        accu[item.id] = item;
+        const log = (deploymentDevices[item.id] || {}).log;
+        if (log) {
+          accu[item.id].log = log;
+        }
+        return accu;
+      }, {});
+      const selectedDeviceIds = Object.keys(devices);
+      let tasks = [
+        dispatch(
+          actions.receivedDeploymentDevices({
+            id,
+            devices,
+            selectedDeviceIds,
+            totalDeviceCount: Number(response.headers[import_constants5.headerNames.total])
+          })
+        )
+      ];
+      const devicesById = getDevicesById(getState());
+      const lackingData = selectedDeviceIds.reduce((accu, deviceId) => {
+        const device = devicesById[deviceId];
+        if (!device || !device.identity_data || !device.attributes || Object.keys(device.attributes).length === 0) {
+          accu.push(deviceId);
+        }
+        return accu;
+      }, []);
+      tasks = lackingData.reduce((accu, deviceId) => [...accu, dispatch(getDeviceById2(deviceId)), dispatch(getDeviceAuth(deviceId))], tasks);
+      return Promise.all(tasks);
+    });
+  }
+);
 var parseDeviceDeployment = ({
   deployment: { id, artifact_name: release, status: deploymentStatus },
   device: { created, deleted, id: deviceId, finished, status, log }
@@ -4537,44 +4324,44 @@ var parseDeviceDeployment = ({
     return accu;
   }, "")
 });
-var getDeviceDeployments = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/getDeviceDeployments`, (options, { dispatch }) => {
+var getDeviceDeployments = createAppAsyncThunk(`${sliceName}/getDeviceDeployments`, (options, { dispatch }) => {
   const { deviceId, filterSelection = [], page = defaultPage3, perPage = defaultPerPage3 } = options;
   const filters = filterSelection.map((item) => `&status=${item}`).join("");
-  return general_api_default.get(`${deploymentsApiUrl}/deployments/devices/${deviceId}?page=${page}&per_page=${perPage}${filters}`).then(
+  return general_api_default.get(`${import_constants5.deploymentsApiUrl}/deployments/devices/${deviceId}?page=${page}&per_page=${perPage}${filters}`).then(
     ({ data, headers }) => Promise.resolve(
       dispatch(
         receivedDevice({
           id: deviceId,
           deviceDeployments: data.map(parseDeviceDeployment),
-          deploymentsCount: Number(headers[headerNames.total])
+          deploymentsCount: Number(headers[import_constants5.headerNames.total])
         })
       )
     )
   ).catch((err) => commonErrorHandler(err, "There was an error retrieving the device deployment history:", dispatch));
 });
-var resetDeviceDeployments = (0, import_toolkit21.createAsyncThunk)(
-  `${sliceName2}/resetDeviceDeployments`,
-  (deviceId, { dispatch }) => general_api_default.delete(`${deploymentsApiUrl}/deployments/devices/${deviceId}/history`).then(() => Promise.resolve(dispatch(getDeviceDeployments({ deviceId })))).catch((err) => commonErrorHandler(err, "There was an error resetting the device deployment history:", dispatch))
+var resetDeviceDeployments = createAppAsyncThunk(
+  `${sliceName}/resetDeviceDeployments`,
+  (deviceId, { dispatch }) => general_api_default.delete(`${import_constants5.deploymentsApiUrl}/deployments/devices/${deviceId}/history`).then(() => Promise.resolve(dispatch(getDeviceDeployments({ deviceId })))).catch((err) => commonErrorHandler(err, "There was an error resetting the device deployment history:", dispatch))
 );
-var getSingleDeployment = (0, import_toolkit21.createAsyncThunk)(
-  `${sliceName2}/getSingleDeployment`,
-  (id, { dispatch, getState }) => general_api_default.get(`${deploymentsApiUrl}/deployments/${id}`).then(({ data }) => {
+var getSingleDeployment = createAppAsyncThunk(
+  `${sliceName}/getSingleDeployment`,
+  (id, { dispatch, getState }) => general_api_default.get(`${import_constants5.deploymentsApiUrl}/deployments/${id}`).then(({ data }) => {
     const { deployments } = transformDeployments([data], getState().deployments.byId);
-    return Promise.resolve(dispatch(actions2.receivedDeployment(deployments[id])));
+    return Promise.resolve(dispatch(actions.receivedDeployment(deployments[id])));
   })
 );
-var getDeviceLog = (0, import_toolkit21.createAsyncThunk)(
-  `${sliceName2}/getDeviceLog`,
-  ({ deploymentId, deviceId }, { dispatch }) => general_api_default.get(`${deploymentsApiUrl}/deployments/${deploymentId}/devices/${deviceId}/log`).catch((e) => {
+var getDeviceLog = createAppAsyncThunk(
+  `${sliceName}/getDeviceLog`,
+  ({ deploymentId, deviceId }, { dispatch }) => general_api_default.get(`${import_constants5.deploymentsApiUrl}/deployments/${deploymentId}/devices/${deviceId}/log`).catch((e) => {
     console.log("no log here", e);
     return Promise.reject();
   }).then(
-    ({ data: log }) => Promise.all([Promise.resolve(dispatch(actions2.receivedDeploymentDeviceLog({ id: deploymentId, deviceId, log }))), Promise.resolve(log)])
+    ({ data: log }) => Promise.all([Promise.resolve(dispatch(actions.receivedDeploymentDeviceLog({ id: deploymentId, deviceId, log }))), Promise.resolve(log)])
   )
 );
-var abortDeployment = (0, import_toolkit21.createAsyncThunk)(
-  `${sliceName2}/abortDeployment`,
-  (deploymentId, { dispatch, getState }) => general_api_default.put(`${deploymentsApiUrl}/deployments/${deploymentId}/status`, { status: "aborted" }).then(() => {
+var abortDeployment = createAppAsyncThunk(
+  `${sliceName}/abortDeployment`,
+  (deploymentId, { dispatch, getState }) => general_api_default.put(`${import_constants5.deploymentsApiUrl}/deployments/${deploymentId}/status`, { status: "aborted" }).then(() => {
     const deploymentsByStatus = getDeploymentsByStatus(getState());
     let status = DEPLOYMENT_STATES.pending;
     let index = deploymentsByStatus.pending.deploymentIds.findIndex((id) => id === deploymentId);
@@ -4590,21 +4377,21 @@ var abortDeployment = (0, import_toolkit21.createAsyncThunk)(
     }, {});
     const total = Math.max(deploymentsByStatus[status].total - 1, 0);
     return Promise.all([
-      dispatch(actions2.receivedDeployments(deployments)),
-      dispatch(actions2.receivedDeploymentsForStatus({ deploymentIds, status, total })),
-      dispatch(actions2.removedDeployment(deploymentId)),
+      dispatch(actions.receivedDeployments(deployments)),
+      dispatch(actions.receivedDeploymentsForStatus({ deploymentIds, status, total })),
+      dispatch(actions.removedDeployment(deploymentId)),
       dispatch(setSnackbar4("The deployment was successfully aborted"))
     ]);
   }).catch((err) => commonErrorHandler(err, "There was an error while aborting the deployment:", dispatch))
 );
-var updateDeploymentControlMap = (0, import_toolkit21.createAsyncThunk)(
-  `${sliceName2}/updateDeploymentControlMap`,
-  ({ deploymentId, updateControlMap }, { dispatch }) => general_api_default.patch(`${deploymentsApiUrl}/deployments/${deploymentId}`, { update_control_map: updateControlMap }).catch((err) => commonErrorHandler(err, "There was an error while updating the deployment status:", dispatch)).then(() => Promise.resolve(dispatch(getSingleDeployment(deploymentId))))
+var updateDeploymentControlMap = createAppAsyncThunk(
+  `${sliceName}/updateDeploymentControlMap`,
+  ({ deploymentId, updateControlMap }, { dispatch }) => general_api_default.patch(`${import_constants5.deploymentsApiUrl}/deployments/${deploymentId}`, { update_control_map: updateControlMap }).catch((err) => commonErrorHandler(err, "There was an error while updating the deployment status:", dispatch)).then(() => Promise.resolve(dispatch(getSingleDeployment(deploymentId))))
 );
-var setDeploymentsState = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/setDeploymentsState`, (selection, { dispatch, getState }) => {
+var setDeploymentsState = createAppAsyncThunk(`${sliceName}/setDeploymentsState`, (selection, { dispatch, getState }) => {
   const { page, perPage, ...selectionState } = selection;
   const currentState = getState().deployments.selectionState;
-  let nextState = {
+  const nextState = {
     ...currentState,
     ...selectionState,
     ...Object.keys(DEPLOYMENT_STATES).reduce((accu, item) => {
@@ -4619,7 +4406,7 @@ var setDeploymentsState = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/
       ...selectionState.general
     }
   };
-  let tasks = [dispatch(actions2.setDeploymentsState(nextState))];
+  const tasks = [dispatch(actions.setDeploymentsState(nextState))];
   if (nextState.selectedId && currentState.selectedId !== nextState.selectedId) {
     tasks.push(dispatch(getSingleDeployment(nextState.selectedId)));
   }
@@ -4640,34 +4427,32 @@ var mapExternalDeltaConfig = (config = {}) => deltaAttributeMappings.reduce((acc
   }
   return accu;
 }, {});
-var getDeploymentsConfig = (0, import_toolkit21.createAsyncThunk)(
-  `${sliceName2}/getDeploymentsConfig`,
-  (_, { dispatch, getState }) => general_api_default.get(`${deploymentsApiUrl}/config`).then(({ data }) => {
+var getDeploymentsConfig = createAppAsyncThunk(
+  `${sliceName}/getDeploymentsConfig`,
+  (_, { dispatch, getState }) => general_api_default.get(`${import_constants5.deploymentsApiUrl}/config`).then(({ data }) => {
     const oldConfig = getState().deployments.config;
     const { delta = {} } = data;
     const { binary_delta = {}, binary_delta_limits = {} } = delta;
-    const { xdelta_args = {}, timeout: timeoutConfig = oldConfig.binaryDelta.timeout } = binary_delta;
-    const { xdelta_args_limits = {}, timeout: timeoutLimit = oldConfig.binaryDeltaLimits.timeout } = binary_delta_limits;
+    const { xdelta_args = {} } = binary_delta;
+    const { xdelta_args_limits = {} } = binary_delta_limits;
     const config = {
       ...oldConfig,
       hasDelta: Boolean(delta.enabled),
       binaryDelta: {
         ...oldConfig.binaryDelta,
-        timeout: timeoutConfig,
         ...mapExternalDeltaConfig(xdelta_args)
       },
       binaryDeltaLimits: {
         ...oldConfig.binaryDeltaLimits,
-        timeout: timeoutLimit,
         ...mapExternalDeltaConfig(xdelta_args_limits)
       }
     };
-    return Promise.resolve(dispatch(actions2.setDeploymentsConfig(config)));
+    return Promise.resolve(dispatch(actions.setDeploymentsConfig(config)));
   })
 );
 var deepClean = (source) => Object.entries(source).reduce((accu, [key, value]) => {
   if (value !== void 0) {
-    let cleanedValue = typeof value === "object" ? deepClean(value) : value;
+    const cleanedValue = typeof value === "object" ? deepClean(value) : value;
     if (cleanedValue === void 0 || typeof cleanedValue === "object" && (0, import_helpers10.isEmpty)(cleanedValue)) {
       return accu;
     }
@@ -4675,32 +4460,34 @@ var deepClean = (source) => Object.entries(source).reduce((accu, [key, value]) =
   }
   return accu;
 }, void 0);
-var saveDeltaDeploymentsConfig = (0, import_toolkit21.createAsyncThunk)(`${sliceName2}/saveDeltaDeploymentsConfig`, (config, { dispatch, getState }) => {
-  const configChange = {
-    timeout: config.timeout,
-    xdelta_args: deltaAttributeMappings.reduce((accu, { here, there }) => {
-      if (config[here] !== void 0) {
-        accu[there] = config[here];
-      }
-      return accu;
-    }, {})
-  };
-  const result = deepClean(configChange);
-  if (!result) {
-    return Promise.resolve();
-  }
-  return general_api_default.put(`${deploymentsApiUrl}/config/binary_delta`, result).catch((err) => commonErrorHandler(err, "There was a problem storing your delta artifact generation configuration.", dispatch)).then(() => {
-    const oldConfig = getState().deployments.config;
-    const newConfig = {
-      ...oldConfig,
-      binaryDelta: {
-        ...oldConfig.binaryDelta,
-        ...config
-      }
+var saveDeltaDeploymentsConfig = createAppAsyncThunk(
+  `${sliceName}/saveDeltaDeploymentsConfig`,
+  (config, { dispatch, getState }) => {
+    const configChange = {
+      xdelta_args: deltaAttributeMappings.reduce((accu, { here, there }) => {
+        if (config[here] !== void 0) {
+          accu[there] = config[here];
+        }
+        return accu;
+      }, {})
     };
-    return Promise.all([dispatch(actions2.setDeploymentsConfig(newConfig)), dispatch(setSnackbar4("Settings saved successfully"))]);
-  });
-});
+    const result = deepClean(configChange);
+    if (!result) {
+      return Promise.resolve();
+    }
+    return general_api_default.put(`${import_constants5.deploymentsApiUrl}/config/binary_delta`, result).catch((err) => commonErrorHandler(err, "There was a problem storing your delta artifact generation configuration.", dispatch)).then(() => {
+      const oldConfig = getState().deployments.config;
+      const newConfig = {
+        ...oldConfig,
+        binaryDelta: {
+          ...oldConfig.binaryDelta,
+          ...config
+        }
+      };
+      return Promise.all([dispatch(actions.setDeploymentsConfig(newConfig)), dispatch(setSnackbar4("Settings saved successfully"))]);
+    });
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   abortDeployment,