@northern.tech/store 0.1.1 → 0.1.3

package/dist/chunk-YNVSU3AA.mjs

@@ -0,0 +1,2977 @@
+import {
+  v4_default
+} from "./chunk-N7G6QK2E.mjs";
+import {
+  getDeviceMonitorConfig,
+  getLatestDeviceAlerts
+} from "./chunk-G7LATUT6.mjs";
+import {
+  users_api_default
+} from "./chunk-IVSYYXTC.mjs";
+import {
+  general_api_default
+} from "./chunk-R2GBNXLV.mjs";
+import {
+  getAttrsEndpoint,
+  getOnboardingState,
+  getSearchEndpoint,
+  getTenantCapabilities,
+  getUserCapabilities
+} from "./chunk-RQOE5OOT.mjs";
+import {
+  getCurrentSession,
+  getCurrentUser,
+  getGlobalSettings,
+  getIdAttribute,
+  getOfflineThresholdSettings,
+  getRolesById,
+  getTooltipsState,
+  getUserSettings
+} from "./chunk-BRHSKNFC.mjs";
+import {
+  getAuditlogState,
+  getDeviceTwinIntegrations,
+  getOrganization,
+  getTenantsList
+} from "./chunk-HVHZG2H4.mjs";
+import {
+  getDeploymentsById,
+  getDeploymentsByStatus
+} from "./chunk-DZBVTSIX.mjs";
+import {
+  getDeviceById,
+  getDeviceFilters,
+  getDeviceListState,
+  getDevicesById,
+  getGroups,
+  getGroupsById,
+  getSelectedGroup
+} from "./chunk-ZIYGEXSJ.mjs";
+import {
+  getFeatures,
+  getSearchState
+} from "./chunk-C2YZYTJ6.mjs";
+import {
+  commonErrorFallback,
+  commonErrorHandler
+} from "./chunk-XYVPYFSM.mjs";
+import {
+  actions_default
+} from "./chunk-IPPIKGIB.mjs";
+import {
+  actions as actions6,
+  sliceName as sliceName6
+} from "./chunk-BJSH2G7W.mjs";
+import {
+  actions as actions5,
+  sliceName as sliceName5
+} from "./chunk-TD45YTYK.mjs";
+import {
+  actions as actions4,
+  sliceName as sliceName4
+} from "./chunk-M4U5R7A4.mjs";
+import {
+  actions as actions2,
+  sliceName as sliceName2
+} from "./chunk-6667TCAJ.mjs";
+import {
+  actions as actions3,
+  sliceName as sliceName3
+} from "./chunk-HRWZJQMH.mjs";
+import {
+  actions,
+  sliceName
+} from "./chunk-F37LUTBX.mjs";
+import {
+  cleanUp,
+  getSessionInfo,
+  maxSessionAge,
+  setSessionInfo
+} from "./chunk-HXPYJ6QN.mjs";
+import {
+  convertDeviceListStateToFilters,
+  extractErrorMessage,
+  filtersFilter,
+  getComparisonCompatibleVersion,
+  mapDeviceAttributes,
+  mapFiltersToTerms,
+  mapTermsToFilters,
+  mergePermissions,
+  preformatWithRequestID,
+  progress
+} from "./chunk-G32LAKW4.mjs";
+import {
+  ALL_DEVICE_STATES,
+  DEPLOYMENT_ROUTES,
+  DEPLOYMENT_STATES,
+  DEPLOYMENT_TYPES,
+  DEVICE_STATES,
+  OWN_USER_ID,
+  PermissionTypes,
+  READ_STATES,
+  SSO_TYPES,
+  TENANT_LIST_DEFAULT,
+  USER_LOGOUT,
+  auditLogsApiUrl,
+  defaultPermissionSets,
+  deploymentPrototype,
+  deploymentsApiUrl,
+  deploymentsApiUrlV2,
+  deviceAuthV2,
+  deviceConfig,
+  deviceConnect,
+  emptyFilter,
+  geoAttributes,
+  inventoryApiUrl,
+  inventoryApiUrlV2,
+  iotManagerBaseURL,
+  itemUiPermissionsReducer,
+  reportingApiUrl,
+  rolesById,
+  scopedPermissionAreas,
+  settingsKeys,
+  ssoIdpApiUrlv1,
+  tenantadmApiUrlv1,
+  tenantadmApiUrlv2,
+  twoFAStates,
+  uiPermissionsByArea,
+  uiPermissionsById,
+  useradmApiUrlv1,
+  useradmApiUrlv2
+} from "./chunk-ZNST5R6O.mjs";
+import {
+  rootfsImageVersion
+} from "./chunk-G4FGNSV3.mjs";
+import {
+  onboardingSteps,
+  orderedOnboardingSteps
+} from "./chunk-IU4OXOPA.mjs";
+import {
+  APPLICATION_JSON_CONTENT_TYPE,
+  APPLICATION_JWT_CONTENT_TYPE,
+  apiRoot,
+  defaultReports,
+  headerNames,
+  locations
+} from "./chunk-BOSBROA3.mjs";
+import {
+  ALL_DEVICES,
+  ALL_RELEASES,
+  DEVICE_FILTERING_OPTIONS,
+  DEVICE_LIST_DEFAULTS,
+  EXTERNAL_PROVIDER,
+  MAX_PAGE_SIZE,
+  SORTING_OPTIONS,
+  TIMEOUTS,
+  UNGROUPED_GROUP,
+  emptyRole,
+  emptyUiPermissions
+} from "./chunk-G3I53JGW.mjs";
+import {
+  __async,
+  __commonJS,
+  __objRest,
+  __require,
+  __spreadProps,
+  __spreadValues,
+  __toESM
+} from "./chunk-XWBD7VOK.mjs";
+
+// ../../node_modules/pluralize/pluralize.js
+var require_pluralize = __commonJS({
+  "../../node_modules/pluralize/pluralize.js"(exports, module) {
+    "use strict";
+    (function(root, pluralize2) {
+      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
+        module.exports = pluralize2();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize2();
+        });
+      } else {
+        root.pluralize = pluralize2();
+      }
+    })(exports, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token) return token;
+        if (word === word.toLowerCase()) return token.toLowerCase();
+        if (word === word.toUpperCase()) return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
+        return token.toLowerCase();
+      }
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word)) return replace(word, rule);
+        }
+        return word;
+      }
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
+      }
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) return true;
+          if (replaceMap.hasOwnProperty(token)) return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize2(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize2.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize2.addPluralRule(word, "$0");
+        pluralize2.addSingularRule(word, "$0");
+      };
+      pluralize2.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
+      };
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["passerby", "passersby"]
+      ].forEach(function(rule) {
+        return pluralize2.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize2.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize2.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        /pok[eé]mon$/i,
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize2.addUncountableRule);
+      return pluralize2;
+    });
+  }
+});
+
+// src/deploymentsSlice/thunks.ts
+import { deepCompare, isEmpty, standardizePhases, startTimeSort } from "@northern.tech/utils/helpers";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import isUUID from "validator/lib/isUUID";
+var { receivedDevice, setSnackbar } = actions_default;
+var { page: defaultPage, perPage: defaultPerPage } = DEVICE_LIST_DEFAULTS;
+var deriveDeploymentGroup = ({ filter = {}, group, groups = [], name }) => group || groups.length === 1 && !isUUID(name) ? groups[0] : filter.name;
+var transformDeployments = (deployments, deploymentsById) => deployments.sort(startTimeSort).reduce(
+  (accu, item) => {
+    var _a, _b;
+    const filter = (_a = item.filter) != null ? _a : {};
+    let deployment = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, deploymentPrototype), deploymentsById[item.id]), item), {
+      filter: item.filter ? __spreadProps(__spreadValues({}, filter), { name: (_b = filter.name) != null ? _b : filter.id, filters: mapTermsToFilters(filter.terms) }) : void 0,
+      name: decodeURIComponent(item.name)
+    });
+    deployment = __spreadProps(__spreadValues({}, deployment), { group: deriveDeploymentGroup(deployment) });
+    accu.deployments[item.id] = deployment;
+    accu.deploymentIds.push(item.id);
+    return accu;
+  },
+  { deployments: {}, deploymentIds: [] }
+);
+var getDeploymentsByStatus2 = createAsyncThunk(`${sliceName2}/getDeploymentsByStatus`, (options = {}, { dispatch, getState }) => {
+  const { status, page = defaultPage, per_page = defaultPerPage, 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)));
+      }
+      return accu;
+    }, tasks);
+    if (shouldSelect) {
+      tasks.push(dispatch(actions2.selectDeploymentsForStatus({ deploymentIds, status, total })));
+    }
+    tasks.push({ deploymentIds, total });
+    return Promise.all(tasks);
+  });
+});
+var MAX_PREVIOUS_PHASES_COUNT = 5;
+var createDeployment = 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);
+  }
+  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 = __spreadProps(__spreadValues({}, 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(setSnackbar("Deployment created successfully", TIMEOUTS.fiveSeconds))
+    ];
+    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 = standardizePhases(phases);
+        let prevPhases = previousPhases.map(standardizePhases);
+        if (!prevPhases.find((previousPhaseList) => previousPhaseList.every((oldPhase) => standardPhases.find((phase) => deepCompare(phase, oldPhase))))) {
+          prevPhases.push(standardPhases);
+        }
+        newSettings.previousPhases = prevPhases.slice(-1 * MAX_PREVIOUS_PHASES_COUNT);
+      }
+      tasks.push(dispatch(saveGlobalSettings(newSettings)));
+    }
+    return Promise.all(tasks);
+  });
+});
+var getDeploymentDevices = createAsyncThunk(`${sliceName2}/getDeploymentDevices`, (options, { dispatch, getState }) => {
+  const { id, page = defaultPage, perPage = defaultPerPage } = 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);
+      }
+      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 }
+}) => ({
+  id,
+  release,
+  created,
+  deleted,
+  deviceId,
+  finished,
+  status,
+  log,
+  route: Object.values(DEPLOYMENT_ROUTES).reduce((accu, { key, states }) => {
+    if (!accu) {
+      return states.includes(deploymentStatus) ? key : accu;
+    }
+    return accu;
+  }, "")
+});
+var getDeviceDeployments = createAsyncThunk(`${sliceName2}/getDeviceDeployments`, (options, { dispatch }) => {
+  const { deviceId, filterSelection = [], page = defaultPage, perPage = defaultPerPage } = 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(
+    ({ data, headers }) => Promise.resolve(
+      dispatch(
+        receivedDevice({
+          id: deviceId,
+          deviceDeployments: data.map(parseDeviceDeployment),
+          deploymentsCount: Number(headers[headerNames.total])
+        })
+      )
+    )
+  ).catch((err) => commonErrorHandler(err, "There was an error retrieving the device deployment history:", dispatch));
+});
+var resetDeviceDeployments = 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 getSingleDeployment = createAsyncThunk(
+  `${sliceName2}/getSingleDeployment`,
+  (id, { dispatch, getState }) => general_api_default.get(`${deploymentsApiUrl}/deployments/${id}`).then(({ data }) => {
+    const { deployments } = transformDeployments([data], getState().deployments.byId);
+    return Promise.resolve(dispatch(actions2.receivedDeployment(deployments[id])));
+  })
+);
+var getDeviceLog = createAsyncThunk(
+  `${sliceName2}/getDeviceLog`,
+  ({ deploymentId, deviceId }, { dispatch }) => general_api_default.get(`${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)])
+  )
+);
+var abortDeployment = createAsyncThunk(
+  `${sliceName2}/abortDeployment`,
+  (deploymentId, { dispatch, getState }) => general_api_default.put(`${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);
+    if (index < 0) {
+      status = DEPLOYMENT_STATES.inprogress;
+      index = deploymentsByStatus.inprogress.deploymentIds.findIndex((id) => id === deploymentId);
+    }
+    const deploymentIds = [...deploymentsByStatus[status].deploymentIds.slice(0, index), ...deploymentsByStatus[status].deploymentIds.slice(index + 1)];
+    const deploymentsById = getDeploymentsById(getState());
+    const deployments = deploymentIds.reduce((accu, id) => {
+      accu[id] = deploymentsById[id];
+      return accu;
+    }, {});
+    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(setSnackbar("The deployment was successfully aborted"))
+    ]);
+  }).catch((err) => commonErrorHandler(err, "There was an error while aborting the deployment:", dispatch))
+);
+var updateDeploymentControlMap = 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 setDeploymentsState = createAsyncThunk(`${sliceName2}/setDeploymentsState`, (selection, { dispatch, getState }) => {
+  const _a = selection, { page, perPage } = _a, selectionState = __objRest(_a, ["page", "perPage"]);
+  const currentState = getState().deployments.selectionState;
+  let nextState = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, currentState), selectionState), Object.keys(DEPLOYMENT_STATES).reduce((accu, item) => {
+    accu[item] = __spreadValues(__spreadValues({}, currentState[item]), selectionState[item]);
+    return accu;
+  }, {})), {
+    general: __spreadValues(__spreadValues({}, currentState.general), selectionState.general)
+  });
+  let tasks = [dispatch(actions2.setDeploymentsState(nextState))];
+  if (nextState.selectedId && currentState.selectedId !== nextState.selectedId) {
+    tasks.push(dispatch(getSingleDeployment(nextState.selectedId)));
+  }
+  return Promise.all(tasks);
+});
+var deltaAttributeMappings = [
+  { here: "compressionLevel", there: "compression_level" },
+  { here: "disableChecksum", there: "disable_checksum" },
+  { here: "disableDecompression", there: "disable_external_decompression" },
+  { here: "sourceWindow", there: "source_window_size" },
+  { here: "inputWindow", there: "input_window_size" },
+  { here: "duplicatesWindow", there: "compression_duplicates_window" },
+  { here: "instructionBuffer", there: "instruction_buffer_size" }
+];
+var mapExternalDeltaConfig = (config = {}) => deltaAttributeMappings.reduce((accu, { here, there }) => {
+  if (config[there] !== void 0) {
+    accu[here] = config[there];
+  }
+  return accu;
+}, {});
+var getDeploymentsConfig = createAsyncThunk(
+  `${sliceName2}/getDeploymentsConfig`,
+  (_, { dispatch, getState }) => general_api_default.get(`${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 config = __spreadProps(__spreadValues({}, oldConfig), {
+      hasDelta: Boolean(delta.enabled),
+      binaryDelta: __spreadValues(__spreadProps(__spreadValues({}, oldConfig.binaryDelta), {
+        timeout: timeoutConfig
+      }), mapExternalDeltaConfig(xdelta_args)),
+      binaryDeltaLimits: __spreadValues(__spreadProps(__spreadValues({}, oldConfig.binaryDeltaLimits), {
+        timeout: timeoutLimit
+      }), mapExternalDeltaConfig(xdelta_args_limits))
+    });
+    return Promise.resolve(dispatch(actions2.setDeploymentsConfig(config)));
+  })
+);
+var deepClean = (source) => Object.entries(source).reduce((accu, [key, value]) => {
+  if (value !== void 0) {
+    let cleanedValue = typeof value === "object" ? deepClean(value) : value;
+    if (cleanedValue === void 0 || typeof cleanedValue === "object" && isEmpty(cleanedValue)) {
+      return accu;
+    }
+    accu = __spreadProps(__spreadValues({}, accu != null ? accu : {}), { [key]: cleanedValue });
+  }
+  return accu;
+}, void 0);
+var saveDeltaDeploymentsConfig = 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 = __spreadProps(__spreadValues({}, oldConfig), {
+      binaryDelta: __spreadValues(__spreadValues({}, oldConfig.binaryDelta), config)
+    });
+    return Promise.all([dispatch(actions2.setDeploymentsConfig(newConfig)), dispatch(setSnackbar("Settings saved successfully"))]);
+  });
+});
+
+// src/devicesSlice/thunks.tsx
+import React from "react";
+import { Link } from "react-router-dom";
+var import_pluralize = __toESM(require_pluralize());
+import { attributeDuplicateFilter, deepCompare as deepCompare2, getSnackbarMessage } from "@northern.tech/utils/helpers";
+import { createAsyncThunk as createAsyncThunk2 } from "@reduxjs/toolkit";
+import { isCancel } from "axios";
+var { cleanUpUpload, initUpload, setSnackbar: setSnackbar2, uploadProgress } = actions_default;
+var { page: defaultPage2, perPage: defaultPerPage2 } = DEVICE_LIST_DEFAULTS;
+var defaultAttributes = [
+  { scope: "identity", attribute: "status" },
+  { scope: "inventory", attribute: "artifact_name" },
+  { scope: "inventory", attribute: "device_type" },
+  { scope: "inventory", attribute: "mender_is_gateway" },
+  { scope: "inventory", attribute: "mender_gateway_system_id" },
+  { scope: "inventory", attribute: rootfsImageVersion },
+  { scope: "monitor", attribute: "alerts" },
+  { scope: "system", attribute: "created_ts" },
+  { scope: "system", attribute: "updated_ts" },
+  { scope: "system", attribute: "check_in_time" },
+  { scope: "system", attribute: "group" },
+  { scope: "tags", attribute: "name" }
+];
+var getGroups2 = createAsyncThunk2(
+  `${sliceName3}/getGroups`,
+  (_, { dispatch, getState }) => general_api_default.get(`${inventoryApiUrl}/groups`).then((res) => {
+    const state = getGroupsById(getState());
+    const dynamicGroups = Object.entries(state).reduce((accu, [id, group]) => {
+      var _a;
+      if (group.id || ((_a = group.filters) == null ? void 0 : _a.length) && id !== UNGROUPED_GROUP.id) {
+        accu[id] = group;
+      }
+      return accu;
+    }, {});
+    const groups = res.data.reduce((accu, group) => {
+      accu[group] = __spreadValues({ deviceIds: [], filters: [], total: 0 }, state[group]);
+      return accu;
+    }, dynamicGroups);
+    const filters = [{ key: "group", value: res.data, operator: DEVICE_FILTERING_OPTIONS.$nin.key, scope: "system" }];
+    return Promise.all([
+      dispatch(actions3.receivedGroups(groups)),
+      dispatch(getDevicesByStatus({ filterSelection: filters, group: 0, page: 1, perPage: 1, status: void 0 }))
+    ]).then((promises) => {
+      const devicesRetrieval = promises[promises.length - 1] || [];
+      const { payload } = devicesRetrieval || {};
+      const result = payload[payload.length - 1] || {};
+      if (!result.total) {
+        return Promise.resolve();
+      }
+      return Promise.resolve(
+        dispatch(
+          actions3.addGroup({
+            groupName: UNGROUPED_GROUP.id,
+            group: { filters: [{ key: "group", value: res.data, operator: DEVICE_FILTERING_OPTIONS.$nin.key, scope: "system" }] }
+          })
+        )
+      );
+    });
+  })
+);
+var addDevicesToGroup = createAsyncThunk2(
+  `${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())) : {})
+);
+var removeDevicesFromGroup = createAsyncThunk2(
+  `${sliceName3}/removeDevicesFromGroup`,
+  ({ group, deviceIds }, { dispatch }) => general_api_default.delete(`${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))
+    ])
+  )
+);
+var getGroupNotification = (newGroup, selectedGroup) => {
+  const successMessage = "The group was updated successfully";
+  if (newGroup === selectedGroup) {
+    return [successMessage, TIMEOUTS.fiveSeconds];
+  }
+  return [
+    /* @__PURE__ */ React.createElement(React.Fragment, null, successMessage, " - ", /* @__PURE__ */ React.createElement(Link, { to: `/devices?inventory=group:eq:${newGroup}` }, "click here"), " to see it."),
+    5e3,
+    void 0,
+    void 0,
+    () => {
+    }
+  ];
+};
+var addStaticGroup = createAsyncThunk2(
+  `${sliceName3}/addStaticGroup`,
+  ({ group, devices }, { dispatch, getState }) => Promise.resolve(dispatch(addDevicesToGroup({ group, deviceIds: devices.map(({ id }) => id), isCreation: true }))).then(
+    () => Promise.resolve(
+      dispatch(
+        actions3.addGroup({
+          group: __spreadValues({ deviceIds: [], total: 0, filters: [] }, getState().devices.groups.byId[group]),
+          groupName: group
+        })
+      )
+    ).then(
+      () => Promise.all([
+        dispatch(setDeviceListState({ setOnly: true })),
+        dispatch(getGroups2()),
+        dispatch(setSnackbar2(...getGroupNotification(group, getState().devices.groups.selectedGroup)))
+      ])
+    )
+  ).catch((err) => commonErrorHandler(err, `Group could not be updated:`, dispatch))
+);
+var removeStaticGroup = createAsyncThunk2(
+  `${sliceName3}/removeStaticGroup`,
+  (groupName, { dispatch }) => general_api_default.delete(`${inventoryApiUrl}/groups/${groupName}`).then(
+    () => Promise.all([
+      dispatch(actions3.removeGroup(groupName)),
+      dispatch(getGroups2()),
+      dispatch(setSnackbar2("Group was removed successfully", TIMEOUTS.fiveSeconds))
+    ])
+  )
+);
+var getDynamicGroups = createAsyncThunk2(
+  `${sliceName3}/getDynamicGroups`,
+  (_, { dispatch, getState }) => general_api_default.get(`${inventoryApiUrlV2}/filters?per_page=${MAX_PAGE_SIZE}`).then(({ data: filters }) => {
+    const state = getGroupsById(getState());
+    const staticGroups = Object.entries(state).reduce((accu, [id, group]) => {
+      var _a;
+      if (!(group.id || ((_a = group.filters) == null ? void 0 : _a.length))) {
+        accu[id] = group;
+      }
+      return accu;
+    }, {});
+    const groups = (filters || []).reduce((accu, filter) => {
+      accu[filter.name] = __spreadProps(__spreadValues({
+        deviceIds: [],
+        total: 0
+      }, state[filter.name]), {
+        id: filter.id,
+        filters: mapTermsToFilters(filter.terms)
+      });
+      return accu;
+    }, staticGroups);
+    return Promise.resolve(dispatch(actions3.receivedGroups(groups)));
+  }).catch(() => console.log("Dynamic group retrieval failed - likely accessing a non-enterprise backend"))
+);
+var addDynamicGroup = createAsyncThunk2(
+  `${sliceName3}/addDynamicGroup`,
+  ({ groupName, filterPredicates }, { dispatch, getState }) => general_api_default.post(`${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),
+            filters: filterPredicates
+          }
+        })
+      )
+    ).then(() => {
+      const { cleanedFilters } = getGroupFilters(groupName, getState().devices.groups);
+      return Promise.all([
+        dispatch(actions3.setDeviceFilters(cleanedFilters)),
+        dispatch(setSnackbar2(...getGroupNotification(groupName, getState().devices.groups.selectedGroup))),
+        dispatch(getDynamicGroups())
+      ]);
+    })
+  ).catch((err) => commonErrorHandler(err, `Group could not be updated:`, dispatch))
+);
+var updateDynamicGroup = createAsyncThunk2(`${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 = createAsyncThunk2(`${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))])
+  );
+});
+var getGroupFilters = (group, groupsState, filters = []) => {
+  var _a;
+  const groupName = group === UNGROUPED_GROUP.id || group === UNGROUPED_GROUP.name ? UNGROUPED_GROUP.id : group;
+  const selectedGroup = groupsState.byId[groupName];
+  const groupFilterLength = ((_a = selectedGroup == null ? void 0 : selectedGroup.filters) == null ? void 0 : _a.length) || 0;
+  const cleanedFilters = groupFilterLength ? [...filters, ...selectedGroup.filters].filter(filtersFilter) : filters;
+  return { cleanedFilters, groupName, selectedGroup, groupFilterLength };
+};
+var selectGroup = createAsyncThunk2(`${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 })));
+  }
+  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) => {
+    var _a, _b, _c;
+    const stateDevice = getDeviceById(state, device.id);
+    const {
+      attributes: storedAttributes = {},
+      identity_data: storedIdentity = {},
+      monitor: storedMonitor = {},
+      tags: storedTags = {},
+      group: storedGroup
+    } = stateDevice;
+    const { identity, inventory, monitor, system = {}, tags } = mapDeviceAttributes(device.attributes);
+    device.tags = __spreadValues(__spreadValues({}, storedTags), tags);
+    device.group = (_a = system.group) != null ? _a : storedGroup;
+    device.monitor = __spreadValues(__spreadValues({}, storedMonitor), monitor);
+    device.identity_data = __spreadValues(__spreadValues(__spreadValues({}, storedIdentity), identity), device.identity_data ? device.identity_data : {});
+    device.status = status ? status : device.status || identity.status;
+    device.check_in_time_rounded = (_b = system.check_in_time) != null ? _b : stateDevice.check_in_time_rounded;
+    device.check_in_time_exact = (_c = device.check_in_time) != null ? _c : stateDevice.check_in_time_exact;
+    device.created_ts = getEarliestTs(getEarliestTs(system.created_ts, device.created_ts), stateDevice.created_ts);
+    device.updated_ts = device.attributes ? device.updated_ts : stateDevice.updated_ts;
+    device.isNew = new Date(device.created_ts) > new Date(state.app.newThreshold);
+    device.isOffline = new Date(device.check_in_time_rounded) < new Date(state.app.offlineThreshold) || device.check_in_time_rounded === void 0;
+    device.attributes = device.attributes ? __spreadValues(__spreadValues({}, storedAttributes), inventory) : storedAttributes;
+    accu.devicesById[device.id] = __spreadValues(__spreadValues({}, stateDevice), device);
+    accu.ids.push(device.id);
+    return accu;
+  },
+  { ids, devicesById: {} }
+);
+var getGroupDevices = createAsyncThunk2(`${sliceName3}/getGroupDevices`, (options, { dispatch, getState }) => {
+  const _a = options, { group, shouldIncludeAllStates } = _a, remainder = __objRest(_a, ["group", "shouldIncludeAllStates"]);
+  const { cleanedFilters: filterSelection } = getGroupFilters(group, getState().devices.groups);
+  return Promise.resolve(
+    dispatch(getDevicesByStatus(__spreadProps(__spreadValues({}, remainder), { filterSelection, group, status: shouldIncludeAllStates ? void 0 : DEVICE_STATES.accepted })))
+  ).unwrap().then((results) => {
+    if (!group) {
+      return Promise.resolve();
+    }
+    const { deviceAccu, total } = results[results.length - 1];
+    const stateGroup = getState().devices.groups.byId[group];
+    if (!stateGroup && !total && !deviceAccu.ids.length) {
+      return Promise.resolve();
+    }
+    return Promise.resolve(
+      dispatch(
+        actions3.addGroup({
+          group: {
+            deviceIds: deviceAccu.ids.length === total || deviceAccu.ids.length > (stateGroup == null ? void 0 : stateGroup.deviceIds) ? deviceAccu.ids : stateGroup.deviceIds,
+            total
+          },
+          groupName: group
+        })
+      )
+    );
+  });
+});
+var getAllGroupDevices = createAsyncThunk2(`${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 = defaultPage2, 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);
+    }
+    return Promise.resolve(dispatch(actions3.addGroup({ group: { deviceIds: deviceAccu.ids, total: deviceAccu.ids.length }, groupName: group })));
+  });
+  return getAllDevices();
+});
+var getAllDynamicGroupDevices = createAsyncThunk2(`${sliceName3}/getAllDynamicGroupDevices`, (group, { dispatch, getState }) => {
+  if (!!group && (!getGroupsById(getState())[group] || !getGroupsById(getState())[group].filters.length)) {
+    return Promise.resolve();
+  }
+  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 = defaultPage2, 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);
+    }
+    return Promise.resolve(dispatch(actions3.addGroup({ group: { deviceIds: deviceAccu.ids, total }, groupName: group })));
+  });
+  return getAllDevices();
+});
+var getDeviceById2 = createAsyncThunk2(
+  `${sliceName3}/getDeviceById`,
+  (id, { dispatch, getState }) => general_api_default.get(`${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 = extractErrorMessage(err);
+    if (errMsg.includes("Not Found")) {
+      console.log(`${id} does not have any inventory information`);
+      const device = reduceReceivedDevices(
+        [
+          {
+            id,
+            attributes: [
+              { name: "status", value: "decomissioned", scope: "identity" },
+              { name: "decomissioned", value: "true", scope: "inventory" }
+            ]
+          }
+        ],
+        [],
+        getState()
+      ).devicesById[id];
+      dispatch(actions3.receivedDevice(device));
+    }
+  })
+);
+var getDeviceInfo = createAsyncThunk2(`${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)) {
+    tasks.push(dispatch(getDeviceConfig(deviceId)));
+  }
+  if (device.status === DEVICE_STATES.accepted) {
+    tasks.push(dispatch(getDeviceById2(deviceId)));
+    if (hasDeviceConnect) {
+      tasks.push(dispatch(getDeviceConnect(deviceId)));
+    }
+    if (hasMonitor) {
+      tasks.push(dispatch(getLatestDeviceAlerts({ id: deviceId })));
+      tasks.push(dispatch(getDeviceMonitorConfig(deviceId)));
+    }
+  }
+  return Promise.all(tasks);
+});
+var deriveInactiveDevices = createAsyncThunk2(`${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 = createAsyncThunk2(
+  `${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" }]),
+    attributes: defaultAttributes
+  }).then((response) => {
+    const count = Number(response.headers[headerNames.total]);
+    if (status) {
+      return dispatch(actions3.setDevicesCountByStatus({ count, status }));
+    }
+    return dispatch(actions3.setTotalDevices(count));
+  })
+);
+var getAllDeviceCounts = createAsyncThunk2(
+  `${sliceName3}/getAllDeviceCounts`,
+  (_, { dispatch }) => Promise.all([DEVICE_STATES.accepted, DEVICE_STATES.pending].map((status) => dispatch(getDeviceCount(status))))
+);
+var getDeviceLimit = createAsyncThunk2(
+  `${sliceName3}/getDeviceLimit`,
+  (_, { dispatch }) => general_api_default.get(`${deviceAuthV2}/limits/max_devices`).then((res) => dispatch(actions3.setDeviceLimit(res.data.limit)))
+);
+var setDeviceListState = createAsyncThunk2(
+  `${sliceName3}/setDeviceListState`,
+  (_a, { dispatch, getState }) => {
+    var _b = _a, { shouldSelectDevices = true, forceRefresh, fetchAuth = true } = _b, selectionState = __objRest(_b, ["shouldSelectDevices", "forceRefresh", "fetchAuth"]);
+    var _c;
+    const currentState = getDeviceListState(getState());
+    const refreshTrigger = forceRefresh ? !currentState.refreshTrigger : selectionState.refreshTrigger;
+    let nextState = __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, currentState), {
+      setOnly: false,
+      refreshTrigger
+    }), selectionState), {
+      sort: __spreadValues(__spreadValues({}, currentState.sort), selectionState.sort)
+    });
+    let tasks = [];
+    const _a2 = currentState, { isLoading: currentLoading, deviceIds: currentDevices, selection: currentSelection } = _a2, currentRequestState = __objRest(_a2, ["isLoading", "deviceIds", "selection"]);
+    const _b2 = nextState, { isLoading: nextLoading, deviceIds: nextDevices, selection: nextSelection } = _b2, nextRequestState = __objRest(_b2, ["isLoading", "deviceIds", "selection"]);
+    if (!nextState.setOnly && !deepCompare2(currentRequestState, nextRequestState)) {
+      const { direction: sortDown = SORTING_OPTIONS.desc, key: sortCol, scope: sortScope } = (_c = nextState.sort) != null ? _c : {};
+      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(getDevicesByStatus(__spreadProps(__spreadValues({}, 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 getDevicesByStatus = createAsyncThunk2(`${sliceName3}/getDevicesByStatus`, (options, { dispatch, getState }) => {
+  const {
+    status,
+    fetchAuth = true,
+    filterSelection,
+    group,
+    selectedIssues = [],
+    page = defaultPage2,
+    perPage = defaultPerPage2,
+    sortOptions = [],
+    selectedAttributes = []
+  } = options;
+  const state = getState();
+  const { applicableFilters, filterTerms } = convertDeviceListStateToFilters({
+    filters: filterSelection != null ? filterSelection : getDeviceFilters(state),
+    group: group != null ? 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)));
+    }
+    tasks.push(Promise.resolve({ deviceAccu, total: Number(response.headers[headerNames.total]) }));
+    return Promise.all(tasks);
+  }).catch((err) => commonErrorHandler(err, `${status} devices couldn't be loaded.`, dispatch, commonErrorFallback));
+});
+var getAllDevicesByStatus = createAsyncThunk2(`${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) => {
+    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) {
+      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 = createAsyncThunk2(`${sliceName3}/searchDevices`, (passedOptions = {}, { dispatch, getState }) => {
+  const state = getState();
+  let options = __spreadValues(__spreadValues({}, state.app.searchState), passedOptions);
+  const { page = defaultPage2, searchTerm, sortOptions = [] } = options;
+  const { columnSelection = [] } = getUserSettings(state);
+  const selectedAttributes = columnSelection.map((column) => ({ attribute: column.key, scope: column.scope }));
+  const attributes = attributeDuplicateFilter([...defaultAttributes, getIdAttribute(state), ...selectedAttributes], "attribute");
+  return general_api_default.post(getSearchEndpoint(getState()), {
+    page,
+    per_page: 10,
+    filters: [],
+    sort: sortOptions,
+    text: searchTerm,
+    attributes
+  }).then((response) => {
+    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]) })
+    ]);
+  }).catch((err) => commonErrorHandler(err, `devices couldn't be searched.`, dispatch, commonErrorFallback));
+});
+var ATTRIBUTE_LIST_CUTOFF = 100;
+var attributeReducer = (attributes = []) => attributes.slice(0, ATTRIBUTE_LIST_CUTOFF).reduce(
+  (accu, { name, scope }) => {
+    if (!accu[scope]) {
+      accu[scope] = [];
+    }
+    accu[scope].push(name);
+    return accu;
+  },
+  { identity: [], inventory: [], system: [], tags: [] }
+);
+var getDeviceAttributes = createAsyncThunk2(
+  `${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 = createAsyncThunk2(
+  `${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 REPORT_CHART_SIZE_LIMIT = 6;
+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 = createAsyncThunk2(`${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 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;
+    }
+    accu[item.attributes[effectiveAttribute]] = accu[item.attributes[effectiveAttribute]] + 1;
+    return accu;
+  }, {});
+  const distributionByAttributeSorted = Object.entries(distributionByAttribute).sort((pairA, pairB) => pairB[1] - pairA[1]);
+  const items = distributionByAttributeSorted.map(([key, count]) => ({ key, count }));
+  const dataCount = items.reduce((accu, item) => accu + item.count, 0);
+  const otherCount = (groups[group] ? total : totalDeviceCount) - dataCount;
+  return { items, otherCount, total: otherCount + dataCount };
+};
+var deriveReportsData = createAsyncThunk2(`${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));
+  return Promise.resolve(dispatch(actions3.setDeviceReports(newReports)));
+});
+var getReportsDataWithoutBackendSupport = createAsyncThunk2(
+  `${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 getDeviceConnect = createAsyncThunk2(
+  `${sliceName3}/getDeviceConnect`,
+  (id, { dispatch }) => general_api_default.get(`${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 getSessionDetails = createAsyncThunk2(`${sliceName3}/getSessionDetails`, ({ sessionId, deviceId, userId, startDate, endDate }) => {
+  const createdAfter = startDate ? `&created_after=${Math.round(Date.parse(startDate) / 1e3)}` : "";
+  const createdBefore = endDate ? `&created_before=${Math.round(Date.parse(endDate) / 1e3)}` : "";
+  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) => {
+          var _a, _b;
+          if ((_b = (_a = item.meta) == null ? void 0 : _a.session_id) == null ? void 0 : _b.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 = createAsyncThunk2(
+  `${sliceName3}/getDeviceFileDownloadLink`,
+  ({ deviceId, path }) => Promise.resolve(`${window.location.origin}${deviceConnect}/devices/${deviceId}/download?path=${encodeURIComponent(path)}`)
+);
+var deviceFileUpload = createAsyncThunk2(`${sliceName3}/deviceFileUpload`, ({ deviceId, path, file }, { dispatch }) => {
+  let formData = new FormData();
+  formData.append("path", path);
+  formData.append("file", file);
+  const uploadId = v4_default();
+  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(uploadProgress({ id: uploadId, progress: progress(e) })),
+      cancelSource.signal
+    )
+  ]).then(() => Promise.resolve(dispatch(setSnackbar2("Upload successful", TIMEOUTS.fiveSeconds)))).catch((err) => {
+    if (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 = createAsyncThunk2(
+  `${sliceName3}/getDeviceAuth`,
+  (id, { dispatch }) => dispatch(getDevicesWithAuth([{ id }])).unwrap().then((results) => {
+    if (results[results.length - 1]) {
+      return Promise.resolve(results[results.length - 1][0]);
+    }
+    return Promise.resolve();
+  })
+);
+var getDevicesWithAuth = createAsyncThunk2(
+  `${sliceName3}/getDevicesWithAuth`,
+  (devices, { dispatch, getState }) => devices.length ? general_api_default.get(`${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 = createAsyncThunk2(
+  `${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 })))
+);
+var updateDevicesAuth = createAsyncThunk2(`${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 = getSnackbarMessage(skipped, count);
+      return dispatch(setSnackbar2(message));
+    });
+  });
+});
+var deleteAuthset = createAsyncThunk2(
+  `${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 })))
+);
+var preauthDevice = createAsyncThunk2(
+  `${sliceName3}/preauthDevice`,
+  (authset, { dispatch }) => general_api_default.post(`${deviceAuthV2}/devices`, authset).catch((err) => {
+    if (err.response.status === 409) {
+      return Promise.reject("A device with a matching identity data set already exists");
+    }
+    return commonErrorHandler(err, "The device could not be added:", dispatch);
+  }).then(() => Promise.resolve(dispatch(setSnackbar2("Device was successfully added to the preauthorization list", TIMEOUTS.fiveSeconds))))
+);
+var decommissionDevice = createAsyncThunk2(
+  `${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 })))
+);
+var getDeviceConfig = createAsyncThunk2(
+  `${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) => {
+    var _a, _b;
+    if (((_b = (_a = err.response) == null ? void 0 : _a.data) == null ? void 0 : _b.error.status_code) !== 404) {
+      return commonErrorHandler(err, `There was an error retrieving the configuration for device ${deviceId}.`, dispatch, commonErrorFallback);
+    }
+  })
+);
+var setDeviceConfig = createAsyncThunk2(
+  `${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))))
+);
+var applyDeviceConfig = createAsyncThunk2(
+  `${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 }) => {
+    var _a;
+    const device = getDeviceById(getState(), deviceId);
+    const { canManageUsers } = getUserCapabilities(getState());
+    let tasks = [
+      dispatch(actions3.receivedDevice(__spreadProps(__spreadValues({}, device), { config: __spreadProps(__spreadValues({}, device.config), { deployment_id: data.deployment_id }) }))),
+      new Promise((resolve) => setTimeout(() => resolve(dispatch(getSingleDeployment(data.deployment_id))), TIMEOUTS.oneSecond))
+    ];
+    if (isDefault && canManageUsers) {
+      const { previous } = (_a = getGlobalSettings(getState()).defaultDeviceConfig) != null ? _a : {};
+      tasks.push(dispatch(saveGlobalSettings({ defaultDeviceConfig: { current: config, previous } })));
+    }
+    return Promise.all(tasks);
+  })
+);
+var setDeviceTags = createAsyncThunk2(
+  `${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) => {
+      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(__spreadProps(__spreadValues({}, device), { id: deviceId, tags }))), dispatch(setSnackbar2("Device name changed"))]));
+    })
+  )
+);
+var getDeviceTwin = createAsyncThunk2(`${sliceName3}/getDeviceTwin`, ({ deviceId, integration }, { dispatch, getState }) => {
+  let providerResult = {};
+  return general_api_default.get(`${iotManagerBaseURL}/devices/${deviceId}/state`).then(({ data }) => {
+    providerResult = __spreadProps(__spreadValues({}, data), { twinError: "" });
+  }).catch((err) => {
+    providerResult = {
+      twinError: `There was an error getting the ${EXTERNAL_PROVIDER[integration.provider].twinTitle.toLowerCase()} for device ${deviceId}. ${err}`
+    };
+  }).finally(() => {
+    const device = getDeviceById(getState(), deviceId);
+    Promise.resolve(dispatch(actions3.receivedDevice(__spreadProps(__spreadValues({}, device), { twinsByIntegration: __spreadValues(__spreadValues({}, device.twinsByIntegration), providerResult) }))));
+  });
+});
+var setDeviceTwin = createAsyncThunk2(
+  `${sliceName3}/setDeviceTwin`,
+  ({ deviceId, integration, settings }, { dispatch, getState }) => general_api_default.put(`${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}.`,
+      dispatch
+    )
+  ).then(() => {
+    const device = getDeviceById(getState(), deviceId);
+    const { twinsByIntegration = {} } = device;
+    const { [integration.id]: currentState = {} } = twinsByIntegration;
+    return Promise.resolve(
+      dispatch(actions3.receivedDevice(__spreadProps(__spreadValues({}, device), { twinsByIntegration: __spreadProps(__spreadValues({}, twinsByIntegration), { [integration.id]: __spreadProps(__spreadValues({}, currentState), { desired: settings }) }) })))
+    );
+  })
+);
+var prepareSearchArguments = ({ filters, group, state, status }) => {
+  const { filterTerms } = convertDeviceListStateToFilters({ filters, group, offlineThreshold: state.app.offlineThreshold, selectedIssues: [], status });
+  const { columnSelection = [] } = getUserSettings(state);
+  const selectedAttributes = columnSelection.map((column) => ({ attribute: column.key, scope: column.scope }));
+  const attributes = [...defaultAttributes, getIdAttribute(state), ...selectedAttributes];
+  return { attributes, filterTerms };
+};
+var getSystemDevices = createAsyncThunk2(`${sliceName3}/getSystemDevices`, (options, { dispatch, getState }) => {
+  const { id, page = defaultPage2, perPage = defaultPerPage2, sortOptions = [] } = options;
+  const state = getState();
+  const { hasFullFiltering } = getTenantCapabilities(state);
+  if (!hasFullFiltering) {
+    return Promise.resolve();
+  }
+  const { attributes: deviceAttributes = {} } = getDeviceById(state, id);
+  const { mender_gateway_system_id = "" } = deviceAttributes;
+  const filters = [
+    __spreadProps(__spreadValues({}, emptyFilter), { key: "mender_is_gateway", operator: DEVICE_FILTERING_OPTIONS.$ne.key, value: "true", scope: "inventory" }),
+    __spreadProps(__spreadValues({}, emptyFilter), { key: "mender_gateway_system_id", value: mender_gateway_system_id, scope: "inventory" })
+  ];
+  const { attributes, filterTerms } = prepareSearchArguments({ filters, state });
+  return general_api_default.post(getSearchEndpoint(getState()), {
+    page,
+    per_page: perPage,
+    filters: filterTerms,
+    sort: sortOptions,
+    attributes
+  }).catch((err) => commonErrorHandler(err, `There was an error getting system devices device ${id}.`, dispatch, "Please check your connection.")).then(({ data, headers }) => {
+    const state2 = getState();
+    const { devicesById, ids } = reduceReceivedDevices(data, [], state2);
+    const device = __spreadProps(__spreadValues({}, getDeviceById(state2, id)), {
+      systemDeviceIds: ids,
+      systemDeviceTotal: Number(headers[headerNames.total])
+    });
+    return Promise.resolve(dispatch(actions3.receivedDevices(__spreadProps(__spreadValues({}, devicesById), { [id]: device }))));
+  });
+});
+var getGatewayDevices = createAsyncThunk2(`${sliceName3}/getGatewayDevices`, (deviceId, { dispatch, getState }) => {
+  const state = getState();
+  const { attributes = {} } = getDeviceById(state, deviceId);
+  const { mender_gateway_system_id = "" } = attributes;
+  const filters = [
+    __spreadProps(__spreadValues({}, emptyFilter), { key: "id", operator: DEVICE_FILTERING_OPTIONS.$ne.key, value: deviceId, scope: "identity" }),
+    __spreadProps(__spreadValues({}, emptyFilter), { key: "mender_is_gateway", value: "true", scope: "inventory" }),
+    __spreadProps(__spreadValues({}, emptyFilter), { key: "mender_gateway_system_id", value: mender_gateway_system_id, scope: "inventory" })
+  ];
+  const { attributes: attributeSelection, filterTerms } = prepareSearchArguments({ filters, state });
+  return general_api_default.post(getSearchEndpoint(getState()), {
+    page: 1,
+    per_page: MAX_PAGE_SIZE,
+    filters: filterTerms,
+    attributes: attributeSelection
+  }).then(({ data }) => {
+    const { ids } = reduceReceivedDevices(data, [], getState());
+    let tasks = ids.map((deviceId2) => dispatch(getDeviceInfo(deviceId2)));
+    tasks.push(dispatch(actions3.receivedDevice({ id: deviceId, gatewayIds: ids })));
+    return Promise.all(tasks);
+  });
+});
+var getDevicesInBounds = createAsyncThunk2(`${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/onboardingSlice/thunks.ts
+import { getDemoDeviceAddress } from "@northern.tech/utils/helpers";
+import { createAsyncThunk as createAsyncThunk3 } from "@reduxjs/toolkit";
+import Cookies from "universal-cookie";
+var cookies = new Cookies();
+var applyOnboardingFallbacks = (progress2) => {
+  const step = orderedOnboardingSteps[progress2];
+  if (step && step.fallbackStep) {
+    return step.fallbackStep;
+  }
+  return progress2;
+};
+var determineProgress = (acceptedDevices, pendingDevices, releases, pastDeployments) => {
+  const steps = orderedOnboardingSteps;
+  let progress2 = -1;
+  progress2 = pendingDevices.length > 1 ? steps.findIndex((step) => step === onboardingSteps.DEVICES_PENDING_ACCEPTING_ONBOARDING) : progress2;
+  progress2 = acceptedDevices.length >= 1 ? steps.findIndex((step) => step === onboardingSteps.DEVICES_ACCEPTED_ONBOARDING) : progress2;
+  progress2 = acceptedDevices.length > 1 && releases.length > 1 && pastDeployments.length > 1 ? steps.findIndex((step) => step === onboardingSteps.DEPLOYMENTS_PAST_COMPLETED) : progress2;
+  return steps[progress2];
+};
+var deductOnboardingState = ({ devicesById, devicesByStatus, onboardingState, pastDeployments, releases, userCapabilities, userId }) => {
+  var _a;
+  const { canDeploy, canManageDevices, canReadDeployments, canReadDevices, canReadReleases, canUploadReleases } = userCapabilities;
+  const userCookie = cookies.get(`${userId}-onboarded`);
+  const acceptedDevices = devicesByStatus[DEVICE_STATES.accepted].deviceIds;
+  const pendingDevices = devicesByStatus[DEVICE_STATES.pending].deviceIds;
+  let deviceType = (_a = onboardingState.deviceType) != null ? _a : [];
+  deviceType = !deviceType.length && acceptedDevices.length && devicesById[acceptedDevices[0]].hasOwnProperty("attributes") ? devicesById[acceptedDevices[0]].attributes.device_type : deviceType;
+  const progress2 = applyOnboardingFallbacks(onboardingState.progress || determineProgress(acceptedDevices, pendingDevices, releases, pastDeployments));
+  return __spreadProps(__spreadValues({}, onboardingState), {
+    complete: !!(Boolean(userCookie) || onboardingState.complete || acceptedDevices.length > 1 && pendingDevices.length > 0 && releases.length > 1 && pastDeployments.length > 1 || acceptedDevices.length >= 1 && releases.length >= 2 && pastDeployments.length > 2 || acceptedDevices.length >= 1 && pendingDevices.length > 0 && releases.length >= 2 && pastDeployments.length >= 2 || orderedOnboardingSteps.findIndex((step) => step === progress2) >= orderedOnboardingSteps.length - 1 || onboardingState.disable || ![canDeploy, canManageDevices, canReadDeployments, canReadDevices, canReadReleases, canUploadReleases].every((i) => i)),
+    showTips: onboardingState.showTips != null ? onboardingState.showTips : true,
+    deviceType,
+    approach: onboardingState.approach || (deviceType.some((type) => type.startsWith("qemu")) ? "virtual" : "physical"),
+    progress: progress2
+  });
+};
+var getOnboardingState2 = createAsyncThunk3(`${sliceName4}/getOnboardingState`, (_, { dispatch, getState }) => {
+  const state = getState();
+  let onboardingState = getOnboardingState(state);
+  if (!onboardingState.complete) {
+    const userId = state.users.currentUser;
+    onboardingState = deductOnboardingState({
+      devicesById: state.devices.byId,
+      devicesByStatus: state.devices.byStatus,
+      onboardingState,
+      pastDeployments: state.deployments.byStatus.finished.deploymentIds,
+      releases: Object.values(state.releases.byId),
+      userCapabilities: getUserCapabilities(state),
+      userId
+    });
+  }
+  onboardingState.progress = onboardingState.progress || onboardingSteps.DASHBOARD_ONBOARDING_START;
+  const demoDeviceAddress = `http://${getDemoDeviceAddress(Object.values(state.devices.byId), onboardingState.approach)}`;
+  onboardingState.address = state.onboarding.demoArtifactPort ? `${demoDeviceAddress}:${state.onboarding.demoArtifactPort}` : demoDeviceAddress;
+  return Promise.all([
+    dispatch(actions4.setOnboardingComplete(onboardingState.complete)),
+    dispatch(actions4.setOnboardingState(onboardingState)),
+    dispatch(saveUserSettings({ onboarding: onboardingState }))
+  ]);
+});
+var setOnboardingDeviceType = createAsyncThunk3(
+  `${sliceName4}/setOnboardingDeviceType`,
+  (value, { dispatch }) => Promise.all([dispatch(actions4.setOnboardingDeviceType(value)), dispatch(saveUserSettings({ onboarding: { deviceType: value } }))])
+);
+var setOnboardingApproach = createAsyncThunk3(
+  `${sliceName4}/setOnboardingApproach`,
+  (value, { dispatch }) => Promise.all([dispatch(actions4.setOnboardingApproach(value)), dispatch(saveUserSettings({ onboarding: { approach: value } }))])
+);
+var setOnboardingComplete = createAsyncThunk3(`${sliceName4}/setOnboardingComplete`, (value, { dispatch }) => {
+  let tasks = [Promise.resolve(dispatch(actions4.setOnboardingComplete(value)))];
+  if (value) {
+    tasks.push(Promise.resolve(dispatch(actions4.setShowOnboardingHelp(false))));
+    tasks.push(Promise.resolve(dispatch(advanceOnboarding(onboardingSteps.DEPLOYMENTS_PAST_COMPLETED))));
+  }
+  return Promise.all(tasks);
+});
+var setOnboardingCanceled = createAsyncThunk3(
+  `${sliceName4}/setOnboardingCanceled`,
+  (_, { dispatch }) => Promise.all([
+    Promise.resolve(dispatch(actions4.setShowOnboardingHelp(false))),
+    Promise.resolve(dispatch(actions4.setShowDismissOnboardingTipsDialog(false))),
+    Promise.resolve(dispatch(actions4.setOnboardingComplete(true)))
+  ]).then(() => dispatch(advanceOnboarding(onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE)))
+);
+var advanceOnboarding = createAsyncThunk3(`${sliceName4}/advanceOnboarding`, (stepId, { dispatch, getState }) => {
+  const steps = orderedOnboardingSteps;
+  const progress2 = steps.findIndex((step) => step === getState().onboarding.progress);
+  const stepIndex = steps.findIndex((step) => step === stepId);
+  if (progress2 > stepIndex || getState().onboarding.progress === null) {
+    return;
+  }
+  const madeProgress = steps[stepIndex + 1];
+  const state = __spreadProps(__spreadValues({}, getOnboardingState(getState())), { progress: madeProgress });
+  state.complete = stepIndex + 1 >= steps.findIndex((step) => step === onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE) ? true : state.complete;
+  return Promise.all([dispatch(actions4.setOnboardingProgress(madeProgress)), dispatch(saveUserSettings({ onboarding: state }))]);
+});
+
+// src/organizationSlice/thunks.ts
+import { deepCompare as deepCompare3 } from "@northern.tech/utils/helpers";
+import { createAsyncThunk as createAsyncThunk4 } from "@reduxjs/toolkit";
+import { jwtDecode } from "jwt-decode";
+import hashString from "md5";
+import Cookies2 from "universal-cookie";
+var cookies2 = new Cookies2();
+var { setAnnouncement, setSnackbar: setSnackbar3 } = actions_default;
+var { page: defaultPage3, perPage: defaultPerPage3 } = DEVICE_LIST_DEFAULTS;
+var cancelRequest = createAsyncThunk4(`${sliceName5}/cancelRequest`, (reason, { dispatch, getState }) => {
+  const { id: tenantId } = getOrganization(getState());
+  return general_api_default.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/cancel`, { reason }).then(
+    () => Promise.resolve(dispatch(setSnackbar3({ message: "Deactivation request was sent successfully", autoHideDuration: TIMEOUTS.fiveSeconds })))
+  );
+});
+var getTargetLocation = (key) => {
+  if (devLocations.includes(window.location.hostname)) {
+    return "";
+  }
+  let subdomainSections = window.location.hostname.substring(0, window.location.hostname.indexOf(locations.us.location)).split(".");
+  subdomainSections = subdomainSections.splice(0, subdomainSections.length - 1);
+  if (!subdomainSections.find((section) => section === key)) {
+    subdomainSections = key === locations.us.key ? subdomainSections.filter((section) => !locations[section]) : [...subdomainSections, key];
+    return `https://${[...subdomainSections, ...locations.us.location.split(".")].join(".")}`;
+  }
+  return `https://${window.location.hostname}`;
+};
+var devLocations = ["localhost", "docker.mender.io"];
+var createOrganizationTrial = createAsyncThunk4(`${sliceName5}/createOrganizationTrial`, (data, { dispatch }) => {
+  const { key } = locations[data.location];
+  const targetLocation = getTargetLocation(key);
+  const target = `${targetLocation}${tenantadmApiUrlv2}/tenants/trial`;
+  return general_api_default.postUnauthorized(target, data).catch((err) => {
+    if (err.response.status >= 400 && err.response.status < 500) {
+      dispatch(setSnackbar3({ message: err.response.data.error, autoHideDuration: TIMEOUTS.fiveSeconds }));
+      return Promise.reject(err);
+    }
+  }).then(({ headers }) => {
+    cookies2.remove("oauth");
+    cookies2.remove("externalID");
+    cookies2.remove("email");
+    dispatch(setFirstLoginAfterSignup(true));
+    return new Promise(
+      (resolve) => setTimeout(() => {
+        window.location.assign(`${targetLocation}${headers.location || ""}`);
+        return resolve();
+      }, TIMEOUTS.fiveSeconds)
+    );
+  });
+});
+var startCardUpdate = createAsyncThunk4(
+  `${sliceName5}/startCardUpdate`,
+  (_, { dispatch }) => general_api_default.post(`${tenantadmApiUrlv2}/billing/card`).then(({ data }) => {
+    dispatch(actions5.receiveSetupIntent(data.intent_id));
+    return Promise.resolve(data.secret);
+  }).catch((err) => commonErrorHandler(err, `Updating the card failed:`, dispatch))
+);
+var confirmCardUpdate = createAsyncThunk4(
+  `${sliceName5}/confirmCardUpdate`,
+  (_, { dispatch, getState }) => general_api_default.post(`${tenantadmApiUrlv2}/billing/card/${getState().organization.intentId}/confirm`).then(() => Promise.all([dispatch(setSnackbar3("Payment card was updated successfully")), dispatch(actions5.receiveSetupIntent(null))])).catch((err) => commonErrorHandler(err, `Updating the card failed:`, dispatch))
+);
+var getCurrentCard = createAsyncThunk4(
+  `${sliceName5}/getCurrentCard`,
+  (_, { dispatch }) => general_api_default.get(`${tenantadmApiUrlv2}/billing`).then((res) => {
+    const { last4, exp_month, exp_year, brand } = res.data.card || {};
+    return Promise.resolve(dispatch(actions5.receiveCurrentCard({ brand, last4, expiration: { month: exp_month, year: exp_year } })));
+  })
+);
+var startUpgrade = createAsyncThunk4(
+  `${sliceName5}/startUpgrade`,
+  (tenantId, { dispatch }) => general_api_default.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/upgrade/start`).then(({ data }) => Promise.resolve(data.secret)).catch((err) => commonErrorHandler(err, `There was an error upgrading your account:`, dispatch))
+);
+var cancelUpgrade = createAsyncThunk4(`${sliceName5}/cancelUpgrade`, (tenantId) => general_api_default.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/upgrade/cancel`));
+var completeUpgrade = createAsyncThunk4(
+  `${sliceName5}/completeUpgrade`,
+  ({ tenantId, plan }, { dispatch }) => general_api_default.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/upgrade/complete`, { plan }).catch((err) => commonErrorHandler(err, `There was an error upgrading your account:`, dispatch)).then(() => Promise.resolve(dispatch(getUserOrganization())))
+);
+var prepareAuditlogQuery = ({ startDate, endDate, user: userFilter, type, detail: detailFilter, sort = {} }) => {
+  const userId = (userFilter == null ? void 0 : userFilter.id) || userFilter;
+  const detail = (detailFilter == null ? void 0 : detailFilter.id) || detailFilter;
+  const createdAfter = startDate ? `&created_after=${Math.round(Date.parse(startDate) / 1e3)}` : "";
+  const createdBefore = endDate ? `&created_before=${Math.round(Date.parse(endDate) / 1e3)}` : "";
+  const typeSearch = type ? `&object_type=${type.value}`.toLowerCase() : "";
+  const userSearch = userId ? `&actor_id=${userId}` : "";
+  const objectSearch = type && detail ? `&${type.queryParameter}=${encodeURIComponent(detail)}` : "";
+  const { direction = SORTING_OPTIONS.desc } = sort;
+  return `${createdAfter}${createdBefore}${userSearch}${typeSearch}${objectSearch}&sort=${direction}`;
+};
+var getAuditLogs = createAsyncThunk4(`${sliceName5}/getAuditLogs`, (selectionState, { dispatch, getState }) => {
+  const { page, perPage } = selectionState;
+  const { hasAuditlogs } = getTenantCapabilities(getState());
+  if (!hasAuditlogs) {
+    return Promise.resolve();
+  }
+  return general_api_default.get(`${auditLogsApiUrl}/logs?page=${page}&per_page=${perPage}${prepareAuditlogQuery(selectionState)}`).then(({ data, headers }) => {
+    let total = headers[headerNames.total];
+    total = Number(total || data.length);
+    return Promise.resolve(dispatch(actions5.receiveAuditLogs({ events: data, total })));
+  }).catch((err) => commonErrorHandler(err, `There was an error retrieving audit logs:`, dispatch));
+});
+var getAuditLogsCsvLink = createAsyncThunk4(
+  `${sliceName5}/getAuditLogsCsvLink`,
+  (_, { getState }) => Promise.resolve(`${window.location.origin}${auditLogsApiUrl}/logs/export?limit=20000${prepareAuditlogQuery(getAuditlogState(getState()))}`)
+);
+var setAuditlogsState = createAsyncThunk4(`${sliceName5}/setAuditlogsState`, (selectionState, { dispatch, getState }) => {
+  const currentState = getAuditlogState(getState());
+  let nextState = __spreadProps(__spreadValues(__spreadValues({}, currentState), selectionState), {
+    sort: __spreadValues(__spreadValues({}, currentState.sort), selectionState.sort)
+  });
+  let tasks = [];
+  const _a = currentState, { isLoading: currentLoading, selectedIssue: currentIssue } = _a, currentRequestState = __objRest(_a, ["isLoading", "selectedIssue"]);
+  const _b = nextState, { isLoading: selectionLoading, selectedIssue: selectionIssue } = _b, selectionRequestState = __objRest(_b, ["isLoading", "selectedIssue"]);
+  if (!deepCompare3(currentRequestState, selectionRequestState)) {
+    nextState.isLoading = true;
+    tasks.push(dispatch(getAuditLogs(nextState)).finally(() => dispatch(actions5.setAuditLogState({ isLoading: false }))));
+  }
+  tasks.push(dispatch(actions5.setAuditLogState(nextState)));
+  return Promise.all(tasks);
+});
+var tenantDataDivergedMessage = "The system detected there is a change in your plan or purchased add-ons. Please log out and log in again";
+var addTenant = createAsyncThunk4(`${sliceName5}/createTenant`, (selectionState, { dispatch }) => {
+  return general_api_default.post(`${tenantadmApiUrlv2}/tenants`, selectionState).then(() => Promise.all([dispatch(getTenants()), dispatch(setSnackbar3("Tenant was created successfully."))])).catch((err) => commonErrorHandler(err, "There was an error creating tenant", dispatch, commonErrorFallback));
+});
+var tenantListRetrieval = (config) => __async(void 0, null, function* () {
+  const { page, perPage } = config;
+  const params = new URLSearchParams({ page, per_page: perPage }).toString();
+  const tenantList = yield general_api_default.get(`${tenantadmApiUrlv2}/tenants?${params}`);
+  const totalCount = tenantList.headers[headerNames.total] || TENANT_LIST_DEFAULT.perPage;
+  return [tenantList.data, totalCount];
+});
+var getTenants = createAsyncThunk4(`${sliceName5}/getTenants`, (_0, _1) => __async(void 0, [_0, _1], function* (_, { dispatch, getState }) {
+  const currentState = getTenantsList(getState());
+  const [tenants, pageCount] = yield tenantListRetrieval(currentState);
+  dispatch(actions5.setTenantListState(__spreadProps(__spreadValues({}, currentState), { total: pageCount, tenants })));
+}));
+var setTenantsListState = createAsyncThunk4(`${sliceName5}/setTenantsListState`, (_0, _1) => __async(void 0, [_0, _1], function* (selectionState, { dispatch, getState }) {
+  const currentState = getTenantsList(getState());
+  const nextState = __spreadValues(__spreadValues({}, currentState), selectionState);
+  if (!deepCompare3(currentState, selectionState)) {
+    const [tenants, pageCount] = yield tenantListRetrieval(nextState);
+    return dispatch(actions5.setTenantListState(__spreadProps(__spreadValues({}, nextState), { tenants, total: pageCount })));
+  }
+  return dispatch(actions5.setTenantListState(__spreadValues({}, nextState)));
+}));
+var editTenantDeviceLimit = createAsyncThunk4(`${sliceName5}/editDeviceLimit`, ({ newLimit, id, name }, { dispatch }) => {
+  return general_api_default.put(`${tenantadmApiUrlv2}/tenants/${id}/child`, { device_limit: newLimit, name }).catch((err) => commonErrorHandler(err, `Device Limit cannot be changed`, dispatch)).then(() => {
+    const tasks = [Promise.resolve(dispatch(setSnackbar3("Device Limit was changed successfully")))];
+    tasks.push(dispatch(getTenants()));
+    tasks.push(dispatch(getUserOrganization()));
+    return Promise.all(tasks);
+  });
+});
+var removeTenant = createAsyncThunk4(`${sliceName5}/editDeviceLimit`, ({ id }, { dispatch }) => {
+  return general_api_default.post(`${tenantadmApiUrlv2}/tenants/${id}/remove/start`).catch((err) => commonErrorHandler(err, `There was an error removing the tenant`, dispatch)).then(
+    () => Promise.all([Promise.resolve(dispatch(setSnackbar3("Device Limit was changed successfully"))), dispatch(getTenants()), dispatch(getUserOrganization())])
+  );
+});
+var getUserOrganization = createAsyncThunk4(`${sliceName5}/getUserOrganization`, (_, { dispatch, getState }) => {
+  return general_api_default.get(`${tenantadmApiUrlv1}/user/tenant`).then((res) => {
+    let tasks = [dispatch(actions5.setOrganization(res.data))];
+    const { addons, plan, trial } = res.data;
+    const { token } = getCurrentSession(getState());
+    const jwt = jwtDecode(token);
+    const jwtData = { addons: jwt["mender.addons"], plan: jwt["mender.plan"], trial: jwt["mender.trial"] };
+    if (!deepCompare3({ addons, plan, trial }, jwtData)) {
+      const hash = hashString(tenantDataDivergedMessage);
+      cookies2.remove(`${jwt.sub}${hash}`);
+      tasks.push(dispatch(setAnnouncement(tenantDataDivergedMessage)));
+    }
+    return Promise.all(tasks);
+  });
+});
+var sendSupportMessage = createAsyncThunk4(
+  `${sliceName5}/sendSupportMessage`,
+  (content, { dispatch }) => general_api_default.post(`${tenantadmApiUrlv2}/contact/support`, content).catch((err) => commonErrorHandler(err, "There was an error sending your request", dispatch, commonErrorFallback)).then(() => Promise.resolve(dispatch(setSnackbar3({ message: "Your request was sent successfully", autoHideDuration: TIMEOUTS.fiveSeconds }))))
+);
+var requestPlanChange = createAsyncThunk4(
+  `${sliceName5}/requestPlanChange`,
+  ({ content, tenantId }, { dispatch }) => general_api_default.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/plan`, content).catch((err) => commonErrorHandler(err, "There was an error sending your request", dispatch, commonErrorFallback)).then(() => Promise.resolve(dispatch(setSnackbar3({ message: "Your request was sent successfully", autoHideDuration: TIMEOUTS.fiveSeconds }))))
+);
+var downloadLicenseReport = createAsyncThunk4(
+  `${sliceName5}/downloadLicenseReport`,
+  (_, { dispatch }) => general_api_default.get(`${deviceAuthV2}/reports/devices`).catch((err) => commonErrorHandler(err, "There was an error downloading the report", dispatch, commonErrorFallback)).then((res) => res.data)
+);
+var createIntegration = createAsyncThunk4(
+  `${sliceName5}/createIntegration`,
+  (_a, { dispatch }) => {
+    var _b = _a, { id } = _b, integration = __objRest(_b, ["id"]);
+    return general_api_default.post(`${iotManagerBaseURL}/integrations`, integration).catch((err) => commonErrorHandler(err, "There was an error creating the integration", dispatch, commonErrorFallback)).then(() => Promise.all([dispatch(setSnackbar3("The integration was set up successfully")), dispatch(getIntegrations())]));
+  }
+);
+var changeIntegration = createAsyncThunk4(
+  `${sliceName5}/changeIntegration`,
+  ({ id, credentials }, { dispatch }) => general_api_default.put(`${iotManagerBaseURL}/integrations/${id}/credentials`, credentials).catch((err) => commonErrorHandler(err, "There was an error updating the integration", dispatch, commonErrorFallback)).then(() => Promise.all([dispatch(setSnackbar3("The integration was updated successfully")), dispatch(getIntegrations())]))
+);
+var deleteIntegration = createAsyncThunk4(
+  `${sliceName5}/deleteIntegration`,
+  ({ id, provider }, { dispatch, getState }) => general_api_default.delete(`${iotManagerBaseURL}/integrations/${id}`, {}).catch((err) => commonErrorHandler(err, "There was an error removing the integration", dispatch, commonErrorFallback)).then(() => {
+    const integrations = getState().organization.externalDeviceIntegrations.filter((item) => provider !== item.provider);
+    return Promise.all([
+      dispatch(setSnackbar3("The integration was removed successfully")),
+      dispatch(actions5.receiveExternalDeviceIntegrations(integrations))
+    ]);
+  })
+);
+var getIntegrations = createAsyncThunk4(
+  `${sliceName5}/getIntegrations`,
+  (_, { dispatch, getState }) => general_api_default.get(`${iotManagerBaseURL}/integrations`).catch((err) => commonErrorHandler(err, "There was an error retrieving the integration", dispatch, commonErrorFallback)).then(({ data }) => {
+    const existingIntegrations = getState().organization.externalDeviceIntegrations;
+    const integrations = data.reduce((accu, item) => {
+      var _a;
+      const existingIntegration = (_a = existingIntegrations.find((integration2) => item.id === integration2.id)) != null ? _a : {};
+      const integration = __spreadValues(__spreadValues({}, existingIntegration), item);
+      accu.push(integration);
+      return accu;
+    }, []);
+    return Promise.resolve(dispatch(actions5.receiveExternalDeviceIntegrations(integrations)));
+  })
+);
+var getWebhookEvents = createAsyncThunk4(`${sliceName5}/getWebhookEvents`, (config = {}, { dispatch, getState }) => {
+  const { isFollowUp, page = defaultPage3, perPage = defaultPerPage3 } = config;
+  return general_api_default.get(`${iotManagerBaseURL}/events?page=${page}&per_page=${perPage}`).catch((err) => commonErrorHandler(err, "There was an error retrieving activity for this integration", dispatch, commonErrorFallback)).then(({ data }) => {
+    let tasks = [
+      dispatch(
+        actions5.receiveWebhookEvents({
+          value: isFollowUp ? getState().organization.webhooks.events : data,
+          total: (page - 1) * perPage + data.length
+        })
+      )
+    ];
+    if (data.length >= perPage && !isFollowUp) {
+      tasks.push(dispatch(getWebhookEvents({ isFollowUp: true, page: page + 1, perPage: 1 })));
+    }
+    return Promise.all(tasks);
+  });
+});
+var ssoConfigActions = {
+  create: { success: "stored", error: "storing" },
+  edit: { success: "updated", error: "updating" },
+  read: { success: "", error: "retrieving" },
+  remove: { success: "removed", error: "removing" },
+  readMultiple: { success: "", error: "retrieving" }
+};
+var ssoConfigActionErrorHandler = (err, type) => (dispatch) => commonErrorHandler(err, `There was an error ${ssoConfigActions[type].error} the SSO configuration.`, dispatch, commonErrorFallback);
+var ssoConfigActionSuccessHandler = (type) => (dispatch) => dispatch(setSnackbar3(`The SSO configuration was ${ssoConfigActions[type].success} successfully`));
+var storeSsoConfig = createAsyncThunk4(
+  `${sliceName5}/storeSsoConfig`,
+  ({ config, contentType }, { dispatch }) => general_api_default.post(ssoIdpApiUrlv1, config, { headers: { "Content-Type": contentType, Accept: "application/json" } }).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "create"))).then(() => Promise.all([dispatch(ssoConfigActionSuccessHandler("create")), dispatch(getSsoConfigs())]))
+);
+var changeSsoConfig = createAsyncThunk4(
+  `${sliceName5}/changeSsoConfig`,
+  ({ config, contentType }, { dispatch }) => general_api_default.put(`${ssoIdpApiUrlv1}/${config.id}`, config, { headers: { "Content-Type": contentType, Accept: "application/json" } }).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "edit"))).then(() => Promise.all([dispatch(ssoConfigActionSuccessHandler("edit")), dispatch(getSsoConfigs())]))
+);
+var deleteSsoConfig = createAsyncThunk4(
+  `${sliceName5}/deleteSsoConfig`,
+  ({ id }, { dispatch, getState }) => general_api_default.delete(`${ssoIdpApiUrlv1}/${id}`).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "remove"))).then(() => {
+    const configs = getState().organization.ssoConfigs.filter((item) => id !== item.id);
+    return Promise.all([dispatch(ssoConfigActionSuccessHandler("remove")), dispatch(actions5.receiveSsoConfigs(configs))]);
+  })
+);
+var getSsoConfigById = createAsyncThunk4(
+  `${sliceName5}/getSsoConfigById`,
+  (config, { dispatch }) => general_api_default.get(`${ssoIdpApiUrlv1}/${config.id}`).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "read"))).then(({ data, headers }) => {
+    const sso = Object.values(SSO_TYPES).find(({ contentType }) => contentType === headers["content-type"]);
+    return sso ? Promise.resolve(__spreadProps(__spreadValues({}, config), { config: data, type: sso.id })) : Promise.reject("Unsupported SSO config content type.");
+  })
+);
+var getSsoConfigs = createAsyncThunk4(
+  `${sliceName5}/getSsoConfigs`,
+  (_, { dispatch }) => general_api_default.get(ssoIdpApiUrlv1).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "readMultiple"))).then(
+    ({ data }) => Promise.all(data.map((config) => dispatch(getSsoConfigById(config)).unwrap())).then((configs) => dispatch(actions5.receiveSsoConfigs(configs))).catch((err) => commonErrorHandler(err, err, dispatch, ""))
+  )
+);
+
+// src/usersSlice/thunks.ts
+import { duplicateFilter, isEmpty as isEmpty2 } from "@northern.tech/utils/helpers";
+import { clearAllRetryTimers } from "@northern.tech/utils/retrytimer";
+import { createAsyncThunk as createAsyncThunk5 } from "@reduxjs/toolkit";
+import hashString2 from "md5";
+import Cookies3 from "universal-cookie";
+var cookies3 = new Cookies3();
+var { setAnnouncement: setAnnouncement2, setSnackbar: setSnackbar4 } = actions_default;
+var handleLoginError = (err, { token2fa: has2FA, password }, rejectWithValue) => (dispatch) => {
+  const errorText = extractErrorMessage(err);
+  const is2FABackend = errorText.includes("2fa");
+  if (is2FABackend && !has2FA) {
+    return rejectWithValue({ error: "2fa code missing" });
+  }
+  if (password === void 0) {
+    return Promise.reject();
+  }
+  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(setSnackbar4(preformatWithRequestID(err.response, errorMessage), null, "Copy to clipboard")));
+};
+var loginUser = createAsyncThunk5(
+  `${sliceName6}/loginUser`,
+  (_a, { dispatch, rejectWithValue }) => {
+    var _b = _a, { stayLoggedIn } = _b, userData = __objRest(_b, ["stayLoggedIn"]);
+    return users_api_default.postLogin(`${useradmApiUrlv1}/auth/login`, __spreadProps(__spreadValues({}, 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;
+        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) {
+        return;
+      }
+      let now = /* @__PURE__ */ new Date();
+      now.setSeconds(now.getSeconds() + maxSessionAge);
+      const expiresAt = stayLoggedIn ? void 0 : now.toISOString();
+      setSessionInfo({ token, expiresAt });
+      cookies3.remove("JWT", { path: "/" });
+      return (
+        // @ts-ignore
+        Promise.resolve(dispatch(getUser(OWN_USER_ID))).unwrap().catch((e) => {
+          cleanUp();
+          return Promise.reject(dispatch(setSnackbar4(extractErrorMessage(e))));
+        }).then(() => {
+          window.sessionStorage.removeItem("pendings-redirect");
+          if (window.location.pathname !== "/ui/") {
+            window.location.replace("/ui/");
+          }
+          return Promise.resolve(dispatch(actions6.successfullyLoggedIn({ expiresAt, token })));
+        })
+      );
+    });
+  }
+);
+var logoutUser = createAsyncThunk5(`${sliceName6}/logoutUser`, (_, { dispatch, getState }) => {
+  if (Object.keys(getState().app.uploadsById).length) {
+    return Promise.reject();
+  }
+  return general_api_default.post(`${useradmApiUrlv1}/auth/logout`).finally(() => {
+    cleanUp();
+    clearAllRetryTimers(setSnackbar4);
+    return Promise.resolve(dispatch({ type: USER_LOGOUT }));
+  });
+});
+var switchUserOrganization = createAsyncThunk5(`${sliceName6}/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 }) => {
+    setSessionInfo(__spreadProps(__spreadValues({}, getSessionInfo()), { token }));
+    window.location.reload();
+  });
+});
+var passwordResetStart = createAsyncThunk5(
+  `${sliceName6}/passwordResetStart`,
+  (email, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/auth/password-reset/start`, { email }).catch(
+    (err) => commonErrorHandler(err, `The password reset request cannot be processed:`, dispatch, void 0, true)
+  )
+);
+var passwordResetComplete = createAsyncThunk5(
+  `${sliceName6}/passwordResetComplete`,
+  ({ secretHash, newPassword }, { dispatch }) => general_api_default.post(`${useradmApiUrlv1}/auth/password-reset/complete`, { secret_hash: secretHash, password: newPassword }).catch((err = {}) => {
+    const { error, response = {} } = err;
+    let errorMsg = "";
+    if (response.status == 400) {
+      errorMsg = "the link you are using expired or the request is not valid, please try again.";
+    } else {
+      errorMsg = error;
+    }
+    dispatch(setSnackbar4("The password reset request cannot be processed: " + errorMsg));
+    return Promise.reject(err);
+  })
+);
+var verifyEmailStart = createAsyncThunk5(
+  `${sliceName6}/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))))
+);
+var verifyEmailComplete = createAsyncThunk5(
+  `${sliceName6}/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))))
+);
+var verify2FA = createAsyncThunk5(
+  `${sliceName6}/verify2FA`,
+  (tfaData, { dispatch }) => users_api_default.putVerifyTFA(`${useradmApiUrlv1}/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 = createAsyncThunk5(
+  `${sliceName6}/getUserList`,
+  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/users`).then((res) => {
+    const users = res.data.reduce((accu, item) => {
+      accu[item.id] = item;
+      return accu;
+    }, {});
+    return dispatch(actions6.receivedUserList(users));
+  }).catch((err) => commonErrorHandler(err, `Users couldn't be loaded.`, dispatch, commonErrorFallback))
+);
+var getUser = createAsyncThunk5(
+  `${sliceName6}/getUser`,
+  (id, { dispatch, rejectWithValue }) => general_api_default.get(`${useradmApiUrlv1}/users/${id}`).then(
+    ({ data: user }) => Promise.all([
+      dispatch(actions6.receivedUser(user)),
+      // @ts-ignore
+      dispatch(setHideAnnouncement({ shouldHide: false, userId: user.id })),
+      // @ts-ignore
+      dispatch(updateUserColumnSettings({ currentUserId: user.id })),
+      user
+    ])
+  ).catch((e) => rejectWithValue(e))
+);
+var initializeSelf = createAsyncThunk5(`${sliceName6}/initializeSelf`, (_, { dispatch }) => dispatch(getUser(OWN_USER_ID)));
+var updateUserColumnSettings = createAsyncThunk5(`${sliceName6}/updateUserColumnSettings`, ({ columns, currentUserId }, { dispatch, getState }) => {
+  const userId = currentUserId != null ? currentUserId : getCurrentUser(getState()).id;
+  const storageKey = `${userId}-column-widths`;
+  let customColumns = [];
+  if (!columns) {
+    try {
+      customColumns = JSON.parse(window.localStorage.getItem(storageKey)) || customColumns;
+    } catch (e) {
+    }
+  } else {
+    customColumns = columns;
+  }
+  window.localStorage.setItem(storageKey, JSON.stringify(customColumns));
+  return Promise.resolve(dispatch(actions6.setCustomColumns(customColumns)));
+});
+var userActions = {
+  add: {
+    successMessage: "The user was added successfully.",
+    errorMessage: "adding"
+  },
+  create: {
+    successMessage: "The user was created successfully.",
+    errorMessage: "creating"
+  },
+  edit: {
+    successMessage: "The user has been updated.",
+    errorMessage: "editing"
+  },
+  remove: {
+    successMessage: "The user was removed from the system.",
+    errorMessage: "removing"
+  }
+};
+var userActionErrorHandler = (err, type, dispatch) => commonErrorHandler(err, `There was an error ${userActions[type].errorMessage} the user.`, dispatch);
+var createUser = createAsyncThunk5(
+  `${sliceName6}/createUser`,
+  (_a, { dispatch }) => {
+    var _b = _a, { shouldResetPassword } = _b, userData = __objRest(_b, ["shouldResetPassword"]);
+    return general_api_default.post(`${useradmApiUrlv1}/users`, __spreadProps(__spreadValues({}, userData), { send_reset_password: shouldResetPassword })).then(() => Promise.all([dispatch(actions6.createdUser(userData)), dispatch(getUserList()), dispatch(setSnackbar4(userActions.create.successMessage))])).catch((err) => userActionErrorHandler(err, "create", dispatch));
+  }
+);
+var removeUser = createAsyncThunk5(
+  `${sliceName6}/removeUser`,
+  (userId, { dispatch }) => (
+    // @ts-ignore
+    general_api_default.delete(`${useradmApiUrlv1}/users/${userId}`).then(() => Promise.all([dispatch(actions6.removedUser(userId)), dispatch(getUserList()), dispatch(setSnackbar4(userActions.remove.successMessage))])).catch((err) => userActionErrorHandler(err, "remove", dispatch))
+  )
+);
+var editUser = createAsyncThunk5(
+  `${sliceName6}/editUser`,
+  (_a, { dispatch, getState }) => {
+    var _b = _a, { id } = _b, userData = __objRest(_b, ["id"]);
+    return general_api_default.put(`${useradmApiUrlv1}/users/${id}`, userData).then(
+      () => Promise.all([
+        dispatch(actions6.updatedUser(__spreadProps(__spreadValues({}, userData), { id: id === OWN_USER_ID ? getCurrentUser(getState()).id : id }))),
+        dispatch(setSnackbar4(userActions.edit.successMessage))
+      ])
+    );
+  }
+);
+var addUserToCurrentTenant = createAsyncThunk5(`${sliceName6}/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(setSnackbar4(userActions.add.successMessage)), dispatch(getUserList())]));
+});
+var enableUser2fa = createAsyncThunk5(
+  `${sliceName6}/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))))
+);
+var disableUser2fa = createAsyncThunk5(
+  `${sliceName6}/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.resolve(dispatch(getUser(userId))))
+);
+var mapHttpPermission = (permission) => Object.entries(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)
+    );
+    if (permission.value === PermissionTypes.Any || permission.value.includes(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)) {
+          permissionsAccu.push(uiPermission.value);
+        }
+        return permissionsAccu;
+      }, []).filter(duplicateFilter);
+      if (Array.isArray(accu[area])) {
+        accu[area] = [...accu[area], ...collector].filter(duplicateFilter);
+      } else {
+        accu[area] = mergePermissions(accu[area], { [scopedPermissionAreas[area].excessiveAccessSelector]: collector });
+      }
+    }
+    return accu;
+  },
+  __spreadValues({}, emptyUiPermissions)
+);
+var permissionActionTypes = {
+  any: mapHttpPermission,
+  CREATE_DEPLOYMENT: (permission) => permission.type === PermissionTypes.DeviceGroup ? {
+    deployments: [uiPermissionsById.deploy.value],
+    groups: { [permission.value]: [uiPermissionsById.deploy.value] }
+  } : {},
+  http: mapHttpPermission,
+  REMOTE_TERMINAL: (permission) => permission.type === PermissionTypes.DeviceGroup ? {
+    groups: { [permission.value]: [uiPermissionsById.connect.value] }
+  } : {},
+  VIEW_DEVICE: (permission) => permission.type === PermissionTypes.DeviceGroup ? {
+    groups: { [permission.value]: [uiPermissionsById.read.value] }
+  } : {}
+};
+var combinePermissions = (existingPermissions, additionalPermissions = {}) => Object.entries(additionalPermissions).reduce((accu, [name, permissions]) => {
+  let maybeExistingPermissions = accu[name] || [];
+  accu[name] = [...permissions, ...maybeExistingPermissions].filter(duplicateFilter);
+  return accu;
+}, existingPermissions);
+var tryParseCustomPermission = (permission) => {
+  const uiPermissions = permissionActionTypes[permission.action](permission.object);
+  const result = mergePermissions(__spreadValues({}, emptyUiPermissions), uiPermissions);
+  return { isCustom: true, permission, result };
+};
+var customPermissionHandler = (accu, permission) => {
+  let processor = tryParseCustomPermission(permission);
+  return __spreadProps(__spreadValues({}, accu), {
+    isCustom: accu.isCustom || processor.isCustom,
+    uiPermissions: mergePermissions(accu.uiPermissions, processor.result)
+  });
+};
+var mapPermissionSet = (permissionSetName, names, scope, existingGroupsPermissions = {}) => {
+  const permission = Object.values(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]) => __spreadProps(__spreadValues({}, accu), { [key]: deriveImpliedAreaPermissions(scope, permissions) }), {});
+};
+var isEmptyPermissionSet = (permissionSet) => !Object.values(permissionSet).reduce((accu, permissions) => {
+  if (Array.isArray(permissions)) {
+    return accu || !!permissions.length;
+  }
+  return accu || !isEmpty2(permissions);
+}, false);
+var parseRolePermissions = ({ permission_sets_with_scope = [], permissions = [] }, permissionSets) => {
+  const preliminaryResult = permission_sets_with_scope.reduce(
+    (accu, permissionSet) => {
+      let processor = permissionSets[permissionSet.name];
+      if (!processor) {
+        return accu;
+      }
+      const scope = Object.keys(scopedPermissionAreas).find((scope2) => {
+        var _a;
+        return uiPermissionsByArea[scope2].scope === ((_a = permissionSet.scope) == null ? void 0 : _a.type);
+      });
+      if (scope) {
+        const result = mapPermissionSet(permissionSet.name, permissionSet.scope.value, scope, accu.uiPermissions[scope]);
+        return __spreadProps(__spreadValues({}, accu), { uiPermissions: __spreadProps(__spreadValues({}, accu.uiPermissions), { [scope]: result }) });
+      } else if (isEmptyPermissionSet(processor.result)) {
+        return processor.permissions.reduce(customPermissionHandler, accu);
+      }
+      return __spreadProps(__spreadValues({}, accu), {
+        isCustom: accu.isCustom || processor.isCustom,
+        uiPermissions: mergePermissions(accu.uiPermissions, processor.result)
+      });
+    },
+    { isCustom: false, uiPermissions: __spreadProps(__spreadValues({}, emptyUiPermissions), { groups: {}, releases: {} }) }
+  );
+  return permissions.reduce(customPermissionHandler, preliminaryResult);
+};
+var normalizeRbacRoles = (roles, rolesById2, permissionSets) => roles.reduce(
+  (accu, role) => {
+    var _a;
+    let normalizedPermissions;
+    let isCustom = false;
+    if (rolesById2[role.name]) {
+      normalizedPermissions = __spreadProps(__spreadValues({}, rolesById2[role.name].uiPermissions), {
+        groups: __spreadValues({}, rolesById2[role.name].uiPermissions.groups),
+        releases: __spreadValues({}, rolesById2[role.name].uiPermissions.releases)
+      });
+    } else {
+      const result = parseRolePermissions(role, permissionSets);
+      normalizedPermissions = result.uiPermissions;
+      isCustom = result.isCustom;
+    }
+    const roleState = (_a = accu[role.name]) != null ? _a : __spreadValues({}, emptyRole);
+    accu[role.name] = __spreadProps(__spreadValues(__spreadValues({}, roleState), role), {
+      description: roleState.description ? roleState.description : role.description,
+      editable: !rolesById[role.name] && !isCustom && (typeof roleState.editable !== "undefined" ? roleState.editable : true),
+      isCustom,
+      name: roleState.name ? roleState.name : role.name,
+      uiPermissions: normalizedPermissions
+    });
+    return accu;
+  },
+  __spreadValues({}, rolesById2)
+);
+var getPermissionSets = createAsyncThunk5(
+  `${sliceName6}/getPermissionSets`,
+  (_, { dispatch, getState }) => general_api_default.get(`${useradmApiUrlv2}/permission_sets?per_page=500`).then(({ data }) => {
+    const permissionSets = data.reduce(
+      (accu, permissionSet) => {
+        var _a, _b;
+        const permissionSetState = (_a = accu[permissionSet.name]) != null ? _a : {};
+        let permissionSetObject = __spreadValues(__spreadValues({}, permissionSetState), permissionSet);
+        permissionSetObject.result = Object.values(uiPermissionsById).reduce(
+          (accu2, item) => Object.entries(item.permissionSets).reduce((collector, [area, permissionSet2]) => {
+            if (scopedPermissionAreas[area]) {
+              return collector;
+            }
+            if (permissionSet2 === permissionSetObject.name) {
+              collector[area] = [...collector[area], item.value].filter(duplicateFilter);
+            }
+            return collector;
+          }, accu2),
+          __spreadValues(__spreadValues({}, emptyUiPermissions), (_b = permissionSetObject.result) != null ? _b : {})
+        );
+        const scopes = Object.values(scopedPermissionAreas).reduce((accu2, { key, scopeType }) => {
+          var _a2, _b2;
+          if (((_a2 = permissionSetObject.supported_scope_types) == null ? void 0 : _a2.includes(key)) || ((_b2 = permissionSetObject.supported_scope_types) == null ? void 0 : _b2.includes(scopeType))) {
+            accu2.push(key);
+          }
+          return accu2;
+        }, []);
+        permissionSetObject = scopes.reduce((accu2, scope) => {
+          accu2.result[scope] = mapPermissionSet(permissionSetObject.name, [scopedPermissionAreas[scope].excessiveAccessSelector], scope);
+          return accu2;
+        }, permissionSetObject);
+        accu[permissionSet.name] = permissionSetObject;
+        return accu;
+      },
+      // @ts-ignore
+      __spreadValues({}, getState().users.permissionSetsById)
+    );
+    return Promise.all([dispatch(actions6.receivedPermissionSets(permissionSets)), permissionSets]);
+  }).catch(() => console.log("Permission set retrieval failed - likely accessing a non-RBAC backend"))
+);
+var getRoles = createAsyncThunk5(
+  `${sliceName6}/getRoles`,
+  (_, { dispatch, getState }) => Promise.all([general_api_default.get(`${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(actions6.receivedRoles(rolesById2)));
+  }).catch(() => console.log("Role retrieval failed - likely accessing a non-RBAC backend"))
+);
+var deriveImpliedAreaPermissions = (area, areaPermissions, skipPermissions = []) => {
+  const highestAreaPermissionLevelSelected = areaPermissions.reduce(
+    (highest, current) => uiPermissionsById[current].permissionLevel > highest ? uiPermissionsById[current].permissionLevel : highest,
+    1
+  );
+  return uiPermissionsByArea[area].uiPermissions.reduce((permissions, current) => {
+    if ((current.permissionLevel < highestAreaPermissionLevelSelected || areaPermissions.includes(current.value)) && !skipPermissions.includes(current.value)) {
+      permissions.push(current.value);
+    }
+    return permissions;
+  }, []);
+};
+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 impliedPermissions = deriveImpliedAreaPermissions(area, uiPermissions, skipPermissions);
+    accu = impliedPermissions.reduce((itemPermissionAccu, impliedPermission) => {
+      var _a;
+      const permissionSetState = (_a = itemPermissionAccu[uiPermissionsById[impliedPermission].permissionSets[area]]) != null ? _a : {
+        type: uiPermissionsByArea[area].scope,
+        value: []
+      };
+      itemPermissionAccu[uiPermissionsById[impliedPermission].permissionSets[area]] = __spreadProps(__spreadValues({}, permissionSetState), {
+        value: [...permissionSetState.value, item]
+      });
+      return itemPermissionAccu;
+    }, accu);
+    return accu;
+  }, {});
+  return Object.entries(permissionSetObject).map((_a) => {
+    var [name, _b] = _a, _c = _b, { value } = _c, scope = __objRest(_c, ["value"]);
+    if (value.includes(excessiveAccessSelector)) {
+      return { name };
+    }
+    return { name, scope: __spreadProps(__spreadValues({}, scope), { value: value.filter(duplicateFilter) }) };
+  });
+};
+var transformRoleDataToRole = (roleData, roleState = {}) => {
+  const role = __spreadValues(__spreadValues({}, roleState), roleData);
+  const { description = "", name, uiPermissions = emptyUiPermissions } = role;
+  const { maybeUiPermissions, remainderKeys } = Object.entries(emptyUiPermissions).reduce(
+    (accu, [key, emptyPermissions]) => {
+      if (!scopedPermissionAreas[key]) {
+        accu.remainderKeys.push(key);
+      } else if (uiPermissions[key]) {
+        accu.maybeUiPermissions[key] = uiPermissions[key].reduce(itemUiPermissionsReducer, emptyPermissions);
+      }
+      return accu;
+    },
+    { maybeUiPermissions: {}, remainderKeys: [] }
+  );
+  const { permissionSetsWithScope, roleUiPermissions } = remainderKeys.reduce(
+    (accu, area) => {
+      const areaPermissions = role.uiPermissions[area];
+      if (!Array.isArray(areaPermissions)) {
+        return accu;
+      }
+      const impliedPermissions = deriveImpliedAreaPermissions(area, areaPermissions);
+      accu.roleUiPermissions[area] = impliedPermissions;
+      const mappedPermissions = impliedPermissions.map((uiPermission) => ({ name: uiPermissionsById[uiPermission].permissionSets[area] }));
+      accu.permissionSetsWithScope.push(...mappedPermissions);
+      return accu;
+    },
+    { permissionSetsWithScope: [{ name: defaultPermissionSets.Basic.name }], roleUiPermissions: {} }
+  );
+  const scopedPermissionSets = Object.values(scopedPermissionAreas).reduce((accu, { key, excessiveAccessSelector }) => {
+    if (!uiPermissions[key]) {
+      return accu;
+    }
+    accu.push(...transformAreaRoleDataToScopedPermissionsSets(key, uiPermissions[key], excessiveAccessSelector));
+    return accu;
+  }, []);
+  return {
+    permissionSetsWithScope: [...permissionSetsWithScope, ...scopedPermissionSets],
+    role: __spreadProps(__spreadValues({}, emptyRole), {
+      name,
+      // @ts-ignore
+      description: description ? description : roleState.description,
+      uiPermissions: __spreadValues(__spreadValues(__spreadValues({}, emptyUiPermissions), roleUiPermissions), maybeUiPermissions)
+    })
+  };
+};
+var roleActions = {
+  create: {
+    successMessage: "The role was created successfully.",
+    errorMessage: "creating"
+  },
+  edit: {
+    successMessage: "The role has been updated.",
+    errorMessage: "editing"
+  },
+  remove: {
+    successMessage: "The role was deleted successfully.",
+    errorMessage: "removing"
+  }
+};
+var roleActionErrorHandler = (err, type, dispatch) => commonErrorHandler(err, `There was an error ${roleActions[type].errorMessage} the role.`, dispatch);
+var createRole = createAsyncThunk5(`${sliceName6}/createRole`, (roleData, { dispatch }) => {
+  const { permissionSetsWithScope, role } = transformRoleDataToRole(roleData);
+  return general_api_default.post(`${useradmApiUrlv2}/roles`, {
+    name: role.name,
+    description: role.description,
+    permission_sets_with_scope: permissionSetsWithScope
+  }).then(() => Promise.all([dispatch(actions6.createdRole(role)), dispatch(getRoles()), dispatch(setSnackbar4(roleActions.create.successMessage))])).catch((err) => roleActionErrorHandler(err, "create", dispatch));
+});
+var editRole = createAsyncThunk5(`${sliceName6}/editRole`, (roleData, { dispatch, getState }) => {
+  const { permissionSetsWithScope, role } = transformRoleDataToRole(roleData, getRolesById(getState())[roleData.name]);
+  return general_api_default.put(`${useradmApiUrlv2}/roles/${role.name}`, {
+    description: role.description,
+    name: role.name,
+    permission_sets_with_scope: permissionSetsWithScope
+  }).then(() => Promise.all([dispatch(actions6.createdRole(role)), dispatch(getRoles()), dispatch(setSnackbar4(roleActions.edit.successMessage))])).catch((err) => roleActionErrorHandler(err, "edit", dispatch));
+});
+var removeRole = createAsyncThunk5(
+  `${sliceName6}/removeRole`,
+  (roleId, { dispatch }) => (
+    // @ts-ignore
+    general_api_default.delete(`${useradmApiUrlv2}/roles/${roleId}`).then(() => Promise.all([dispatch(actions6.removedRole(roleId)), dispatch(getRoles()), dispatch(setSnackbar4(roleActions.remove.successMessage))])).catch((err) => roleActionErrorHandler(err, "remove", dispatch))
+  )
+);
+var getGlobalSettings2 = createAsyncThunk5(
+  `${sliceName6}/getGlobalSettings`,
+  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/settings`).then(({ data: settings, headers: { etag } }) => {
+    window.sessionStorage.setItem(settingsKeys.initialized, true);
+    return Promise.all([dispatch(actions6.setGlobalSettings(settings)), dispatch(setOfflineThreshold()), etag]);
+  })
+);
+var saveGlobalSettings = createAsyncThunk5(
+  `${sliceName6}/saveGlobalSettings`,
+  // @ts-ignore
+  (_a, { dispatch, getState }) => {
+    var _b = _a, { beOptimistic = false, notify = false } = _b, settings = __objRest(_b, ["beOptimistic", "notify"]);
+    if (!window.sessionStorage.getItem(settingsKeys.initialized) && !beOptimistic) {
+      return;
+    }
+    return dispatch(getGlobalSettings2()).unwrap().then((result) => {
+      let updatedSettings = __spreadValues(__spreadValues({}, getState().users.globalSettings), settings);
+      if (getCurrentUser(getState()).verified) {
+        updatedSettings["2fa"] = twoFAStates.enabled;
+      } else {
+        delete updatedSettings["2fa"];
+      }
+      let tasks = [dispatch(actions6.setGlobalSettings(updatedSettings))];
+      const headers = result[result.length - 1] ? { "If-Match": result[result.length - 1] } : {};
+      return general_api_default.post(`${useradmApiUrlv1}/settings`, updatedSettings, { headers }).then(() => {
+        if (notify) {
+          tasks.push(dispatch(setSnackbar4("Settings saved successfully")));
+        }
+        return Promise.all(tasks);
+      }).catch((err) => {
+        if (beOptimistic) {
+          return Promise.all([tasks]);
+        }
+        console.log(err);
+        return commonErrorHandler(err, `The settings couldn't be saved.`, dispatch);
+      });
+    });
+  }
+);
+var getUserSettings2 = createAsyncThunk5(
+  `${sliceName6}/getUserSettings`,
+  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/settings/me`).then(({ data: settings, headers: { etag } }) => {
+    window.sessionStorage.setItem(settingsKeys.initialized, true);
+    return Promise.all([dispatch(actions6.setUserSettings(settings)), etag]);
+  })
+);
+var saveUserSettings = createAsyncThunk5(`${sliceName6}/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 = __spreadProps(__spreadValues(__spreadValues({}, userSettings), settings), {
+      onboarding: __spreadValues(__spreadValues({}, onboardingState), settings.onboarding),
+      tooltips: tooltipState
+    });
+    const headers = result[result.length - 1] ? { "If-Match": result[result.length - 1] } : {};
+    return Promise.all([
+      Promise.resolve(dispatch(actions6.setUserSettings(updatedSettings))),
+      general_api_default.post(`${useradmApiUrlv1}/settings/me`, updatedSettings, { headers })
+    ]).catch(() => dispatch(actions6.setUserSettings(userSettings)));
+  });
+});
+var get2FAQRCode = createAsyncThunk5(
+  `${sliceName6}/get2FAQRCode`,
+  (_, { dispatch }) => general_api_default.get(`${useradmApiUrlv1}/2faqr`).then((res) => dispatch(actions6.receivedQrCode(res.data.qr)))
+);
+var setHideAnnouncement = createAsyncThunk5(`${sliceName6}/setHideAnnouncement`, ({ shouldHide, userId }, { dispatch, getState }) => {
+  const currentUserId = userId || getCurrentUser(getState()).id;
+  const hash = getState().app.hostedAnnouncement ? hashString2(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(setAnnouncement2()));
+  }
+  return Promise.resolve();
+});
+var getTokens = createAsyncThunk5(
+  `${sliceName6}/getTokens`,
+  (_, { dispatch, getState }) => general_api_default.get(`${useradmApiUrlv1}/settings/tokens`).then(({ data: tokens }) => {
+    const user = getCurrentUser(getState());
+    const updatedUser = __spreadProps(__spreadValues({}, user), {
+      tokens
+    });
+    return Promise.resolve(dispatch(actions6.updatedUser(updatedUser)));
+  })
+);
+var ONE_YEAR = 31536e3;
+var generateToken = createAsyncThunk5(
+  `${sliceName6}/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))
+);
+var revokeToken = createAsyncThunk5(
+  `${sliceName6}/revokeToken`,
+  (token, { dispatch }) => (
+    // @ts-ignore
+    general_api_default.delete(`${useradmApiUrlv1}/settings/tokens/${token.id}`).then(() => Promise.resolve(dispatch(getTokens())))
+  )
+);
+var setTooltipReadState = createAsyncThunk5(`${sliceName6}/setTooltipReadState`, (_a, { dispatch }) => {
+  var _b = _a, { persist } = _b, remainder = __objRest(_b, ["persist"]);
+  let tasks = [dispatch(actions6.setTooltipState(remainder))];
+  if (persist) {
+    tasks.push(dispatch(saveUserSettings()));
+  }
+  return Promise.all(tasks);
+});
+var setAllTooltipsReadState = createAsyncThunk5(`${sliceName6}/toggleHelptips`, ({ readState = READ_STATES.read, tooltips }, { dispatch }) => {
+  const updatedTips = tooltips.reduce((accu, id) => __spreadProps(__spreadValues({}, accu), { [id]: { readState } }), {});
+  return Promise.resolve(dispatch(actions6.setTooltipsState(updatedTips))).then(() => dispatch(saveUserSettings()));
+});
+var submitFeedback = createAsyncThunk5(
+  `${sliceName6}/submitFeedback`,
+  // @ts-ignore
+  (_a, { dispatch }) => {
+    var _b = _a, { satisfaction, feedback } = _b, meta = __objRest(_b, ["satisfaction", "feedback"]);
+    return general_api_default.post(`${tenantadmApiUrlv2}/contact/support`, {
+      subject: "feedback submission",
+      body: JSON.stringify({ feedback, satisfaction, meta })
+    }).then(() => {
+      const today = /* @__PURE__ */ new Date();
+      dispatch(saveUserSettings({ feedbackCollectedAt: today.toISOString().split("T")[0] }));
+      setTimeout(() => dispatch(actions6.setShowFeedbackDialog(false)), TIMEOUTS.threeSeconds);
+    });
+  }
+);
+
+// src/appSlice/thunks.ts
+import { deepCompare as deepCompare4 } from "@northern.tech/utils/helpers";
+import { createAsyncThunk as createAsyncThunk6 } from "@reduxjs/toolkit";
+import Cookies4 from "universal-cookie";
+var cookies4 = new Cookies4();
+var setFirstLoginAfterSignup = createAsyncThunk6(`${sliceName}/setFirstLoginAfterSignup`, (firstLoginAfterSignup, { dispatch }) => {
+  cookies4.set("firstLoginAfterSignup", !!firstLoginAfterSignup, { maxAge: 60, path: "/", domain: ".mender.io", sameSite: false });
+  dispatch(actions.setFirstLoginAfterSignup(!!firstLoginAfterSignup));
+});
+var dateFunctionMap = {
+  getDays: "getDate",
+  setDays: "setDate"
+};
+var setOfflineThreshold = createAsyncThunk6(`${sliceName}/setOfflineThreshold`, (_, { dispatch, getState }) => {
+  var _a, _b;
+  const { interval, intervalUnit } = getOfflineThresholdSettings(getState());
+  const today = /* @__PURE__ */ new Date();
+  const intervalName = `${intervalUnit.charAt(0).toUpperCase()}${intervalUnit.substring(1)}`;
+  const setter = (_a = dateFunctionMap[`set${intervalName}`]) != null ? _a : `set${intervalName}`;
+  const getter = (_b = dateFunctionMap[`get${intervalName}`]) != null ? _b : `get${intervalName}`;
+  today[setter](today[getter]() - interval);
+  let value;
+  try {
+    value = today.toISOString();
+  } catch (e) {
+    return Promise.resolve(dispatch(actions.setSnackbar("There was an error saving the offline threshold, please check your settings.")));
+  }
+  return Promise.resolve(dispatch(actions.setOfflineThreshold(value)));
+});
+var versionRegex = new RegExp(/\d+\.\d+/);
+var getLatestRelease = (thing) => {
+  const latestKey = Object.keys(thing).filter((key) => versionRegex.test(key)).sort().reverse()[0];
+  return thing[latestKey];
+};
+var repoKeyMap = {
+  integration: "Integration",
+  mender: "Mender-Client",
+  "mender-artifact": "Mender-Artifact"
+};
+var deductSaasState = (latestRelease, guiTags, saasReleases) => {
+  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;
+};
+var getLatestReleaseInfo = createAsyncThunk6(`${sliceName}/getLatestReleaseInfo`, (_, { dispatch, getState }) => {
+  if (!getFeatures(getState()).isHosted) {
+    return Promise.resolve();
+  }
+  return Promise.all([general_api_default.get("/versions.json"), general_api_default.get("/tags.json")]).catch((err) => {
+    console.log("init error:", extractErrorMessage(err));
+    return Promise.resolve([{ data: {} }, { data: [] }]);
+  }).then(([{ data }, { data: guiTags }]) => {
+    if (!guiTags.length) {
+      return Promise.resolve();
+    }
+    const { releases, saas } = data;
+    const latestRelease = getLatestRelease(getLatestRelease(releases));
+    const { latestRepos, latestVersions } = latestRelease.repos.reduce(
+      (accu, item) => {
+        if (repoKeyMap[item.name]) {
+          accu.latestVersions[repoKeyMap[item.name]] = getComparisonCompatibleVersion(item.version);
+        }
+        accu.latestRepos[item.name] = getComparisonCompatibleVersion(item.version);
+        return accu;
+      },
+      { latestVersions: __spreadValues({}, getState().app.versionInformation), latestRepos: {} }
+    );
+    const info = deductSaasState(latestRelease, guiTags, saas);
+    return Promise.resolve(
+      dispatch(
+        actions.setVersionInformation(__spreadProps(__spreadValues({}, latestVersions), {
+          backend: info,
+          GUI: info,
+          latestRelease: {
+            releaseDate: latestRelease.release_date,
+            repos: latestRepos
+          }
+        }))
+      )
+    );
+  });
+});
+var setSearchState = createAsyncThunk6(`${sliceName}/setSearchState`, (searchState, { dispatch, getState }) => {
+  const currentState = getSearchState(getState());
+  let nextState = __spreadProps(__spreadValues(__spreadValues({}, currentState), searchState), {
+    sort: __spreadValues(__spreadValues({}, currentState.sort), searchState.sort)
+  });
+  let tasks = [];
+  const _a = currentState, { isSearching: currentSearching, deviceIds: currentDevices, searchTotal: currentTotal } = _a, currentRequestState = __objRest(_a, ["isSearching", "deviceIds", "searchTotal"]);
+  const _b = nextState, { isSearching: nextSearching, deviceIds: nextDevices, searchTotal: nextTotal } = _b, nextRequestState = __objRest(_b, ["isSearching", "deviceIds", "searchTotal"]);
+  if (nextRequestState.searchTerm && !deepCompare4(currentRequestState, nextRequestState)) {
+    nextState.isSearching = true;
+    tasks.push(
+      dispatch(searchDevices(nextState)).unwrap().then((results) => {
+        const searchResult = results[results.length - 1];
+        return dispatch(actions.setSearchState(__spreadProps(__spreadValues({}, searchResult), { isSearching: false })));
+      }).catch(() => dispatch(actions.setSearchState({ isSearching: false, searchTotal: 0 })))
+    );
+  }
+  tasks.push(dispatch(actions.setSearchState(nextState)));
+  return Promise.all(tasks);
+});
+
+export {
+  setFirstLoginAfterSignup,
+  setOfflineThreshold,
+  getLatestReleaseInfo,
+  setSearchState,
+  deriveDeploymentGroup,
+  getDeploymentsByStatus2 as getDeploymentsByStatus,
+  createDeployment,
+  getDeploymentDevices,
+  getDeviceDeployments,
+  resetDeviceDeployments,
+  getSingleDeployment,
+  getDeviceLog,
+  abortDeployment,
+  updateDeploymentControlMap,
+  setDeploymentsState,
+  getDeploymentsConfig,
+  saveDeltaDeploymentsConfig,
+  getGroups2 as getGroups,
+  addDevicesToGroup,
+  removeDevicesFromGroup,
+  addStaticGroup,
+  removeStaticGroup,
+  getDynamicGroups,
+  addDynamicGroup,
+  updateDynamicGroup,
+  removeDynamicGroup,
+  selectGroup,
+  getGroupDevices,
+  getAllGroupDevices,
+  getAllDynamicGroupDevices,
+  getDeviceById2 as getDeviceById,
+  getDeviceInfo,
+  deriveInactiveDevices,
+  getDeviceCount,
+  getAllDeviceCounts,
+  getDeviceLimit,
+  setDeviceListState,
+  getDevicesByStatus,
+  getAllDevicesByStatus,
+  searchDevices,
+  getDeviceAttributes,
+  getReportingLimits,
+  ensureVersionString,
+  getReportsData,
+  deriveReportsData,
+  getReportsDataWithoutBackendSupport,
+  getDeviceConnect,
+  getSessionDetails,
+  getDeviceFileDownloadLink,
+  deviceFileUpload,
+  getDeviceAuth,
+  getDevicesWithAuth,
+  updateDeviceAuth,
+  updateDevicesAuth,
+  deleteAuthset,
+  preauthDevice,
+  decommissionDevice,
+  getDeviceConfig,
+  setDeviceConfig,
+  applyDeviceConfig,
+  setDeviceTags,
+  getDeviceTwin,
+  setDeviceTwin,
+  getSystemDevices,
+  getGatewayDevices,
+  getDevicesInBounds,
+  applyOnboardingFallbacks,
+  getOnboardingState2 as getOnboardingState,
+  setOnboardingDeviceType,
+  setOnboardingApproach,
+  setOnboardingComplete,
+  setOnboardingCanceled,
+  advanceOnboarding,
+  cancelRequest,
+  getTargetLocation,
+  createOrganizationTrial,
+  startCardUpdate,
+  confirmCardUpdate,
+  getCurrentCard,
+  startUpgrade,
+  cancelUpgrade,
+  completeUpgrade,
+  getAuditLogs,
+  getAuditLogsCsvLink,
+  setAuditlogsState,
+  tenantDataDivergedMessage,
+  addTenant,
+  getTenants,
+  setTenantsListState,
+  editTenantDeviceLimit,
+  removeTenant,
+  getUserOrganization,
+  sendSupportMessage,
+  requestPlanChange,
+  downloadLicenseReport,
+  createIntegration,
+  changeIntegration,
+  deleteIntegration,
+  getIntegrations,
+  getWebhookEvents,
+  storeSsoConfig,
+  changeSsoConfig,
+  deleteSsoConfig,
+  getSsoConfigById,
+  getSsoConfigs,
+  loginUser,
+  logoutUser,
+  switchUserOrganization,
+  passwordResetStart,
+  passwordResetComplete,
+  verifyEmailStart,
+  verifyEmailComplete,
+  verify2FA,
+  getUserList,
+  getUser,
+  initializeSelf,
+  updateUserColumnSettings,
+  createUser,
+  removeUser,
+  editUser,
+  addUserToCurrentTenant,
+  enableUser2fa,
+  disableUser2fa,
+  normalizeRbacRoles,
+  getPermissionSets,
+  getRoles,
+  createRole,
+  editRole,
+  removeRole,
+  getGlobalSettings2 as getGlobalSettings,
+  saveGlobalSettings,
+  getUserSettings2 as getUserSettings,
+  saveUserSettings,
+  get2FAQRCode,
+  setHideAnnouncement,
+  getTokens,
+  generateToken,
+  revokeToken,
+  setTooltipReadState,
+  setAllTooltipsReadState,
+  submitFeedback
+};
+//# sourceMappingURL=chunk-YNVSU3AA.mjs.map