@northern.tech/store 0.30.0 → 0.30.2

package/dist/thunks.js

@@ -1,387 +1,2483 @@
-import {
-  abortDeployment,
-  addDevicesToGroup,
-  addDynamicGroup,
-  addStaticGroup,
-  addTenant,
-  addUserToCurrentTenant,
-  advanceOnboarding,
-  applyDeviceConfig,
-  cancelRequest,
-  cancelUpgrade,
-  changeIntegration,
-  changeSsoConfig,
-  checkEmailExists,
-  completeUpgrade,
-  confirmCardUpdate,
-  createBillingProfile,
-  createDeployment,
-  createIntegration,
-  createOrganizationTrial,
-  createRole,
-  createUser,
-  decommissionDevice,
-  deleteAuthset,
-  deleteIntegration,
-  deleteSsoConfig,
-  deriveDeploymentGroup,
-  deviceFileUpload,
-  disableUser2fa,
-  downloadLicenseReport,
-  editBillingProfile,
-  editRole,
-  editTenant,
-  editUser,
-  enableUser2fa,
-  generateDeploymentLogAnalysis,
-  generateToken,
-  get2FAQRCode,
-  getAllDeviceCounts,
-  getAllDevicesByStatus,
-  getAllDynamicGroupDevices,
-  getAllGroupDevices,
-  getAuditLogs,
-  getAuditLogsCsvLink,
-  getBillingPreview,
-  getCurrentCard,
-  getCurrentSubscription,
-  getDeploymentDevices,
-  getDeploymentsByStatus,
-  getDeploymentsConfig,
-  getDeviceAttributes,
-  getDeviceAuth,
-  getDeviceById,
-  getDeviceConfig,
-  getDeviceConnect,
-  getDeviceDeployments,
-  getDeviceFileDownloadLink,
-  getDeviceInfo,
-  getDeviceLimits,
-  getDeviceLog,
-  getDeviceTwin,
-  getDevicesByStatus,
-  getDevicesWithAuth,
-  getDynamicGroup,
-  getDynamicGroups,
-  getGatewayDevices,
-  getGlobalSettings,
-  getGroupDevices,
-  getGroups,
-  getIntegrations,
-  getLatestReleaseInfo,
-  getOnboardingState,
-  getPermissionSets,
-  getProducts,
-  getReportDataWithoutBackendSupport,
-  getRoles,
-  getSessionDetails,
-  getSingleDeployment,
-  getSsoConfigById,
-  getSsoConfigs,
-  getSystemDevices,
-  getTargetLocation,
-  getTenants,
-  getTokens,
-  getUser,
-  getUserBilling,
-  getUserList,
-  getUserOrganization,
-  getUserSettings,
-  getUserSubscription,
-  getWebhookEvents,
-  initializeSelf,
-  loginUser,
-  logoutUser,
-  normalizeRbacRoles,
-  passwordResetComplete,
-  passwordResetStart,
-  preauthDevice,
-  removeDevicesFromGroup,
-  removeDynamicGroup,
-  removeReportsByGroupName,
-  removeRole,
-  removeStaticGroup,
-  removeTenant,
-  removeUser,
-  requestPlanChange,
-  requestPlanUpgrade,
-  resetDeviceDeployments,
-  revokeToken,
-  saveDeltaDeploymentsConfig,
-  saveGlobalSettings,
-  saveUserSettings,
-  searchDevices,
-  selectGroup,
-  sendSupportMessage,
-  setAllTooltipsReadState,
-  setAuditlogsState,
-  setDeploymentsState,
-  setDeviceConfig,
-  setDeviceListState,
-  setDeviceTags,
-  setDeviceTwin,
-  setFirstLoginAfterSignup,
-  setHideAnnouncement,
-  setOfflineThreshold,
-  setOnboardingApproach,
-  setOnboardingCanceled,
-  setOnboardingComplete,
-  setOnboardingDeviceType,
-  setSearchState,
-  setTenantsListState,
-  setTooltipReadState,
-  startCardUpdate,
-  startUpgrade,
-  storeSsoConfig,
-  submitUserFeedback,
-  switchUserOrganization,
-  tenantDataDivergedMessage,
-  transformProductResponse,
-  triggerDeviceUpdate,
-  updateDeploymentControlMap,
-  updateDeviceAuth,
-  updateDevicesAuth,
-  updateDynamicGroup,
-  updateReportData,
-  updateUserColumnSettings,
-  verify2FA,
-  verifyEmailComplete,
-  verifyEmailStart
-} from "./chunk-FCY7BUGK.js";
-import {
-  cancelFileUpload,
-  createArtifact,
-  editArtifact,
-  getArtifactInstallCount,
-  getArtifactUrl,
-  getDeltaGenerationJobDetails,
-  getDeltaGenerationJobs,
-  getExistingReleaseTags,
-  getRelease,
-  getReleases,
-  getUpdateTypes,
-  removeArtifact,
-  removeRelease,
-  removeReleases,
-  selectRelease,
-  setReleaseTags,
-  setReleasesListState,
-  setReleasesTags,
-  setSingleReleaseTags,
-  updateReleaseInfo,
-  uploadArtifact
-} from "./chunk-ARMI6SZS.js";
-import {
-  changeNotificationSetting,
-  getDeviceAlerts,
-  getDeviceMonitorConfig,
-  getIssueCountsByType,
-  getLatestDeviceAlerts
-} from "./chunk-AZF4YY3P.js";
-import "./chunk-NXLXPRYW.js";
-import "./chunk-XF3TZSZS.js";
-import "./chunk-JYPSCCT4.js";
-import "./chunk-HKN3RN2Z.js";
-import "./chunk-FG37HJLC.js";
-import "./chunk-Z2O6LYVP.js";
-import "./chunk-PQADM3M3.js";
-import "./chunk-YB3US6OT.js";
-import "./chunk-CQXDAXQF.js";
-import "./chunk-YDDE5TIH.js";
-import "./chunk-B5AI2YPV.js";
-import "./chunk-4UNLEL5A.js";
-import "./chunk-ECVQVQEL.js";
-import "./chunk-6V5IIIF7.js";
-import "./chunk-NMAXZ3ZY.js";
-import "./chunk-MNJXEB7S.js";
-import "./chunk-SJ75YKOA.js";
-import "./chunk-JXBTIFMS.js";
-import "./chunk-HPKXWNEF.js";
-import "./chunk-YO22XLHI.js";
-import "./chunk-JIS4PA3R.js";
-import "./chunk-O6VCSLNE.js";
-import "./chunk-TUPBZ6MQ.js";
-import "./chunk-4BHM6WVX.js";
-import "./chunk-FQAUVV6C.js";
-import "./chunk-L53CPHJU.js";
-import "./chunk-2DYA3X77.js";
-import "./chunk-FAJ3I2UQ.js";
-import "./chunk-ZKAH3APE.js";
-import "./chunk-DBBE6D36.js";
-export {
-  abortDeployment,
-  addDevicesToGroup,
-  addDynamicGroup,
-  addStaticGroup,
-  addTenant,
-  addUserToCurrentTenant,
-  advanceOnboarding,
-  applyDeviceConfig,
-  cancelFileUpload,
-  cancelRequest,
-  cancelUpgrade,
-  changeIntegration,
-  changeNotificationSetting,
-  changeSsoConfig,
-  checkEmailExists,
-  completeUpgrade,
-  confirmCardUpdate,
-  createArtifact,
-  createBillingProfile,
-  createDeployment,
-  createIntegration,
-  createOrganizationTrial,
-  createRole,
-  createUser,
-  decommissionDevice,
-  deleteAuthset,
-  deleteIntegration,
-  deleteSsoConfig,
-  deriveDeploymentGroup,
-  deviceFileUpload,
-  disableUser2fa,
-  downloadLicenseReport,
-  editArtifact,
-  editBillingProfile,
-  editRole,
-  editTenant,
-  editUser,
-  enableUser2fa,
-  generateDeploymentLogAnalysis,
-  generateToken,
-  get2FAQRCode,
-  getAllDeviceCounts,
-  getAllDevicesByStatus,
-  getAllDynamicGroupDevices,
-  getAllGroupDevices,
-  getArtifactInstallCount,
-  getArtifactUrl,
-  getAuditLogs,
-  getAuditLogsCsvLink,
-  getBillingPreview,
-  getCurrentCard,
-  getCurrentSubscription,
-  getDeltaGenerationJobDetails,
-  getDeltaGenerationJobs,
-  getDeploymentDevices,
-  getDeploymentsByStatus,
-  getDeploymentsConfig,
-  getDeviceAlerts,
-  getDeviceAttributes,
-  getDeviceAuth,
-  getDeviceById,
-  getDeviceConfig,
-  getDeviceConnect,
-  getDeviceDeployments,
-  getDeviceFileDownloadLink,
-  getDeviceInfo,
-  getDeviceLimits,
-  getDeviceLog,
-  getDeviceMonitorConfig,
-  getDeviceTwin,
-  getDevicesByStatus,
-  getDevicesWithAuth,
-  getDynamicGroup,
-  getDynamicGroups,
-  getExistingReleaseTags,
-  getGatewayDevices,
-  getGlobalSettings,
-  getGroupDevices,
-  getGroups,
-  getIntegrations,
-  getIssueCountsByType,
-  getLatestDeviceAlerts,
-  getLatestReleaseInfo,
-  getOnboardingState,
-  getPermissionSets,
-  getProducts,
-  getRelease,
-  getReleases,
-  getReportDataWithoutBackendSupport,
-  getRoles,
-  getSessionDetails,
-  getSingleDeployment,
-  getSsoConfigById,
-  getSsoConfigs,
-  getSystemDevices,
-  getTargetLocation,
-  getTenants,
-  getTokens,
-  getUpdateTypes,
-  getUser,
-  getUserBilling,
-  getUserList,
-  getUserOrganization,
-  getUserSettings,
-  getUserSubscription,
-  getWebhookEvents,
-  initializeSelf,
-  loginUser,
-  logoutUser,
-  normalizeRbacRoles,
-  passwordResetComplete,
-  passwordResetStart,
-  preauthDevice,
-  removeArtifact,
-  removeDevicesFromGroup,
-  removeDynamicGroup,
-  removeRelease,
-  removeReleases,
-  removeReportsByGroupName,
-  removeRole,
-  removeStaticGroup,
-  removeTenant,
-  removeUser,
-  requestPlanChange,
-  requestPlanUpgrade,
-  resetDeviceDeployments,
-  revokeToken,
-  saveDeltaDeploymentsConfig,
-  saveGlobalSettings,
-  saveUserSettings,
-  searchDevices,
-  selectGroup,
-  selectRelease,
-  sendSupportMessage,
-  setAllTooltipsReadState,
-  setAuditlogsState,
-  setDeploymentsState,
-  setDeviceConfig,
-  setDeviceListState,
-  setDeviceTags,
-  setDeviceTwin,
-  setFirstLoginAfterSignup,
-  setHideAnnouncement,
-  setOfflineThreshold,
-  setOnboardingApproach,
-  setOnboardingCanceled,
-  setOnboardingComplete,
-  setOnboardingDeviceType,
-  setReleaseTags,
-  setReleasesListState,
-  setReleasesTags,
-  setSearchState,
-  setSingleReleaseTags,
-  setTenantsListState,
-  setTooltipReadState,
-  startCardUpdate,
-  startUpgrade,
-  storeSsoConfig,
-  submitUserFeedback,
-  switchUserOrganization,
-  tenantDataDivergedMessage,
-  transformProductResponse,
-  triggerDeviceUpdate,
-  updateDeploymentControlMap,
-  updateDeviceAuth,
-  updateDevicesAuth,
-  updateDynamicGroup,
-  updateReleaseInfo,
-  updateReportData,
-  updateUserColumnSettings,
-  uploadArtifact,
-  verify2FA,
-  verifyEmailComplete,
-  verifyEmailStart
+import { ADDONS, PLANS, locations } from "./appSlice/constants.js";
+import { onboardingSteps, orderedOnboardingSteps } from "./onboardingSlice/constants.js";
+import { rootfsImageVersion } from "./releasesSlice/constants.js";
+import { ALL_DEVICE_STATES, ALL_RELEASES, APPLICATION_JSON_CONTENT_TYPE, APPLICATION_JWT_CONTENT_TYPE, DEPLOYMENT_ROUTES, DEPLOYMENT_STATES, DEPLOYMENT_TYPES, DEVICE_FILTERING_OPTIONS, DEVICE_LIST_DEFAULTS, DEVICE_STATES, EXTERNAL_PROVIDER, PermissionTypes, READ_STATES, SORTING_OPTIONS, SSO_TYPES, TENANT_LIST_DEFAULT, TIMEOUTS, UNGROUPED_GROUP, USER_LOGOUT, apiRoot, auditLogsApiUrl, defaultPermissionSets, deploymentPrototype, deploymentsApiUrl, deploymentsApiUrlV2, deviceAuthV2, deviceConfig, deviceConnect, emptyFilter, emptyRole, emptyUiPermissions, headerNames, inventoryApiUrl, inventoryApiUrlV2, iotManagerBaseURL, itemUiPermissionsReducer, maxSessionAge, rolesById, scopedPermissionAreas, settingsKeys, ssoIdpApiUrlv1, tenantadmApiUrlv1, tenantadmApiUrlv2, twoFAStates, uiPermissionsByArea, uiPermissionsById, useradmApiUrl, useradmApiUrlv2 } from "./constants.js";
+import { actions } from "./appSlice/index.js";
+import { actions as actions$1, sliceName as sliceName$1 } from "./deploymentsSlice/index.js";
+import { actions as actions$2, sliceName as sliceName$2 } from "./devicesSlice/index.js";
+import { actions as actions$3, sliceName as sliceName$3 } from "./onboardingSlice/index.js";
+import { actions as actions$4, sliceName as sliceName$4 } from "./organizationSlice/index.js";
+import { actions as actions$5, sliceName as sliceName$5 } from "./usersSlice/index.js";
+import actions_default from "./actions.js";
+import { cleanUp, getSessionInfo, setSessionInfo } from "./auth.js";
+import { getFeatures, getHostedAnnouncement, getSearchState } from "./appSlice/selectors.js";
+import { getDeploymentsById, getDeploymentsByStatus as getDeploymentsByStatus$1 } from "./deploymentsSlice/selectors.js";
+import { getAcceptedDevices, getDeviceById as getDeviceById$1, getDeviceCountsByStatus, getDeviceFilters, getDeviceListState, getDeviceReports, getDevicesById, getGroupsById, getSelectedGroup } from "./devicesSlice/selectors.js";
+import { getAuditlogState, getDeviceTwinIntegrations, getOrganization, getSpLimits, getTenantsList } from "./organizationSlice/selectors.js";
+import { convertDeviceListStateToFilters, convertToBackendSPLimits, extractErrorMessage as extractErrorMessage$1, filtersFilter, getComparisonCompatibleVersion, mapDeviceAttributes, mapFiltersToTerms, mapTermsToFilters, mergePermissions, parseSubscriptionPreview, progress, stripUndefined } from "./utils.js";
+import { getCurrentUser, getGlobalSettings as getGlobalSettings$1, getIdAttribute, getOfflineThresholdSettings, getRolesById, getSelectedDeviceAttribute, getTooltipsState, getUserSettings as getUserSettings$1, getUsersById } from "./usersSlice/selectors.js";
+import { getDeviceReportsForUser, getOnboardingState as getOnboardingState$1, getTenantCapabilities, getUserCapabilities } from "./commonSelectors.js";
+import { commonErrorFallback, commonErrorHandler, createAppAsyncThunk } from "./store.js";
+import Api from "./api/general-api.js";
+import { changeNotificationSetting, getDeviceAlerts, getDeviceMonitorConfig, getIssueCountsByType, getLatestDeviceAlerts } from "./monitorSlice/thunks.js";
+import { cancelFileUpload, createArtifact, editArtifact, getArtifactInstallCount, getArtifactUrl, getDeltaGenerationJobDetails, getDeltaGenerationJobs, getExistingReleaseTags, getRelease, getReleases, getUpdateTypes, removeArtifact, removeRelease, removeReleases, selectRelease, setReleaseTags, setReleasesListState, setReleasesTags, setSingleReleaseTags, updateReleaseInfo, uploadArtifact } from "./releasesSlice/thunks.js";
+import Api$1 from "./api/users-api.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { attributeDuplicateFilter, customSort, dateRangeToUnix, deepCompare, duplicateFilter, extractErrorMessage, getDemoDeviceAddress, getSnackbarMessage, isEmpty, standardizePhases } from "@northern.tech/utils/helpers";
+import Cookies from "universal-cookie";
+import dayjs from "dayjs";
+import { Link } from "react-router-dom";
+import { isCancel } from "axios";
+import Tracking from "@northern.tech/utils/tracking";
+import validator from "validator";
+import pluralize from "pluralize";
+import { v4 } from "uuid";
+import utc from "dayjs/plugin/utc.js";
+import hashString from "md5";
+import { clearAllRetryTimers } from "@northern.tech/utils/retrytimer";
+//#region src/appSlice/thunks.ts
+const cookies$3 = new Cookies();
+const setFirstLoginAfterSignup = createAppAsyncThunk(`app/setFirstLoginAfterSignup`, (firstLoginAfterSignup, { dispatch }) => {
+	cookies$3.set("firstLoginAfterSignup", !!firstLoginAfterSignup, {
+		maxAge: 60,
+		path: "/",
+		domain: ".mender.io",
+		sameSite: false
+	});
+	dispatch(actions.setFirstLoginAfterSignup(!!firstLoginAfterSignup));
+});
+const dateFunctionMap = {
+	getDays: "getDate",
+	setDays: "setDate"
 };
+const setOfflineThreshold = createAppAsyncThunk(`app/setOfflineThreshold`, async (_, { dispatch, getState }) => {
+	const { interval, intervalUnit } = getOfflineThresholdSettings(getState());
+	const today = /* @__PURE__ */ new Date();
+	const intervalName = `${intervalUnit.charAt(0).toUpperCase()}${intervalUnit.substring(1)}`;
+	const setter = dateFunctionMap[`set${intervalName}`] ?? `set${intervalName}`;
+	const getter = dateFunctionMap[`get${intervalName}`] ?? `get${intervalName}`;
+	today[setter](today[getter]() - interval);
+	let value;
+	try {
+		value = today.toISOString();
+	} catch {
+		dispatch(actions.setSnackbar("There was an error saving the offline threshold, please check your settings."));
+		return;
+	}
+	return dispatch(actions.setOfflineThreshold(value));
+});
+const versionRegex = /* @__PURE__ */ new RegExp(/\d+\.\d+/);
+const getLatestRelease = (thing) => {
+	return thing[Object.keys(thing).filter((key) => versionRegex.test(key)).sort().reverse()[0]];
+};
+const repoKeyMap = {
+	integration: "Integration",
+	"mender-artifact": "Mender-Artifact"
+};
+const deductSaasState = (latestRelease, guiTags) => {
+	const latestGuiTag = guiTags.length ? guiTags[0].name : "";
+	return latestGuiTag ? latestGuiTag : latestRelease.release;
+};
+const getLatestReleaseInfo = createAppAsyncThunk(`app/getLatestReleaseInfo`, async (_, { dispatch, getState }) => {
+	if (!getFeatures(getState()).isHosted) return;
+	const [{ data }, { data: guiTags }] = await Promise.all([Api.get("/versions.json"), Api.get("/tags.json")]).catch((err) => {
+		console.log("init error:", extractErrorMessage(err));
+		return [{ data: {} }, { data: [] }];
+	});
+	if (!guiTags.length) return;
+	const { releases } = 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: { ...getState().app.versionInformation },
+		latestRepos: {}
+	});
+	const info = deductSaasState(latestRelease, guiTags);
+	return dispatch(actions.setVersionInformation({
+		...latestVersions,
+		Server: info,
+		latestRelease: {
+			releaseDate: latestRelease.release_date,
+			repos: latestRepos
+		}
+	}));
+});
+const setSearchState = createAppAsyncThunk(`app/setSearchState`, (searchState, { dispatch, getState }) => {
+	const currentState = getSearchState(getState());
+	const nextState = {
+		...currentState,
+		...searchState,
+		sort: {
+			...currentState.sort,
+			...searchState.sort
+		}
+	};
+	const tasks = [];
+	const { isSearching: currentSearching, deviceIds: currentDevices, searchTotal: currentTotal, ...currentRequestState } = currentState;
+	const { isSearching: nextSearching, deviceIds: nextDevices, searchTotal: nextTotal, ...nextRequestState } = nextState;
+	if (nextRequestState.searchTerm && !deepCompare(currentRequestState, nextRequestState)) {
+		nextState.isSearching = true;
+		tasks.push(dispatch(searchDevices(nextState)).unwrap().then((searchResult) => dispatch(actions.setSearchState({
+			...searchResult,
+			isSearching: false
+		}))).catch(() => dispatch(actions.setSearchState({
+			isSearching: false,
+			searchTotal: 0
+		}))));
+	}
+	tasks.push(Promise.resolve(dispatch(actions.setSearchState(nextState))));
+	return Promise.all(tasks);
+});
+//#endregion
+//#region src/deploymentsSlice/thunks.ts
+const { isUUID } = validator;
+const { receivedDevice, setSnackbar: setSnackbar$3 } = actions_default;
+const { page: defaultPage$2, perPage: defaultPerPage$2 } = DEVICE_LIST_DEFAULTS;
+const deriveDeploymentGroup = ({ filter, group, groups = [], name }) => group || groups.length === 1 && !isUUID(name) ? groups[0] : filter?.name;
+const transformDeployments = (deployments, deploymentsById) => deployments.sort(customSort(true, "created")).reduce((accu, item) => {
+	const filter = item.filter;
+	let deployment = {
+		...deploymentPrototype,
+		...deploymentsById[item.id],
+		...item,
+		filter: filter ? {
+			...filter,
+			name: filter.name ?? filter.id,
+			filters: mapTermsToFilters(filter.terms)
+		} : void 0,
+		name: decodeURIComponent(item.name)
+	};
+	deployment = {
+		...deployment,
+		group: deriveDeploymentGroup(deployment)
+	};
+	accu.deployments[item.id] = deployment;
+	accu.deploymentIds.push(item.id);
+	return accu;
+}, {
+	deployments: {},
+	deploymentIds: []
+});
+const getDeploymentsByStatus = createAppAsyncThunk(`${sliceName$1}/getDeploymentsByStatus`, (options, { dispatch, getState }) => {
+	const { status, page = defaultPage$2, perPage = defaultPerPage$2, 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 { attribute, scope } = getIdAttribute(getState());
+	const attributeHint = `&id_attribute=${attribute}&id_scope=${scope}`;
+	const search = group ? `&name=${group}${attributeHint}` : "";
+	const typeFilter = type ? `&type=${type}` : "";
+	return Api.get(`${deploymentsApiUrlV2}/deployments?status=${status}&per_page=${perPage}&page=${page}${created_after}${created_before}${search}${typeFilter}&sort=${sort}`).then((res) => {
+		const { deployments, deploymentIds } = transformDeployments(res.data, getState().deployments.byId);
+		const total = Number(res.headers[headerNames.total]);
+		const tasks = [Promise.resolve(dispatch(actions$1.receivedDeployments(deployments))), Promise.resolve(dispatch(actions$1.receivedDeploymentsForStatus({
+			deploymentIds,
+			status,
+			total: !(startDate || endDate || group || type) ? total : getState().deployments.byStatus[status].total
+		})))];
+		deploymentIds.forEach((deploymentId) => {
+			if (deployments[deploymentId].type === DEPLOYMENT_TYPES.configuration) tasks.push(dispatch(getSingleDeployment(deploymentId)).unwrap());
+		});
+		if (shouldSelect) tasks.push(Promise.resolve(dispatch(actions$1.selectDeploymentsForStatus({
+			deploymentIds,
+			status,
+			total
+		}))));
+		tasks.push(Promise.resolve({
+			deploymentIds,
+			total
+		}));
+		return Promise.all(tasks);
+	});
+});
+const isWithinFirstMonth = (expirationDate) => {
+	if (!expirationDate) return false;
+	const endOfFirstMonth = new Date(expirationDate);
+	endOfFirstMonth.setMonth(endOfFirstMonth.getMonth() - 11);
+	return endOfFirstMonth > /* @__PURE__ */ new Date();
+};
+const trackDeploymentCreation = (totalDeploymentCount, hasDeployments, trial_expiration) => {
+	Tracking.event({
+		category: "deployments",
+		action: "create"
+	});
+	if (!totalDeploymentCount) {
+		if (!hasDeployments) {
+			Tracking.event({
+				category: "deployments",
+				action: "create_initial_deployment"
+			});
+			if (isWithinFirstMonth(trial_expiration)) Tracking.event({
+				category: "deployments",
+				action: "create_initial_deployment_first_month"
+			});
+		}
+		Tracking.event({
+			category: "deployments",
+			action: "create_initial_deployment_user"
+		});
+	}
+};
+const cleanPhases = (phases) => phases?.map(({ batch_size, batch_size_devices, start_ts }) => stripUndefined({
+	batch_size,
+	batch_size_devices,
+	start_ts
+}));
+const MAX_PREVIOUS_PHASES_COUNT = 5;
+const createDeployment = createAppAsyncThunk(`${sliceName$1}/createDeployment`, ({ newDeployment, hasNewRetryDefault = false }, { dispatch, getState }) => {
+	let request;
+	const { name, artifact_name, retries, update_control_map, autogenerate_delta } = newDeployment;
+	const common = stripUndefined({
+		name,
+		artifact_name,
+		phases: cleanPhases(newDeployment.phases),
+		retries,
+		update_control_map,
+		autogenerate_delta
+	});
+	if ("filter_id" in newDeployment && newDeployment.filter_id) {
+		const { filter_id, max_devices } = newDeployment;
+		request = Api.post(`${deploymentsApiUrlV2}/deployments`, stripUndefined({
+			...common,
+			filter_id,
+			max_devices
+		}));
+	} else if ("group" in newDeployment && newDeployment.group) {
+		const { force_installation, group } = newDeployment;
+		request = Api.post(`${deploymentsApiUrl}/deployments/group/${group}`, stripUndefined({
+			...common,
+			force_installation
+		}));
+	} else {
+		const { devices, all_devices, force_installation } = newDeployment;
+		request = Api.post(`${deploymentsApiUrl}/deployments`, stripUndefined({
+			...common,
+			devices,
+			all_devices,
+			force_installation
+		}));
+	}
+	const totalDeploymentCount = Object.values(getDeploymentsByStatus$1(getState())).reduce((accu, item) => accu + item.total, 0);
+	const { hasDeployments } = getGlobalSettings$1(getState());
+	const { trial_expiration } = getOrganization(getState());
+	return request.catch((err) => commonErrorHandler(err, "Error creating deployment.", dispatch)).then((data) => {
+		const lastslashindex = data.headers.location.lastIndexOf("/");
+		const deploymentId = data.headers.location.substring(lastslashindex + 1);
+		const deployment = {
+			...newDeployment,
+			id: deploymentId,
+			devices: "devices" in newDeployment && newDeployment.devices ? newDeployment.devices.map((id) => ({
+				id,
+				status: "pending"
+			})) : [],
+			statistics: { status: {} }
+		};
+		const tasks = [
+			Promise.resolve(dispatch(actions$1.createdDeployment(deployment))),
+			dispatch(getSingleDeployment(deploymentId)),
+			Promise.resolve(dispatch(setSnackbar$3({
+				message: "Deployment created successfully",
+				autoHideDuration: TIMEOUTS.fiveSeconds
+			})))
+		];
+		trackDeploymentCreation(totalDeploymentCount, hasDeployments, trial_expiration);
+		const { canManageUsers } = getUserCapabilities(getState());
+		if (canManageUsers) {
+			const { phases, retries } = newDeployment;
+			const { previousPhases = [], retries: previousRetries = 0 } = getGlobalSettings$1(getState());
+			const newSettings = {
+				retries: hasNewRetryDefault ? retries : previousRetries,
+				hasDeployments: true
+			};
+			if (phases) {
+				const standardPhases = standardizePhases(phases);
+				const 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);
+	});
+});
+const getDeploymentDevices = createAppAsyncThunk(`${sliceName$1}/getDeploymentDevices`, (options, { dispatch, getState }) => {
+	const { id, page = defaultPage$2, perPage = defaultPerPage$2 } = options;
+	return Api.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);
+		const tasks = [Promise.resolve(dispatch(actions$1.receivedDeploymentDevices({
+			id,
+			devices,
+			selectedDeviceIds,
+			totalDeviceCount: Number(response.headers[headerNames.total])
+		})))];
+		const devicesById = getDevicesById(getState());
+		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;
+		}, []).forEach((deviceId) => {
+			tasks.push(dispatch(getDeviceById(deviceId)).unwrap(), dispatch(getDeviceAuth(deviceId)).unwrap());
+		});
+		return Promise.all(tasks);
+	});
+});
+const 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;
+	}, "")
+});
+const getDeviceDeployments = createAppAsyncThunk(`${sliceName$1}/getDeviceDeployments`, (options, { dispatch }) => {
+	const { deviceId, filterSelection = [], page = defaultPage$2, perPage = defaultPerPage$2 } = options;
+	const filters = filterSelection.map((item) => `&status=${item}`).join("");
+	return Api.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));
+});
+const resetDeviceDeployments = createAppAsyncThunk(`${sliceName$1}/resetDeviceDeployments`, (deviceId, { dispatch }) => Api.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)));
+const getSingleDeployment = createAppAsyncThunk(`${sliceName$1}/getSingleDeployment`, (id, { dispatch, getState }) => Api.get(`${deploymentsApiUrl}/deployments/${id}`).then(({ data }) => {
+	const { deployments } = transformDeployments([data], getState().deployments.byId);
+	return Promise.resolve(dispatch(actions$1.receivedDeployment(deployments[id])));
+}));
+const getDeviceLog = createAppAsyncThunk(`${sliceName$1}/getDeviceLog`, ({ deploymentId, deviceId }, { dispatch }) => Api.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(actions$1.receivedDeploymentDeviceLog({
+	id: deploymentId,
+	deviceId,
+	log
+}))), Promise.resolve(log)])));
+const abortDeployment = createAppAsyncThunk(`${sliceName$1}/abortDeployment`, (deploymentId, { dispatch, getState }) => Api.put(`${deploymentsApiUrl}/deployments/${deploymentId}/status`, { status: "aborted" }).then(() => {
+	const deploymentsByStatus = getDeploymentsByStatus$1(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(actions$1.receivedDeployments(deployments)),
+		dispatch(actions$1.receivedDeploymentsForStatus({
+			deploymentIds,
+			status,
+			total
+		})),
+		dispatch(actions$1.removedDeployment(deploymentId)),
+		dispatch(setSnackbar$3("The deployment was successfully aborted"))
+	]);
+}).catch((err) => commonErrorHandler(err, "There was an error while aborting the deployment:", dispatch)));
+const updateDeploymentControlMap = createAppAsyncThunk(`${sliceName$1}/updateDeploymentControlMap`, ({ deploymentId, updateControlMap }, { dispatch }) => Api.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)))));
+const setDeploymentsState = createAppAsyncThunk(`${sliceName$1}/setDeploymentsState`, (selection, { dispatch, getState }) => {
+	const { page, perPage, ...selectionState } = selection;
+	const currentState = getState().deployments.selectionState;
+	const nextState = {
+		...currentState,
+		...selectionState,
+		...Object.keys(DEPLOYMENT_STATES).reduce((accu, item) => {
+			accu[item] = {
+				...currentState[item],
+				...selectionState[item]
+			};
+			return accu;
+		}, {}),
+		general: {
+			...currentState.general,
+			...selectionState.general
+		}
+	};
+	const tasks = [Promise.resolve(dispatch(actions$1.setDeploymentsState(nextState)))];
+	if (nextState.selectedId && currentState.selectedId !== nextState.selectedId) tasks.push(dispatch(getSingleDeployment(nextState.selectedId)));
+	return Promise.all(tasks);
+});
+const 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"
+	}
+];
+const mapExternalDeltaConfig = (config = {}) => deltaAttributeMappings.reduce((accu, { here, there }) => {
+	if (config[there] !== void 0) accu[here] = config[there];
+	return accu;
+}, {});
+const getDeploymentsConfig = createAppAsyncThunk(`${sliceName$1}/getDeploymentsConfig`, (_, { dispatch, getState }) => Api.get(`${deploymentsApiUrl}/config`).then(({ data }) => {
+	const oldConfig = getState().deployments.config;
+	const { delta = {} } = data;
+	const { binary_delta = {}, binary_delta_limits = {} } = delta;
+	const { xdelta_args = {} } = binary_delta;
+	const { xdelta_args_limits = {} } = binary_delta_limits;
+	const config = {
+		...oldConfig,
+		hasDelta: Boolean(delta.enabled),
+		binaryDelta: {
+			...oldConfig.binaryDelta,
+			...mapExternalDeltaConfig(xdelta_args)
+		},
+		binaryDeltaLimits: {
+			...oldConfig.binaryDeltaLimits,
+			...mapExternalDeltaConfig(xdelta_args_limits)
+		}
+	};
+	return Promise.resolve(dispatch(actions$1.setDeploymentsConfig(config)));
+}));
+const deepClean = (source) => Object.entries(source).reduce((accu, [key, value]) => {
+	if (value !== void 0) {
+		const cleanedValue = typeof value === "object" ? deepClean(value) : value;
+		if (cleanedValue === void 0 || typeof cleanedValue === "object" && isEmpty(cleanedValue)) return accu;
+		accu = {
+			...accu ?? {},
+			[key]: cleanedValue
+		};
+	}
+	return accu;
+}, void 0);
+const saveDeltaDeploymentsConfig = createAppAsyncThunk(`${sliceName$1}/saveDeltaDeploymentsConfig`, (config, { dispatch, getState }) => {
+	const result = deepClean({ xdelta_args: deltaAttributeMappings.reduce((accu, { here, there }) => {
+		if (config[here] !== void 0) accu[there] = config[here];
+		return accu;
+	}, {}) });
+	if (!result) return Promise.resolve();
+	return Api.put(`${deploymentsApiUrl}/config/binary_delta`, result).catch((err) => commonErrorHandler(err, "There was a problem storing your delta artifact generation configuration.", dispatch)).then(() => {
+		const oldConfig = getState().deployments.config;
+		const newConfig = {
+			...oldConfig,
+			binaryDelta: {
+				...oldConfig.binaryDelta,
+				...config
+			}
+		};
+		return Promise.all([dispatch(actions$1.setDeploymentsConfig(newConfig)), dispatch(setSnackbar$3("Settings saved successfully"))]);
+	});
+});
+const generateDeploymentLogAnalysis = createAppAsyncThunk(`${sliceName$1}/generateDeploymentLogAnalysis`, ({ deploymentId, deviceId }, { dispatch, rejectWithValue }) => Api.get(`${apiRoot}/v1alpha1/deployments/deployments/${deploymentId}/devices/${deviceId}/log/explain`, { timeout: 60 * TIMEOUTS.oneSecond }).then(({ data: result }) => Promise.resolve(result)).catch((err) => {
+	if (err.response.status === 429) return rejectWithValue(err.response);
+	commonErrorHandler(err, "There was an error analysing the deployment log:", dispatch);
+}));
+//#endregion
+//#region src/devicesSlice/thunks.tsx
+const { cleanUpUpload, initUpload, setSnackbar: setSnackbar$2, uploadProgress } = actions_default;
+const { page: defaultPage$1, perPage: defaultPerPage$1 } = DEVICE_LIST_DEFAULTS;
+const 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"
+	}
+];
+const getGroups = createAppAsyncThunk(`${sliceName$2}/getGroups`, async (_, { dispatch, getState }) => {
+	const res = await Api.get(`${inventoryApiUrl}/groups`);
+	const state = getGroupsById(getState());
+	const dynamicGroups = Object.entries(state).reduce((accu, [id, group]) => {
+		if (group.id || group.filters?.length && id !== UNGROUPED_GROUP.id) accu[id] = group;
+		return accu;
+	}, {});
+	const groups = res.data.reduce((accu, group) => {
+		accu[group] = {
+			deviceIds: [],
+			filters: [],
+			total: 0,
+			...state[group]
+		};
+		return accu;
+	}, dynamicGroups);
+	const filters = [{
+		key: "group",
+		value: res.data,
+		operator: DEVICE_FILTERING_OPTIONS.$nin.key,
+		scope: "system"
+	}];
+	const [, devicesRetrieval] = await Promise.all([dispatch(actions$2.receivedGroups(groups)), dispatch(getDevicesByStatus({
+		filterSelection: filters,
+		group: "",
+		page: 1,
+		perPage: 1,
+		status: void 0
+	}))]);
+	const { total } = devicesRetrieval?.payload ?? {};
+	if (!total) return;
+	return dispatch(actions$2.addGroup({
+		groupName: UNGROUPED_GROUP.id,
+		group: { filters: [{
+			key: "group",
+			value: res.data,
+			operator: DEVICE_FILTERING_OPTIONS.$nin.key,
+			scope: "system"
+		}] }
+	}));
+});
+const addDevicesToGroup = createAppAsyncThunk(`${sliceName$2}/addDevicesToGroup`, ({ group, deviceIds, isCreation }, { dispatch }) => Api.patch(`${inventoryApiUrl}/groups/${group}/devices`, deviceIds).then(() => dispatch(actions$2.addToGroup({
+	group,
+	deviceIds
+}))).finally(() => isCreation ? Promise.resolve(dispatch(getGroups())) : {}));
+const removeDevicesFromGroup = createAppAsyncThunk(`${sliceName$2}/removeDevicesFromGroup`, ({ group, deviceIds }, { dispatch }) => Api.delete(`${inventoryApiUrl}/groups/${group}/devices`, deviceIds).then(() => Promise.all([dispatch(actions$2.removeFromGroup({
+	group,
+	deviceIds
+})), dispatch(setSnackbar$2({
+	message: `The ${pluralize("devices", deviceIds.length)} ${pluralize("were", deviceIds.length)} removed from the group`,
+	autoHideDuration: TIMEOUTS.fiveSeconds
+}))])));
+const getGroupNotification = (newGroup, selectedGroup) => {
+	const successMessage = "The group was updated successfully";
+	if (newGroup === selectedGroup) return {
+		message: successMessage,
+		autoHideDuration: TIMEOUTS.fiveSeconds
+	};
+	return {
+		action: "",
+		autoHideDuration: TIMEOUTS.fiveSeconds,
+		message: /* @__PURE__ */ jsxs(Fragment, { children: [
+			successMessage,
+			" - ",
+			/* @__PURE__ */ jsx(Link, {
+				to: `/devices?inventory=group:eq:${newGroup}`,
+				children: "click here"
+			}),
+			" to see it."
+		] }),
+		preventClickToCopy: true
+	};
+};
+const addStaticGroup = createAppAsyncThunk(`${sliceName$2}/addStaticGroup`, ({ group, devices }, { dispatch, getState }) => Promise.resolve(dispatch(addDevicesToGroup({
+	group,
+	deviceIds: devices.map(({ id }) => id),
+	isCreation: true
+}))).then(() => Promise.resolve(dispatch(actions$2.addGroup({
+	group: {
+		deviceIds: [],
+		total: 0,
+		filters: [],
+		...getState().devices.groups.byId[group]
+	},
+	groupName: group
+}))).then(() => Promise.all([
+	dispatch(setDeviceListState({ setOnly: true })),
+	dispatch(getGroups()),
+	dispatch(setSnackbar$2(getGroupNotification(group, getState().devices.groups.selectedGroup)))
+]))).catch((err) => commonErrorHandler(err, `Group could not be updated:`, dispatch)));
+const removeReportsByGroupName = createAppAsyncThunk(`${sliceName$2}/removeReportsByGroupName`, (groupName, { dispatch, getState }) => {
+	if (!groupName) return Promise.resolve();
+	dispatch(saveUserSettings({ reports: getDeviceReportsForUser(getState()).filter((report) => report.group !== groupName) }));
+});
+const removeStaticGroup = createAppAsyncThunk(`${sliceName$2}/removeStaticGroup`, (groupName, { dispatch }) => Api.delete(`${inventoryApiUrl}/groups/${groupName}`).then(() => Promise.all([
+	dispatch(actions$2.removeGroup(groupName)),
+	dispatch(removeReportsByGroupName(groupName)),
+	dispatch(getGroups()),
+	dispatch(setSnackbar$2({
+		message: "Group was removed successfully",
+		autoHideDuration: TIMEOUTS.fiveSeconds
+	}))
+])));
+const getDynamicGroup = createAppAsyncThunk(`${sliceName$2}/getDynamicGroupById`, (id, { dispatch }) => Api.get(`${inventoryApiUrlV2}/filters/${id}`).catch((err) => {
+	if (err.response && err.response.status === 404) throw new Error("Request failed with status code 404");
+	return commonErrorHandler(err, `Error retrieving the group: `, dispatch, commonErrorFallback);
+}));
+const getDynamicGroups = createAppAsyncThunk(`${sliceName$2}/getDynamicGroups`, (_, { dispatch, getState }) => Api.get(`${inventoryApiUrlV2}/filters?per_page=500`).then(({ data: filters }) => {
+	const state = getGroupsById(getState());
+	const staticGroups = Object.entries(state).reduce((accu, [id, group]) => {
+		if (!(group.id || group.filters?.length)) accu[id] = group;
+		return accu;
+	}, {});
+	const groups = (filters || []).reduce((accu, filter) => {
+		accu[filter.name] = {
+			deviceIds: [],
+			total: 0,
+			...state[filter.name],
+			id: filter.id,
+			filters: mapTermsToFilters(filter.terms)
+		};
+		return accu;
+	}, staticGroups);
+	return Promise.resolve(dispatch(actions$2.receivedGroups(groups)));
+}).catch(() => console.log("Dynamic group retrieval failed - likely accessing a non-enterprise backend")));
+const addDynamicGroup = createAppAsyncThunk(`${sliceName$2}/addDynamicGroup`, ({ groupName, filterPredicates }, { dispatch, getState }) => Api.post(`${inventoryApiUrlV2}/filters`, {
+	name: groupName,
+	terms: mapFiltersToTerms(filterPredicates)
+}).then((res) => Promise.resolve(dispatch(actions$2.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(actions$2.setDeviceFilters(cleanedFilters)),
+		dispatch(setSnackbar$2(getGroupNotification(groupName, getState().devices.groups.selectedGroup))),
+		dispatch(getDynamicGroups())
+	]);
+})).catch((err) => commonErrorHandler(err, `Group could not be updated:`, dispatch)));
+const updateDynamicGroup = createAppAsyncThunk(`${sliceName$2}/updateDynamicGroup`, ({ groupName, filterPredicates }, { dispatch, getState }) => {
+	const filterId = getState().devices.groups.byId[groupName].id;
+	return Api.delete(`${inventoryApiUrlV2}/filters/${filterId}`).then(() => dispatch(addDynamicGroup({
+		groupName,
+		filterPredicates
+	})).unwrap());
+});
+const removeDynamicGroup = createAppAsyncThunk(`${sliceName$2}/removeDynamicGroup`, (groupName, { dispatch, getState }) => {
+	const filterId = getState().devices.groups.byId[groupName].id;
+	return Api.delete(`${inventoryApiUrlV2}/filters/${filterId}`).then(() => Promise.all([
+		dispatch(actions$2.removeGroup(groupName)),
+		dispatch(removeReportsByGroupName(groupName)),
+		dispatch(setSnackbar$2({
+			message: "Group was removed successfully",
+			autoHideDuration: TIMEOUTS.fiveSeconds
+		}))
+	]));
+});
+const getGroupFilters = (group, groupsState, filters = []) => {
+	const groupName = group === UNGROUPED_GROUP.id || group === UNGROUPED_GROUP.name ? UNGROUPED_GROUP.id : group;
+	const selectedGroup = groupsState.byId[groupName];
+	const groupFilterLength = selectedGroup?.filters?.length || 0;
+	return {
+		cleanedFilters: groupFilterLength ? [...filters, ...selectedGroup.filters || []].filter(filtersFilter) : filters,
+		groupName,
+		selectedGroup,
+		groupFilterLength
+	};
+};
+const selectGroup = createAppAsyncThunk(`${sliceName$2}/selectGroup`, ({ group, filters = [] }, { dispatch, getState }) => {
+	const { cleanedFilters, groupName, selectedGroup, groupFilterLength } = getGroupFilters(group, getState().devices.groups, filters);
+	if (getSelectedGroup(getState()) === groupName && (filters.length === 0 && !groupFilterLength || filters.length === cleanedFilters.length)) return Promise.resolve();
+	const tasks = [];
+	if (groupFilterLength) tasks.push(Promise.resolve(dispatch(actions$2.setDeviceFilters(cleanedFilters))));
+	else {
+		tasks.push(Promise.resolve(dispatch(actions$2.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(Promise.resolve(dispatch(actions$2.selectGroup(selectedGroupName))));
+	return Promise.all(tasks);
+});
+const getEarliestTs = (dateA = "", dateB = "") => !dateA || !dateB ? dateA || dateB : dateA < dateB ? dateA : dateB;
+const reduceReceivedDevices = (devices, ids, state, status) => devices.reduce((accu, device) => {
+	const stateDevice = getDeviceById$1(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 = {
+		...storedTags,
+		...tags
+	};
+	device.group = system.group ?? storedGroup;
+	device.monitor = {
+		...storedMonitor,
+		...monitor
+	};
+	device.identity_data = {
+		...storedIdentity,
+		...identity,
+		...device.identity_data ? device.identity_data : {}
+	};
+	device.status = status ? status : device.status || identity.status;
+	device.check_in_time_rounded = system.check_in_time ?? stateDevice.check_in_time_rounded;
+	device.check_in_time_exact = device.check_in_time ?? 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 ? {
+		...storedAttributes,
+		...inventory
+	} : storedAttributes;
+	accu.devicesById[device.id] = {
+		...stateDevice,
+		...device
+	};
+	accu.ids.push(device.id);
+	return accu;
+}, {
+	ids,
+	devicesById: {}
+});
+const getGroupDevices = createAppAsyncThunk(`${sliceName$2}/getGroupDevices`, async (options, { dispatch, getState }) => {
+	const { group, shouldIncludeAllStates, ...remainder } = options;
+	const { cleanedFilters: filterSelection } = getGroupFilters(group, getState().devices.groups);
+	const { deviceAccu, total } = await dispatch(getDevicesByStatus({
+		...remainder,
+		filterSelection,
+		group,
+		status: shouldIncludeAllStates ? void 0 : DEVICE_STATES.accepted
+	})).unwrap();
+	if (!group) return;
+	const stateGroup = getState().devices.groups.byId[group];
+	if (!stateGroup && !total && !deviceAccu.ids.length) return;
+	return dispatch(actions$2.addGroup({
+		group: {
+			deviceIds: deviceAccu.ids.length === total || stateGroup && stateGroup.deviceIds && deviceAccu.ids.length > stateGroup.deviceIds.length ? deviceAccu.ids : stateGroup.deviceIds,
+			total
+		},
+		groupName: group
+	}));
+});
+const getAllGroupDevices = createAppAsyncThunk(`${sliceName$2}/getAllGroupDevices`, ({ group, attribute }, { 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 = 500, page = defaultPage$1, devices = []) => Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		page,
+		per_page: perPage,
+		filters: filterTerms,
+		attributes: [...attributes, {
+			scope: "inventory",
+			attribute
+		}]
+	}).then((res) => {
+		const state = getState();
+		const deviceAccu = reduceReceivedDevices(res.data, devices, state);
+		dispatch(actions$2.receivedDevices(deviceAccu.devicesById));
+		if (Number(res.headers[headerNames.total]) > perPage * page) return getAllDevices(perPage, page + 1, deviceAccu.ids);
+		return Promise.resolve(dispatch(actions$2.addGroup({
+			group: {
+				deviceIds: deviceAccu.ids,
+				total: deviceAccu.ids.length
+			},
+			groupName: group
+		})));
+	});
+	return getAllDevices();
+});
+const getAllDynamicGroupDevices = createAppAsyncThunk(`${sliceName$2}/getAllDynamicGroupDevices`, ({ group, attribute }, { 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 = 500, page = defaultPage$1, devices = []) => Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		page,
+		per_page: perPage,
+		filters,
+		attributes: [...attributes, {
+			scope: "inventory",
+			attribute
+		}]
+	}).then((res) => {
+		const state = getState();
+		const deviceAccu = reduceReceivedDevices(res.data, devices, state);
+		dispatch(actions$2.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(actions$2.addGroup({
+			group: {
+				deviceIds: deviceAccu.ids,
+				total
+			},
+			groupName: group
+		})));
+	});
+	return getAllDevices();
+});
+const getDeviceById = createAppAsyncThunk(`${sliceName$2}/getDeviceById`, (id, { dispatch, getState }) => Api.get(`${inventoryApiUrl}/devices/${id}`).then((res) => {
+	const device = reduceReceivedDevices([res.data], [], getState()).devicesById[id];
+	device.etag = res.headers.etag;
+	dispatch(actions$2.receivedDevice(device));
+	return Promise.resolve(device);
+}).catch((err) => {
+	if (extractErrorMessage$1(err).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"
+			}],
+			log: false
+		}], [], getState()).devicesById[id];
+		dispatch(actions$2.receivedDevice(device));
+	}
+}));
+const getDeviceInfo = createAppAsyncThunk(`${sliceName$2}/getDeviceInfo`, (deviceId, { dispatch, getState }) => {
+	const device = getDeviceById$1(getState(), deviceId);
+	const { hasDeviceConfig, hasDeviceConnect, hasMonitor } = getTenantCapabilities(getState());
+	const { canConfigure } = getUserCapabilities(getState());
+	const integrations = getDeviceTwinIntegrations(getState());
+	const tasks = [
+		dispatch(getDeviceAuth(deviceId)),
+		dispatch(getDeviceById(deviceId)),
+		...integrations.map((integration) => dispatch(getDeviceTwin({
+			deviceId,
+			integration
+		})))
+	];
+	if (hasDeviceConfig && canConfigure && (device.status === DEVICE_STATES.accepted || device.status === DEVICE_STATES.preauth)) tasks.push(dispatch(getDeviceConfig(deviceId)));
+	if (device.status === DEVICE_STATES.accepted) {
+		if (hasDeviceConnect) tasks.push(dispatch(getDeviceConnect(deviceId)));
+		if (hasMonitor) {
+			tasks.push(dispatch(getLatestDeviceAlerts({ id: deviceId })));
+			tasks.push(dispatch(getDeviceMonitorConfig(deviceId)));
+		}
+	}
+	return Promise.all(tasks);
+});
+const getAllDeviceCounts = createAppAsyncThunk(`${sliceName$2}/getAllDeviceCounts`, (_, { dispatch }) => Api.get(`${inventoryApiUrlV2}/statistics`).then(({ data }) => {
+	const { devices_by_status } = data;
+	Object.entries(devices_by_status).map(([status, countsPerTier]) => dispatch(actions$2.setDevicesCountByStatus({
+		countsPerTier,
+		status
+	})));
+}));
+const getDeviceLimits = createAppAsyncThunk(`${sliceName$2}/getDeviceLimit`, (_, { dispatch }) => Api.get(`${deviceAuthV2}/limits/devices`).then((res) => dispatch(actions$2.setDeviceLimits(res.data))));
+const setDeviceListState = createAppAsyncThunk(`${sliceName$2}/setDeviceListState`, ({ shouldSelectDevices = true, forceRefresh, fetchAuth = true, ...selectionState }, { dispatch, getState }) => {
+	const currentState = getDeviceListState(getState());
+	const refreshTrigger = forceRefresh ? !currentState.refreshTrigger : selectionState.refreshTrigger;
+	const nextState = {
+		...currentState,
+		setOnly: false,
+		refreshTrigger,
+		...selectionState,
+		sort: {
+			...currentState.sort,
+			...selectionState.sort
+		}
+	};
+	const tasks = [];
+	const { isLoading: currentLoading, deviceIds: currentDevices, selection: currentSelection, ...currentRequestState } = currentState;
+	const { isLoading: nextLoading, deviceIds: nextDevices, selection: nextSelection, ...nextRequestState } = nextState;
+	if (!nextState.setOnly && !deepCompare(currentRequestState, nextRequestState)) {
+		const { direction: sortDown = SORTING_OPTIONS.desc, key: sortCol, scope: sortScope = "" } = nextState.sort ?? {};
+		const sortBy = sortCol ? [{
+			attribute: sortCol,
+			order: sortDown,
+			scope: sortScope
+		}] : void 0;
+		const applicableSelectedState = nextState.state === ALL_DEVICE_STATES ? void 0 : nextState.state;
+		nextState.isLoading = true;
+		tasks.push(dispatch(getDevicesByStatus({
+			...nextState,
+			status: applicableSelectedState,
+			sortOptions: sortBy,
+			fetchAuth
+		})).unwrap().then(({ deviceAccu, total }) => {
+			const devicesState = shouldSelectDevices ? {
+				deviceIds: deviceAccu.ids,
+				total,
+				isLoading: false
+			} : { isLoading: false };
+			return Promise.resolve(dispatch(actions$2.setDeviceListState(devicesState)));
+		}).catch(() => Promise.resolve({ isLoading: false })));
+	}
+	if (currentState.page !== nextState.page || currentState.perPage > nextState.perPage || currentState.state !== nextState.state || !deepCompare(currentState.sort, nextState.sort)) nextState.selection = [];
+	tasks.push(Promise.resolve(dispatch(actions$2.setDeviceListState(nextState))));
+	return Promise.all(tasks);
+});
+const getDevicesByStatus = createAppAsyncThunk(`${sliceName$2}/getDevicesByStatus`, async (options, { dispatch, getState }) => {
+	const { status, fetchAuth = true, filterSelection, group, selectedIssues = [], page = defaultPage$1, perPage = defaultPerPage$1, sortOptions = [], selectedAttributes = getSelectedDeviceAttribute(getState()) } = options;
+	const state = getState();
+	const { applicableFilters, filterTerms } = convertDeviceListStateToFilters({
+		filters: filterSelection ?? getDeviceFilters(state),
+		group: group ?? getSelectedGroup(state),
+		groups: state.devices.groups,
+		offlineThreshold: state.app.offlineThreshold,
+		selectedIssues,
+		status
+	});
+	const attributes = [
+		...defaultAttributes,
+		getIdAttribute(getState()),
+		...selectedAttributes
+	];
+	const response = await Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		page,
+		per_page: perPage,
+		filters: filterTerms,
+		sort: sortOptions,
+		attributes
+	}).catch((err) => commonErrorHandler(err, `${status} devices couldn't be loaded.`, dispatch, commonErrorFallback));
+	const currentState = getState();
+	const deviceAccu = reduceReceivedDevices(response.data, [], currentState, status);
+	let total = !applicableFilters.length ? Number(response.headers[headerNames.total]) : 0;
+	if (status && currentState.devices.byStatus[status].counts.total === deviceAccu.ids.length) total = deviceAccu.ids.length;
+	const sideEffects = [Promise.resolve(dispatch(actions$2.receivedDevices(deviceAccu.devicesById)))];
+	if (status) sideEffects.push(Promise.resolve(dispatch(actions$2.setDevicesByStatus({
+		deviceIds: deviceAccu.ids,
+		status,
+		total
+	}))));
+	const receivedDevices = Object.values(deviceAccu.devicesById);
+	if (receivedDevices.length && fetchAuth) sideEffects.push(dispatch(getDevicesWithAuth(receivedDevices)));
+	await Promise.all(sideEffects);
+	return {
+		deviceAccu,
+		total: Number(response.headers[headerNames.total])
+	};
+});
+const getAllDevicesByStatus = createAppAsyncThunk(`${sliceName$2}/getAllDevicesByStatus`, ({ status, attribute }, { dispatch, getState }) => {
+	const attributes = [...defaultAttributes, getIdAttribute(getState())];
+	const getAllDevices = (perPage = 500, page = 1, devices = []) => Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		page,
+		per_page: perPage,
+		filters: mapFiltersToTerms([{
+			key: "status",
+			value: status,
+			operator: DEVICE_FILTERING_OPTIONS.$eq.key,
+			scope: "identity"
+		}]),
+		attributes: [...attributes, {
+			scope: "inventory",
+			attribute
+		}]
+	}).then((res) => {
+		const state = getState();
+		const deviceAccu = reduceReceivedDevices(res.data, devices, state, status);
+		dispatch(actions$2.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);
+		return Promise.resolve();
+	});
+	return getAllDevices();
+});
+const searchDevices = createAppAsyncThunk(`${sliceName$2}/searchDevices`, async (passedOptions = {}, { dispatch, getState }) => {
+	const state = getState();
+	const { page = defaultPage$1, searchTerm, sortOptions = [] } = {
+		...state.app.searchState,
+		...passedOptions
+	};
+	const { columnSelection = [] } = getUserSettings$1(state);
+	const selectedAttributes = columnSelection.map((column) => ({
+		attribute: column.key,
+		scope: column.scope
+	}));
+	const attributes = attributeDuplicateFilter([
+		...defaultAttributes,
+		getIdAttribute(state),
+		...selectedAttributes
+	], "attribute");
+	const response = await Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		page,
+		per_page: 10,
+		filters: [],
+		sort: sortOptions,
+		text: searchTerm,
+		attributes
+	}).catch((err) => commonErrorHandler(err, `devices couldn't be searched.`, dispatch, commonErrorFallback));
+	const deviceAccu = reduceReceivedDevices(response.data, [], getState());
+	dispatch(actions$2.receivedDevices(deviceAccu.devicesById));
+	return {
+		deviceIds: deviceAccu.ids,
+		searchTotal: Number(response.headers[headerNames.total])
+	};
+});
+const ATTRIBUTE_LIST_CUTOFF = 100;
+const 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: []
+});
+const getDeviceAttributes = createAppAsyncThunk(`${sliceName$2}/getDeviceAttributes`, (_, { dispatch }) => Api.get(`${inventoryApiUrlV2}/filters/attributes`).then(({ data }) => {
+	const { identity: identityAttributes, inventory: inventoryAttributes, system: systemAttributes, tags: tagAttributes } = attributeReducer(data || []);
+	return dispatch(actions$2.setFilterAttributes({
+		identityAttributes,
+		inventoryAttributes,
+		systemAttributes,
+		tagAttributes
+	}));
+}));
+const initializeDistributionData = (report, groups, devices, totalDeviceCount) => {
+	const { attribute, group = "", software = "" } = report;
+	const effectiveAttribute = software ? software : attribute;
+	const { deviceIds, total = 0 } = groups[group] || {};
+	const distributionByAttribute = (deviceIds ? deviceIds.map((id) => devices[id]) : Object.values(devices)).reduce((accu, item) => {
+		if (!item.attributes || item.status !== DEVICE_STATES.accepted) return accu;
+		const attributeValue = item.attributes[effectiveAttribute];
+		if (!accu[attributeValue]) accu[attributeValue] = 0;
+		accu[attributeValue] = accu[attributeValue] + 1;
+		return accu;
+	}, {});
+	const items = Object.entries(distributionByAttribute).sort((pairA, pairB) => pairB[1] - pairA[1]).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
+	};
+};
+const updateReportData = createAppAsyncThunk(`${sliceName$2}/updateReportData`, (reportIndex, { dispatch, getState }) => {
+	const report = getDeviceReportsForUser(getState())[reportIndex];
+	const { group = "" } = report;
+	const devicesById = getDevicesById(getState());
+	const groups = getGroupsById(getState());
+	const { accepted: acceptedDevicesCount } = getDeviceCountsByStatus(getState());
+	const totalDeviceCount = groups[group] ? groups[group].total : acceptedDevicesCount;
+	const newReports = [...getDeviceReports(getState())];
+	newReports[reportIndex] = initializeDistributionData(report, groups, devicesById, totalDeviceCount);
+	return Promise.resolve(dispatch(actions$2.setDeviceReports(newReports)));
+});
+const getReportDataWithoutBackendSupport = createAppAsyncThunk(`${sliceName$2}/getReportDataWithoutBackendSupport`, (reportIndex, { dispatch, getState }) => {
+	const report = getDeviceReportsForUser(getState())[reportIndex];
+	if (!report) return;
+	const { attribute, group = "", software = "" } = report;
+	const effectiveAttribute = software ? software : attribute;
+	const devicesById = getDevicesById(getState());
+	const acceptedDevices = getAcceptedDevices(getState());
+	const { accepted: acceptedDevicesCount } = getDeviceCountsByStatus(getState());
+	const { deviceIds = [], filters = [], total = 0 } = getGroupsById(getState())[group] || {};
+	let groupDevicesRequest = Promise.resolve({ payload: {
+		groupName: "",
+		group: {
+			deviceIds: Object.keys(devicesById),
+			total: Object.keys(devicesById).length
+		}
+	} });
+	if (group && (!(deviceIds.length && total) || deviceIds.length !== total || !deviceIds.every((id) => !!devicesById[id]))) groupDevicesRequest = filters.length ? dispatch(getAllDynamicGroupDevices({
+		group,
+		attribute: effectiveAttribute
+	})).unwrap() : dispatch(getAllGroupDevices({
+		group,
+		attribute: effectiveAttribute
+	})).unwrap();
+	else if (!group && (acceptedDevices.deviceIds.length !== acceptedDevicesCount || !acceptedDevices.deviceIds.every((id) => !!devicesById[id]))) groupDevicesRequest = dispatch(getAllDevicesByStatus({
+		status: DEVICE_STATES.accepted,
+		attribute: effectiveAttribute
+	})).unwrap();
+	return groupDevicesRequest.then(() => dispatch(updateReportData(reportIndex)));
+});
+const getDeviceConnect = createAppAsyncThunk(`${sliceName$2}/getDeviceConnect`, (id, { dispatch }) => Api.get(`${deviceConnect}/devices/${id}`).then(({ data }) => Promise.all([dispatch(actions$2.receivedDevice({
+	connect_status: data.status,
+	connect_updated_ts: data.updated_ts,
+	id
+})), Promise.resolve(data)])));
+const updateTypeMap = {
+	deploymentUpdate: "check-update",
+	inventoryUpdate: "send-inventory"
+};
+const triggerDeviceUpdate = createAppAsyncThunk(`${sliceName$2}/triggerDeviceUpdate`, async ({ id, type }, { dispatch }) => {
+	await Api.post(`${deviceConnect}/devices/${id}/${updateTypeMap[type] ?? updateTypeMap.deploymentUpdate}`).catch((err) => commonErrorHandler(err, `The request couldn't be sent.`, dispatch));
+	dispatch(setSnackbar$2("Request has been sent."));
+	await new Promise((resolve) => setTimeout(resolve, TIMEOUTS.threeSeconds));
+	return dispatch(getDeviceById(id));
+});
+const getSessionDetails = createAppAsyncThunk(`${sliceName$2}/getSessionDetails`, ({ sessionId, deviceId, userId, startDate, endDate }) => {
+	const { start: startUnix, end: endUnix } = dateRangeToUnix(startDate, endDate);
+	const createdAfter = startDate ? `&created_after=${startUnix}` : "";
+	const createdBefore = endDate ? `&created_before=${endUnix}` : "";
+	const objectSearch = `&object_id=${deviceId}`;
+	return Api.get(`${auditLogsApiUrl}/logs?per_page=500${createdAfter}${createdBefore}&actor_id=${userId}${objectSearch}`).then(({ data: auditLogEntries }) => {
+		const { start, end } = auditLogEntries.reduce((accu, item) => {
+			if (item.meta?.session_id?.includes(sessionId)) {
+				accu.start = new Date(item.action.startsWith("open") ? item.time : accu.start);
+				accu.end = new Date(item.action.startsWith("close") ? item.time : accu.end);
+			}
+			return accu;
+		}, {
+			start: startDate || endDate,
+			end: endDate || startDate
+		});
+		return Promise.resolve({
+			start,
+			end
+		});
+	});
+});
+const getDeviceFileDownloadLink = createAppAsyncThunk(`${sliceName$2}/getDeviceFileDownloadLink`, ({ deviceId, path }) => Promise.resolve(`${window.location.origin}${deviceConnect}/devices/${deviceId}/download?path=${encodeURIComponent(path)}`));
+const deviceFileUpload = createAppAsyncThunk(`${sliceName$2}/deviceFileUpload`, ({ deviceId, path, file }, { dispatch }) => {
+	const formData = new FormData();
+	formData.append("path", path);
+	formData.append("file", file);
+	const uploadId = v4();
+	const cancelSource = new AbortController();
+	return Promise.all([
+		dispatch(setSnackbar$2("Uploading file")),
+		dispatch(initUpload({
+			id: uploadId,
+			upload: {
+				progress: 0,
+				cancelSource
+			}
+		})),
+		Api.uploadPut(`${deviceConnect}/devices/${deviceId}/upload`, formData, (e) => dispatch(uploadProgress({
+			id: uploadId,
+			progress: progress(e)
+		})), cancelSource.signal)
+	]).then(() => Promise.resolve(dispatch(setSnackbar$2({
+		message: "Upload successful",
+		autoHideDuration: TIMEOUTS.fiveSeconds
+	})))).catch((err) => {
+		if (isCancel(err)) return dispatch(setSnackbar$2({
+			message: "The upload has been cancelled",
+			autoHideDuration: TIMEOUTS.fiveSeconds
+		}));
+		return commonErrorHandler(err, `Error uploading file to device.`, dispatch);
+	}).finally(() => dispatch(cleanUpUpload(uploadId)));
+});
+const getDeviceAuth = createAppAsyncThunk(`${sliceName$2}/getDeviceAuth`, async (id, { dispatch }) => {
+	return (await dispatch(getDevicesWithAuth([{ id }])).unwrap())?.[0];
+});
+const getDevicesWithAuth = createAppAsyncThunk(`${sliceName$2}/getDevicesWithAuth`, async (devices, { dispatch, getState }) => {
+	if (!devices.length) return [];
+	const { data: receivedDevices } = await Api.get(`${deviceAuthV2}/devices?id=${devices.map((device) => device.id).join("&id=")}`).catch((err) => commonErrorHandler(err, `Error: ${err}`, dispatch));
+	const { devicesById } = reduceReceivedDevices(receivedDevices, [], getState());
+	dispatch(actions$2.receivedDevices(devicesById));
+	return receivedDevices;
+});
+const updateDeviceAuth = createAppAsyncThunk(`${sliceName$2}/updateDeviceAuth`, ({ deviceId, authId, status }, { dispatch, getState }) => Api.put(`${deviceAuthV2}/devices/${deviceId}/auth/${authId}/status`, { status }).then(() => Promise.all([dispatch(getDeviceAuth(deviceId)), dispatch(setSnackbar$2("Device authorization status was updated successfully"))])).catch((err) => commonErrorHandler(err, "There was a problem updating the device authorization status:", dispatch)).then(() => Promise.resolve(dispatch(actions$2.maybeUpdateDevicesByStatus({
+	deviceId,
+	authId
+})))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getDeviceListState(getState()).refreshTrigger }))));
+const updateDevicesAuth = createAppAsyncThunk(`${sliceName$2}/updateDevicesAuth`, ({ deviceIds, status }, { dispatch, getState }) => {
+	let devices = getDevicesById(getState());
+	return dispatch(getDevicesWithAuth(deviceIds.reduce((accu, id) => devices[id].auth_sets ? accu : [...accu, { id }], []))).then(() => {
+		devices = getDevicesById(getState());
+		const deviceAuthUpdates = deviceIds.map((id) => {
+			const device = devices[id];
+			if (device.auth_sets && device.auth_sets.length !== 1) return Promise.reject();
+			return dispatch(updateDeviceAuth({
+				authId: device.auth_sets[0].id,
+				deviceId: device.id,
+				status
+			})).unwrap().catch((err) => commonErrorHandler(err, "The action was stopped as there was a problem updating a device authorization status: ", dispatch, "", false));
+		});
+		return Promise.allSettled(deviceAuthUpdates).then((results) => {
+			const { skipped, count } = results.reduce((accu, item) => {
+				if (item.status === "rejected") accu.skipped = accu.skipped + 1;
+				else accu.count = accu.count + 1;
+				return accu;
+			}, {
+				skipped: 0,
+				count: 0
+			});
+			return dispatch(setSnackbar$2(getSnackbarMessage(skipped, count)));
+		});
+	});
+});
+const deleteAuthset = createAppAsyncThunk(`${sliceName$2}/deleteAuthset`, ({ deviceId, authId }, { dispatch, getState }) => Api.delete(`${deviceAuthV2}/devices/${deviceId}/auth/${authId}`).then(() => Promise.all([dispatch(setSnackbar$2("Device authorization status was updated successfully"))])).catch((err) => commonErrorHandler(err, "There was a problem updating the device authorization status:", dispatch)).then(() => Promise.resolve(dispatch(actions$2.maybeUpdateDevicesByStatus({
+	deviceId,
+	authId
+})))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getState().devices.deviceList.refreshTrigger }))));
+const preauthDevice = createAppAsyncThunk(`${sliceName$2}/preauthDevice`, (authset, { dispatch, rejectWithValue }) => Api.post(`${deviceAuthV2}/devices`, authset).then(() => Promise.resolve(dispatch(setSnackbar$2({
+	message: "Device was successfully added to the preauthorization list",
+	autoHideDuration: TIMEOUTS.fiveSeconds
+})))).catch((err) => {
+	if (err.response.status === 409) return rejectWithValue("A device with a matching identity data set already exists");
+	return commonErrorHandler(err, "The device could not be added:", dispatch);
+}));
+const decommissionDevice = createAppAsyncThunk(`${sliceName$2}/decommissionDevice`, ({ deviceId, authId }, { dispatch, getState }) => Api.delete(`${deviceAuthV2}/devices/${deviceId}`).then(() => Promise.resolve(dispatch(setSnackbar$2("Device was decommissioned successfully")))).catch((err) => commonErrorHandler(err, "There was a problem decommissioning the device:", dispatch)).then(() => Promise.resolve(dispatch(actions$2.maybeUpdateDevicesByStatus({
+	deviceId,
+	authId
+})))).finally(() => dispatch(setDeviceListState({ refreshTrigger: !getState().devices.deviceList.refreshTrigger }))));
+const getDeviceConfig = createAppAsyncThunk(`${sliceName$2}/getDeviceConfig`, (deviceId, { dispatch }) => Api.get(`${deviceConfig}/${deviceId}`).then(({ data }) => Promise.all([dispatch(actions$2.receivedDevice({
+	id: deviceId,
+	config: data
+})), Promise.resolve(data)])).catch((err) => {
+	if (err.response?.data?.error.status_code !== 404) return commonErrorHandler(err, `There was an error retrieving the configuration for device ${deviceId}.`, dispatch, commonErrorFallback);
+}));
+const setDeviceConfig = createAppAsyncThunk(`${sliceName$2}/setDeviceConfig`, ({ deviceId, config }, { dispatch }) => Api.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)))));
+const applyDeviceConfig = createAppAsyncThunk(`${sliceName$2}/applyDeviceConfig`, ({ deviceId, configDeploymentConfiguration, isDefault, config }, { dispatch, getState }) => Api.post(`${deviceConfig}/${deviceId}/deploy`, configDeploymentConfiguration).catch((err) => commonErrorHandler(err, `There was an error deploying the configuration to device ${deviceId}.`, dispatch, commonErrorFallback)).then(({ data }) => {
+	const device = getDeviceById$1(getState(), deviceId);
+	const { canManageUsers } = getUserCapabilities(getState());
+	const tasks = [Promise.resolve(dispatch(actions$2.receivedDevice({
+		...device,
+		config: {
+			...device.config,
+			deployment_id: data.deployment_id
+		}
+	}))), new Promise((resolve) => setTimeout(() => resolve(dispatch(getSingleDeployment(data.deployment_id))), TIMEOUTS.oneSecond))];
+	if (isDefault && canManageUsers) {
+		const { previous } = getGlobalSettings$1(getState()).defaultDeviceConfig ?? {};
+		tasks.push(dispatch(saveGlobalSettings({ defaultDeviceConfig: {
+			current: config,
+			previous
+		} })));
+	}
+	return Promise.all(tasks);
+}));
+const setDeviceTags = createAppAsyncThunk(`${sliceName$2}/setDeviceTags`, ({ deviceId, tags }, { dispatch }) => dispatch(getDeviceById(deviceId)).unwrap().then((device) => {
+	const headers = device.etag ? { "If-Match": device.etag } : {};
+	const tagList = Object.entries(tags).map(([name, value]) => ({
+		name,
+		value
+	}));
+	const isNameChange = tagList.some(({ name }) => name === "name");
+	return Api.put(`${inventoryApiUrl}/devices/${deviceId}/tags`, tagList, { headers }).catch((err) => commonErrorHandler(err, `There was an error setting tags for device ${deviceId}.`, dispatch, "Please check your connection.")).then(() => Promise.all([dispatch(actions$2.receivedDevice({
+		...device,
+		id: deviceId,
+		tags
+	})), dispatch(setSnackbar$2(`Device ${tagList.length === 1 && isNameChange ? "name" : "tags"} changed`))]));
+}));
+const getDeviceTwin = createAppAsyncThunk(`${sliceName$2}/getDeviceTwin`, ({ deviceId, integration }, { dispatch, getState }) => {
+	let providerResult = {};
+	return Api.get(`${iotManagerBaseURL}/devices/${deviceId}/state`).then(({ data }) => {
+		providerResult = {
+			...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$1(getState(), deviceId);
+		Promise.resolve(dispatch(actions$2.receivedDevice({
+			...device,
+			twinsByIntegration: {
+				...device.twinsByIntegration,
+				...providerResult
+			}
+		})));
+	});
+});
+const setDeviceTwin = createAppAsyncThunk(`${sliceName$2}/setDeviceTwin`, ({ deviceId, integration, settings }, { dispatch, getState }) => Api.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$1(getState(), deviceId);
+	const { twinsByIntegration = {} } = device;
+	const { [integration.id]: currentState = {} } = twinsByIntegration;
+	return Promise.resolve(dispatch(actions$2.receivedDevice({
+		...device,
+		twinsByIntegration: {
+			...twinsByIntegration,
+			[integration.id]: {
+				...currentState,
+				desired: settings
+			}
+		}
+	})));
+}));
+const prepareSearchArguments = ({ filters, group, state, status }) => {
+	const { filterTerms } = convertDeviceListStateToFilters({
+		filters,
+		group,
+		offlineThreshold: state.app.offlineThreshold,
+		selectedIssues: [],
+		status
+	});
+	const { columnSelection = [] } = getUserSettings$1(state);
+	const selectedAttributes = columnSelection.map((column) => ({
+		attribute: column.key,
+		scope: column.scope
+	}));
+	return {
+		attributes: [
+			...defaultAttributes,
+			getIdAttribute(state),
+			...selectedAttributes
+		],
+		filterTerms
+	};
+};
+const getSystemDevices = createAppAsyncThunk(`${sliceName$2}/getSystemDevices`, (options, { dispatch, getState }) => {
+	const { id, page = defaultPage$1, perPage = defaultPerPage$1, sortOptions = [] } = options;
+	const state = getState();
+	const { hasFullFiltering } = getTenantCapabilities(state);
+	if (!hasFullFiltering) return Promise.resolve();
+	const { attributes: deviceAttributes = {} } = getDeviceById$1(state, id);
+	const { mender_gateway_system_id = "" } = deviceAttributes;
+	const { attributes, filterTerms } = prepareSearchArguments({
+		filters: [{
+			...emptyFilter,
+			key: "mender_is_gateway",
+			operator: DEVICE_FILTERING_OPTIONS.$ne.key,
+			value: "true",
+			scope: "inventory"
+		}, {
+			...emptyFilter,
+			key: "mender_gateway_system_id",
+			value: mender_gateway_system_id,
+			scope: "inventory"
+		}],
+		state
+	});
+	return Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		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 state = getState();
+		const { devicesById, ids } = reduceReceivedDevices(data, [], state);
+		const device = {
+			...getDeviceById$1(state, id),
+			systemDeviceIds: ids,
+			systemDeviceTotal: Number(headers[headerNames.total])
+		};
+		return Promise.resolve(dispatch(actions$2.receivedDevices({
+			...devicesById,
+			[id]: device
+		})));
+	});
+});
+const getGatewayDevices = createAppAsyncThunk(`${sliceName$2}/getGatewayDevices`, (deviceId, { dispatch, getState }) => {
+	const state = getState();
+	const { attributes = {} } = getDeviceById$1(state, deviceId);
+	const { mender_gateway_system_id = "" } = attributes;
+	const { attributes: attributeSelection, filterTerms } = prepareSearchArguments({
+		filters: [
+			{
+				...emptyFilter,
+				key: "id",
+				operator: DEVICE_FILTERING_OPTIONS.$ne.key,
+				value: deviceId,
+				scope: "identity"
+			},
+			{
+				...emptyFilter,
+				key: "mender_is_gateway",
+				value: "true",
+				scope: "inventory"
+			},
+			{
+				...emptyFilter,
+				key: "mender_gateway_system_id",
+				value: mender_gateway_system_id,
+				scope: "inventory"
+			}
+		],
+		state
+	});
+	return Api.post(`${inventoryApiUrlV2}/filters/search`, {
+		page: 1,
+		per_page: 500,
+		filters: filterTerms,
+		attributes: attributeSelection
+	}).then(({ data }) => {
+		const { ids } = reduceReceivedDevices(data, [], getState());
+		const tasks = ids.map((deviceId) => dispatch(getDeviceInfo(deviceId)));
+		tasks.push(Promise.resolve(dispatch(actions$2.receivedDevice({
+			id: deviceId,
+			gatewayIds: ids
+		}))));
+		return Promise.all(tasks);
+	});
+});
+//#endregion
+//#region src/onboardingSlice/thunks.ts
+const cookies$2 = new Cookies();
+const determineProgress = (acceptedDevices, pendingDevices, releases, pastDeployments) => {
+	const steps = orderedOnboardingSteps;
+	let progress = -1;
+	progress = pendingDevices.length > 1 ? steps.findIndex((step) => step === onboardingSteps.DEVICES_PENDING_ACCEPTING_ONBOARDING) : progress;
+	progress = acceptedDevices.length >= 1 ? steps.findIndex((step) => step === onboardingSteps.DEVICES_ACCEPTED_ONBOARDING) : progress;
+	progress = acceptedDevices.length > 1 && releases.length > 1 && pastDeployments.length > 1 ? steps.findIndex((step) => step === onboardingSteps.DEPLOYMENTS_PAST_COMPLETED) : progress;
+	return steps[progress];
+};
+const deductOnboardingState = ({ devicesById, devicesByStatus, onboardingState, pastDeployments, releases, userCapabilities, userId }) => {
+	const { canDeploy, canManageDevices, canReadDeployments, canReadDevices, canReadReleases, canUploadReleases } = userCapabilities;
+	const userCookie = cookies$2.get(`${userId}-onboarded`);
+	const acceptedDevices = devicesByStatus[DEVICE_STATES.accepted].deviceIds;
+	const pendingDevices = devicesByStatus[DEVICE_STATES.pending].deviceIds;
+	let deviceType = onboardingState.deviceType ?? [];
+	deviceType = !deviceType.length && acceptedDevices.length && devicesById[acceptedDevices[0]].hasOwnProperty("attributes") ? devicesById[acceptedDevices[0]].attributes.device_type : deviceType;
+	const deviceTier = acceptedDevices.length && devicesById[acceptedDevices[0]].tier;
+	let approach = null;
+	if (deviceType.some((type) => type.startsWith("qemu"))) approach = "virtual";
+	else if (deviceType.some((type) => type.startsWith("esp32")) || deviceTier === "micro") approach = "mcu";
+	else if (deviceType.length) approach = "physical";
+	const progress = onboardingState.progress || determineProgress(acceptedDevices, pendingDevices, releases, pastDeployments);
+	return {
+		...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 === progress) >= 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 || approach,
+		progress
+	};
+};
+const getOnboardingState = createAppAsyncThunk(`${sliceName$3}/getOnboardingState`, (_, { dispatch, getState }) => {
+	const state = getState();
+	let onboardingState = getOnboardingState$1(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(actions$3.setOnboardingComplete(onboardingState.complete)),
+		dispatch(actions$3.setOnboardingState(onboardingState)),
+		dispatch(saveUserSettings({ onboarding: onboardingState }))
+	]);
+});
+const setOnboardingDeviceType = createAppAsyncThunk(`${sliceName$3}/setOnboardingDeviceType`, (value, { dispatch }) => Promise.all([dispatch(actions$3.setOnboardingDeviceType(value)), dispatch(saveUserSettings({ onboarding: { deviceType: value } }))]));
+const setOnboardingApproach = createAppAsyncThunk(`${sliceName$3}/setOnboardingApproach`, (value, { dispatch }) => Promise.all([dispatch(actions$3.setOnboardingApproach(value)), dispatch(saveUserSettings({ onboarding: { approach: value } }))]));
+const setOnboardingComplete = createAppAsyncThunk(`${sliceName$3}/setOnboardingComplete`, (value, { dispatch }) => {
+	const tasks = [Promise.resolve(dispatch(actions$3.setOnboardingComplete(value)))];
+	if (value) {
+		tasks.push(Promise.resolve(dispatch(actions$3.setShowOnboardingHelp(false))));
+		tasks.push(Promise.resolve(dispatch(advanceOnboarding(onboardingSteps.DEPLOYMENTS_PAST_COMPLETED))));
+	}
+	return Promise.all(tasks);
+});
+const setOnboardingCanceled = createAppAsyncThunk(`${sliceName$3}/setOnboardingCanceled`, (_, { dispatch }) => Promise.all([
+	Promise.resolve(dispatch(actions$3.setShowOnboardingHelp(false))),
+	Promise.resolve(dispatch(actions$3.setShowDismissOnboardingTipsDialog(false))),
+	Promise.resolve(dispatch(actions$3.setOnboardingComplete(true)))
+]).then(() => dispatch(advanceOnboarding(onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE))).then(() => Tracking.event({
+	category: "onboarding",
+	action: onboardingSteps.ONBOARDING_CANCELED
+})));
+const advanceOnboarding = createAppAsyncThunk(`${sliceName$3}/advanceOnboarding`, (stepId, { dispatch, getState }) => {
+	const steps = orderedOnboardingSteps;
+	const progress = steps.findIndex((step) => step === getState().onboarding.progress);
+	const stepIndex = steps.findIndex((step) => step === stepId);
+	if (progress > stepIndex || getState().onboarding.progress === null) return;
+	const madeProgress = steps[stepIndex + 1];
+	const state = {
+		...getOnboardingState$1(getState()),
+		progress: madeProgress
+	};
+	state.complete = stepIndex + 1 >= orderedOnboardingSteps.findIndex((step) => step === onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE) ? true : state.complete;
+	Tracking.event({
+		category: "onboarding",
+		action: stepId
+	});
+	return Promise.all([dispatch(actions$3.setOnboardingProgress(madeProgress)), dispatch(saveUserSettings({ onboarding: state }))]);
+});
+//#endregion
+//#region src/organizationSlice/thunks.ts
+const cookies$1 = new Cookies();
+dayjs.extend(utc);
+const { setAnnouncement: setAnnouncement$1, setSnackbar: setSnackbar$1 } = actions_default;
+const { page: defaultPage, perPage: defaultPerPage } = DEVICE_LIST_DEFAULTS;
+const cancelRequest = createAppAsyncThunk(`${sliceName$4}/cancelRequest`, (reason, { dispatch, getState }) => {
+	const { id: tenantId } = getOrganization(getState());
+	return Api.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/cancel`, { reason }).then(() => Promise.resolve(dispatch(setSnackbar$1({
+		message: "Deactivation request was sent successfully",
+		autoHideDuration: TIMEOUTS.fiveSeconds
+	}))));
+});
+const getTierId = (tierName) => tierName.replace("mender_", "");
+const getProductPlans = (products) => {
+	return {
+		...products.reduce((plansById, product) => {
+			const { name, prices } = product;
+			const tierId = getTierId(name);
+			prices.forEach((price) => {
+				const existing = plansById[price.plan] ?? {
+					...PLANS[price.plan],
+					tierLimitsConstrains: {}
+				};
+				const tierConstraints = price.constraints ? { [tierId]: {
+					min: price.constraints.min,
+					max: price.constraints.max,
+					div: price.constraints.div
+				} } : {};
+				plansById[price.plan] = {
+					...existing,
+					tierLimitsConstrains: {
+						...existing.tierLimitsConstrains,
+						...tierConstraints
+					}
+				};
+			});
+			return plansById;
+		}, {}),
+		enterprise: { ...PLANS.enterprise }
+	};
+};
+const getProductAddons = (products) => products.reduce((accu, product) => {
+	const { addons = [] } = product;
+	addons.forEach((addon) => {
+		const { name: addonName = "", prices: addonPrices = [] } = addon;
+		const existingEligible = accu[addonName]?.eligible ?? [];
+		const newEligible = addonPrices.map((p) => p.plan);
+		accu[addonName] = {
+			...ADDONS[addonName],
+			eligible: [...new Set([
+				...existingEligible,
+				...newEligible,
+				PLANS.enterprise.id
+			])]
+		};
+	});
+	return accu;
+}, {});
+const transformProductResponse = (products) => {
+	const tiers = [];
+	products.sort((a, b) => a.name.localeCompare(b.name)).forEach((tier) => {
+		const addonsSupported = Object.fromEntries((tier.addons || []).map((addon) => [addon.name, addon.prices?.map((p) => p.plan)]));
+		const addonsTransposed = tier.prices.map((price) => price.plan).reduce((acc, plan) => {
+			acc[plan] = Object.entries(addonsSupported).filter(([, addonSupportedPlans]) => addonSupportedPlans.includes(plan)).map(([addon]) => addon);
+			return acc;
+		}, {});
+		const tierId = getTierId(tier.name);
+		tiers.push({
+			id: tierId,
+			title: tierId,
+			stripeProductName: tier.name,
+			limitConstrains: Object.fromEntries(tier.prices.map((p) => [p.plan, p.constraints])),
+			addons: addonsSupported,
+			addonsByPlan: addonsTransposed
+		});
+	});
+	return {
+		plans: getProductPlans(products),
+		tiers,
+		addons: getProductAddons(products)
+	};
+};
+const 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}`;
+};
+const devLocations = ["localhost", "docker.mender.io"];
+const createOrganizationTrial = createAppAsyncThunk(`${sliceName$4}/createOrganizationTrial`, async (data, { dispatch }) => {
+	const { location, tos: _tos, ...trialPayload } = data;
+	const { key } = locations[location];
+	const targetLocation = getTargetLocation(key);
+	const target = `${targetLocation}${tenantadmApiUrlv2}/tenants/trial`;
+	const { headers } = await Api.postUnauthorized(target, trialPayload).catch((err) => {
+		if (err.response?.status >= 400 && err.response?.status < 500) dispatch(setSnackbar$1({
+			message: err.response.data.error,
+			autoHideDuration: TIMEOUTS.fiveSeconds
+		}));
+		else dispatch(setSnackbar$1({
+			message: "There was an error creating your account",
+			autoHideDuration: TIMEOUTS.fiveSeconds
+		}));
+		return Promise.reject(err);
+	});
+	cookies$1.remove("oauth");
+	cookies$1.remove("externalID");
+	cookies$1.remove("email");
+	dispatch(setFirstLoginAfterSignup(true));
+	return new Promise((resolve) => setTimeout(() => {
+		window.location.assign(`${targetLocation}${headers.location || ""}`);
+		return resolve();
+	}, TIMEOUTS.fiveSeconds));
+});
+const startCardUpdate = createAppAsyncThunk(`${sliceName$4}/startCardUpdate`, (_, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/billing/card`).then(({ data }) => {
+	dispatch(actions$4.receiveSetupIntent(data.intent_id));
+	return Promise.resolve(data.secret);
+}).catch((err) => commonErrorHandler(err, `Updating the card failed:`, dispatch)));
+const confirmCardUpdate = createAppAsyncThunk(`${sliceName$4}/confirmCardUpdate`, (_, { dispatch, getState }) => Api.post(`${tenantadmApiUrlv2}/billing/card/${getState().organization.intentId}/confirm`).then(() => Promise.all([dispatch(setSnackbar$1("Payment card was updated successfully")), dispatch(actions$4.receiveSetupIntent(null))])).catch((err) => commonErrorHandler(err, `Updating the card failed:`, dispatch)));
+const getCurrentCard = createAppAsyncThunk(`${sliceName$4}/getCurrentCard`, (_, { dispatch }) => Api.get(`${tenantadmApiUrlv2}/billing`).then((res) => {
+	const { last4, exp_month, exp_year, brand } = res.data.card || {};
+	return Promise.resolve(dispatch(actions$4.receiveCurrentCard({
+		brand,
+		last4,
+		expiration: {
+			month: exp_month,
+			year: exp_year
+		}
+	})));
+}));
+const startUpgrade = createAppAsyncThunk(`${sliceName$4}/startUpgrade`, (tenantId, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/upgrade/start`).then(({ data }) => Promise.resolve(data.secret)).catch((err) => commonErrorHandler(err, `There was an error upgrading your account:`, dispatch)));
+const cancelUpgrade = createAppAsyncThunk(`${sliceName$4}/cancelUpgrade`, (tenantId) => Api.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/upgrade/cancel`));
+const completeUpgrade = createAppAsyncThunk(`${sliceName$4}/completeUpgrade`, ({ tenantId, plan, billing_profile }, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/upgrade/complete`, {
+	plan,
+	billing_profile
+}).catch((err) => commonErrorHandler(err, `There was an error upgrading your account:`, dispatch)).then(() => Promise.all([dispatch(getDeviceLimits()), dispatch(getUserOrganization())])));
+const prepareAuditlogQuery = ({ startDate, endDate, user: userFilter, type, detail: detailFilter, sort = { direction: SORTING_OPTIONS.desc } }) => {
+	const userId = typeof userFilter === "object" && userFilter ? userFilter.id : userFilter;
+	const detail = typeof detailFilter === "object" && detailFilter ? detailFilter.id : detailFilter;
+	const { start: startUnix, end: endUnix } = dateRangeToUnix(startDate, endDate);
+	const createdAfter = startDate ? `&created_after=${startUnix}` : "";
+	const createdBefore = endDate ? `&created_before=${endUnix}` : "";
+	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}`;
+};
+const getAuditLogs = createAppAsyncThunk(`${sliceName$4}/getAuditLogs`, async (selectionState, { dispatch, getState }) => {
+	const { page, perPage } = selectionState;
+	const { hasAuditlogs } = getTenantCapabilities(getState());
+	if (!hasAuditlogs) return;
+	const { data, headers } = await Api.get(`${auditLogsApiUrl}/logs?page=${page}&per_page=${perPage}${prepareAuditlogQuery(selectionState)}`).catch((err) => commonErrorHandler(err, `There was an error retrieving audit logs:`, dispatch));
+	const total = Number(headers[headerNames.total] || data.length);
+	return dispatch(actions$4.receiveAuditLogs({
+		events: data,
+		total
+	}));
+});
+const getAuditLogsCsvLink = createAppAsyncThunk(`${sliceName$4}/getAuditLogsCsvLink`, (_, { getState }) => Promise.resolve(`${window.location.origin}${auditLogsApiUrl}/logs/export?limit=20000${prepareAuditlogQuery(getAuditlogState(getState()))}`));
+const setAuditlogsState = createAppAsyncThunk(`${sliceName$4}/setAuditlogsState`, (selectionState, { dispatch, getState }) => {
+	const currentState = getAuditlogState(getState());
+	const nextState = {
+		...currentState,
+		...selectionState,
+		sort: {
+			...currentState.sort,
+			...selectionState.sort
+		}
+	};
+	const tasks = [];
+	const { isLoading: currentLoading, selectedIssue: currentIssue, ...currentRequestState } = currentState;
+	const { isLoading: selectionLoading, selectedIssue: selectionIssue, ...selectionRequestState } = nextState;
+	if (!deepCompare(currentRequestState, selectionRequestState)) {
+		nextState.isLoading = true;
+		tasks.push(dispatch(getAuditLogs(nextState)).finally(() => dispatch(actions$4.setAuditLogState({ isLoading: false }))));
+	}
+	tasks.push(Promise.resolve(dispatch(actions$4.setAuditLogState(nextState))));
+	return Promise.all(tasks);
+});
+const tenantDataDivergedMessage = "The system detected there is a change in your plan or purchased add-ons. Please log out and log in again";
+const addTenant = createAppAsyncThunk(`${sliceName$4}/createTenant`, (selectionState, { dispatch, getState }) => {
+	const spLimits = getSpLimits(getState());
+	const { deviceLimits, ...rest } = selectionState;
+	const device_limits = convertToBackendSPLimits(deviceLimits, spLimits);
+	return Api.post(`${tenantadmApiUrlv2}/tenants`, {
+		...rest,
+		device_limits
+	}).then(() => Promise.all([dispatch(setSnackbar$1("Tenant was created successfully.")), new Promise((resolve) => setTimeout(() => resolve(dispatch(getTenants())), TIMEOUTS.oneSecond))])).catch((err) => commonErrorHandler(err, "There was an error creating tenant", dispatch, commonErrorFallback));
+});
+const tenantListRetrieval = async (config) => {
+	const { page, perPage } = config;
+	const params = new URLSearchParams({
+		page,
+		per_page: perPage,
+		tiers: "true"
+	}).toString();
+	const tenantList = await Api.get(`${tenantadmApiUrlv2}/tenants?${params}`);
+	const totalCount = tenantList.headers[headerNames.total] || TENANT_LIST_DEFAULT.perPage;
+	return [tenantList.data, Number(totalCount)];
+};
+const getTenants = createAppAsyncThunk(`${sliceName$4}/getTenants`, async (_, { dispatch, getState }) => {
+	const currentState = getTenantsList(getState());
+	const [tenants, pageCount] = await tenantListRetrieval(currentState);
+	dispatch(actions$4.setTenantListState({
+		...currentState,
+		total: pageCount,
+		tenants
+	}));
+});
+const setTenantsListState = createAppAsyncThunk(`${sliceName$4}/setTenantsListState`, async (selectionState, { dispatch, getState }) => {
+	const currentState = getTenantsList(getState());
+	const nextState = {
+		...currentState,
+		...selectionState
+	};
+	if (!deepCompare(currentState, selectionState)) {
+		const [tenants, pageCount] = await tenantListRetrieval(nextState);
+		return dispatch(actions$4.setTenantListState({
+			...nextState,
+			tenants,
+			total: pageCount
+		}));
+	}
+	return dispatch(actions$4.setTenantListState({ ...nextState }));
+});
+const editTenant = createAppAsyncThunk(`${sliceName$4}/editDeviceLimit`, ({ deviceLimits, id, name }, { dispatch, getState }) => {
+	const device_limits = convertToBackendSPLimits(deviceLimits, getSpLimits(getState()));
+	return Api.put(`${tenantadmApiUrlv2}/tenants/${id}/child`, {
+		device_limits,
+		name
+	}).catch((err) => commonErrorHandler(err, `Device Limit cannot be changed`, dispatch)).then(() => Promise.all([
+		dispatch(setSnackbar$1("Tenant was changed successfully")),
+		dispatch(getUserOrganization()),
+		new Promise((resolve) => setTimeout(() => resolve(dispatch(getTenants())), TIMEOUTS.oneSecond))
+	]));
+});
+const editBillingProfile = createAppAsyncThunk(`${sliceName$4}/editBillingProfileEmail`, ({ billingProfile }, { dispatch }) => Api.patch(`${tenantadmApiUrlv2}/billing/profile`, billingProfile).catch((err) => commonErrorHandler(err, `Failed to change billing profile`, dispatch)).then(() => Promise.all([dispatch(setSnackbar$1("Billing Profile was changed successfully")), dispatch(getUserBilling())])));
+const createBillingProfile = createAppAsyncThunk(`${sliceName$4}/createBillingProfileEmail`, ({ billingProfile }, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/billing/profile`, billingProfile).catch((err) => commonErrorHandler(err, `Failed to create billing profile`, dispatch)).then(() => Promise.all([dispatch(setSnackbar$1("Billing Profile was created successfully")), dispatch(getUserBilling())])));
+const removeTenant = createAppAsyncThunk(`${sliceName$4}/editDeviceLimit`, ({ id }, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/tenants/${id}/remove/start`).catch((err) => commonErrorHandler(err, `There was an error removing the tenant`, dispatch)).then(() => Promise.all([
+	dispatch(setSnackbar$1("The tenant was removed successfully")),
+	dispatch(getUserOrganization()),
+	new Promise((resolve) => setTimeout(() => resolve(dispatch(getTenants())), TIMEOUTS.oneSecond))
+])));
+const getUserOrganization = createAppAsyncThunk(`${sliceName$4}/getUserOrganization`, (_, { dispatch, getState }) => Api.get(`${tenantadmApiUrlv1}/user/tenant?tiers=true`).then((res) => {
+	const { addons, plan, trial } = res.data;
+	const { addons: currentAddons, id: currentId, plan: currentPlan, trial: currentTrial } = getOrganization(getState());
+	const tasks = [dispatch(actions$4.setOrganization(res.data))];
+	if (currentId && !deepCompare({
+		addons,
+		plan,
+		trial
+	}, {
+		addons: currentAddons,
+		plan: currentPlan,
+		trial: currentTrial
+	})) {
+		const hash = hashString(tenantDataDivergedMessage);
+		const { id: currentUserId } = getCurrentUser(getState());
+		cookies$1.remove(`${currentUserId}${hash}`);
+		tasks.push(dispatch(setAnnouncement$1(tenantDataDivergedMessage)));
+	}
+	return Promise.all(tasks);
+}));
+const getUserBilling = createAppAsyncThunk(`${sliceName$4}/getUserBilling`, (_, { dispatch }) => Api.get(`${tenantadmApiUrlv2}/billing/profile`).catch((err) => commonErrorHandler(err, "There was an error getting your billing profile:", dispatch, commonErrorFallback)).then((res) => dispatch(actions$4.setBillingProfile(res.data))));
+const getUserSubscription = createAppAsyncThunk(`${sliceName$4}/getUserSubscription`, async (_, { dispatch }) => {
+	const currentSubscription = await dispatch(getCurrentSubscription()).unwrap();
+	const currentPreview = await dispatch(getBillingPreview({ preview_mode: "next" })).unwrap();
+	return dispatch(actions$4.setSubscription({
+		...currentPreview,
+		...currentSubscription
+	}));
+});
+const getBillingPreview = createAppAsyncThunk(`${sliceName$4}/getBillingPreview`, (order, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/billing/subscription/invoices/preview`, order).catch((err) => commonErrorHandler(err, "There was an error getting your billing information:", dispatch, commonErrorFallback)).then(({ data }) => order.preview_mode === "recurring" ? {
+	items: parseSubscriptionPreview(data.lines),
+	total: data.total
+} : data));
+const getCurrentSubscription = createAppAsyncThunk(`${sliceName$4}/getCurrentSubscription`, (_, { dispatch }) => Api.get(`${tenantadmApiUrlv2}/billing/subscription`).then((res) => res.data).catch((err) => {
+	if (err.response && err.response.status === 404) throw new Error("Request failed with status code 404");
+	return commonErrorHandler(err, "There was an error retrieving your current subscription", dispatch, commonErrorFallback);
+}));
+const getProducts = createAppAsyncThunk(`${sliceName$4}/getEnabledTiers`, (_, { dispatch }) => Api.get(`${tenantadmApiUrlv2}/billing/products`).catch((err) => commonErrorHandler(err, "There was an error getting Mender products:", dispatch, commonErrorFallback)).then((res) => dispatch(actions$4.setProducts(transformProductResponse(res.data)))));
+const requestPlanUpgrade = createAppAsyncThunk(`${sliceName$4}/requestPlanUpgrade`, (order, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/billing/subscription`, order).catch((err) => commonErrorHandler(err, "There was an error sending your request", dispatch, commonErrorFallback)).then(() => Promise.all([setTimeout(() => dispatch(getDeviceLimits()), TIMEOUTS.threeSeconds), dispatch(getUserOrganization())])));
+const sendSupportMessage = createAppAsyncThunk(`${sliceName$4}/sendSupportMessage`, (content, { dispatch }) => Api.post(`${tenantadmApiUrlv2}/contact/support`, content).catch((err) => commonErrorHandler(err, "There was an error sending your request", dispatch, commonErrorFallback)).then(() => Promise.resolve(dispatch(setSnackbar$1({
+	message: "Your request was sent successfully",
+	autoHideDuration: TIMEOUTS.fiveSeconds
+})))));
+const requestPlanChange = createAppAsyncThunk(`${sliceName$4}/requestPlanChange`, ({ content, tenantId }, { dispatch, rejectWithValue }) => Api.post(`${tenantadmApiUrlv2}/tenants/${tenantId}/plan`, content).catch(async (err) => {
+	await commonErrorHandler(err, "There was an error sending your request", dispatch, commonErrorFallback);
+	rejectWithValue(err);
+}).then(() => Promise.resolve(dispatch(setSnackbar$1({
+	message: "Your request was sent successfully",
+	autoHideDuration: TIMEOUTS.fiveSeconds
+})))));
+const downloadLicenseReport = createAppAsyncThunk(`${sliceName$4}/downloadLicenseReport`, (_, { dispatch }) => Api.get(`${deviceAuthV2}/license`).catch((err) => commonErrorHandler(err, "There was an error downloading the report", dispatch, commonErrorFallback)).then((res) => res.data));
+const createIntegration = createAppAsyncThunk(`${sliceName$4}/createIntegration`, ({ id, ...integration }, { dispatch }) => Api.post(`${iotManagerBaseURL}/integrations`, integration).catch((err) => commonErrorHandler(err, "There was an error creating the integration", dispatch, commonErrorFallback)).then(() => Promise.all([dispatch(setSnackbar$1("The integration was set up successfully")), dispatch(getIntegrations())])));
+const changeIntegration = createAppAsyncThunk(`${sliceName$4}/changeIntegration`, ({ id, credentials }, { dispatch }) => Api.put(`${iotManagerBaseURL}/integrations/${id}/credentials`, credentials).catch((err) => commonErrorHandler(err, "There was an error updating the integration", dispatch, commonErrorFallback)).then(() => Promise.all([dispatch(setSnackbar$1("The integration was updated successfully")), dispatch(getIntegrations())])));
+const deleteIntegration = createAppAsyncThunk(`${sliceName$4}/deleteIntegration`, ({ id, provider }, { dispatch, getState }) => Api.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(setSnackbar$1("The integration was removed successfully")), dispatch(actions$4.receiveExternalDeviceIntegrations(integrations))]);
+}));
+const getIntegrations = createAppAsyncThunk(`${sliceName$4}/getIntegrations`, (_, { dispatch, getState }) => Api.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) => {
+		const integration = {
+			...existingIntegrations.find((integration) => item.id === integration.id) ?? {},
+			...item
+		};
+		accu.push(integration);
+		return accu;
+	}, []);
+	return Promise.resolve(dispatch(actions$4.receiveExternalDeviceIntegrations(integrations)));
+}));
+const getWebhookEvents = createAppAsyncThunk(`${sliceName$4}/getWebhookEvents`, (config = {}, { dispatch, getState }) => {
+	const { isFollowUp, page = defaultPage, perPage = defaultPerPage } = config;
+	return Api.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 }) => {
+		const tasks = [Promise.resolve(dispatch(actions$4.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);
+	});
+});
+const ssoConfigActions = {
+	create: {
+		success: "stored",
+		error: "storing"
+	},
+	edit: {
+		success: "updated",
+		error: "updating"
+	},
+	read: {
+		success: "",
+		error: "retrieving"
+	},
+	remove: {
+		success: "removed",
+		error: "removing"
+	},
+	readMultiple: {
+		success: "",
+		error: "retrieving"
+	}
+};
+const ssoConfigActionErrorHandler = (err, type) => (dispatch) => commonErrorHandler(err, `There was an error ${ssoConfigActions[type].error} the SSO configuration.`, dispatch, commonErrorFallback);
+const ssoConfigActionSuccessHandler = (type) => (dispatch) => dispatch(setSnackbar$1(`The SSO configuration was ${ssoConfigActions[type].success} successfully`));
+const storeSsoConfig = createAppAsyncThunk(`${sliceName$4}/storeSsoConfig`, ({ config, contentType }, { dispatch }) => Api.post(ssoIdpApiUrlv1, config, { headers: {
+	"Content-Type": contentType,
+	Accept: "application/json"
+} }).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "create"))).then(() => Promise.all([dispatch(ssoConfigActionSuccessHandler("create")), dispatch(getSsoConfigs())])));
+const changeSsoConfig = createAppAsyncThunk(`${sliceName$4}/changeSsoConfig`, ({ config, contentType }, { dispatch }) => Api.put(`${ssoIdpApiUrlv1}/${config.id}`, config.config, { headers: {
+	"Content-Type": contentType,
+	Accept: "application/json"
+} }).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "edit"))).then(() => Promise.all([dispatch(ssoConfigActionSuccessHandler("edit")), dispatch(getSsoConfigs())])));
+const deleteSsoConfig = createAppAsyncThunk(`${sliceName$4}/deleteSsoConfig`, ({ id }, { dispatch, getState }) => Api.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(actions$4.receiveSsoConfigs(configs))]);
+}));
+const getSsoConfigById = createAppAsyncThunk(`${sliceName$4}/getSsoConfigById`, (config, { dispatch }) => Api.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({
+		...config,
+		config: data,
+		type: sso.id
+	}) : Promise.reject("Unsupported SSO config content type.");
+}));
+const getSsoConfigs = createAppAsyncThunk(`${sliceName$4}/getSsoConfigs`, (_, { dispatch }) => Api.get(ssoIdpApiUrlv1).catch((err) => dispatch(ssoConfigActionErrorHandler(err, "readMultiple"))).then(({ data }) => Promise.all(data.map((config) => dispatch(getSsoConfigById(config)).unwrap())).then((configs) => dispatch(actions$4.receiveSsoConfigs(configs))).catch((err) => commonErrorHandler(err, err, dispatch, ""))));
+//#endregion
+//#region src/usersSlice/thunks.ts
+const cookies = new Cookies();
+const { setAnnouncement, setSnackbar } = actions_default;
+const handleLoginError = (err, { token2fa: has2FA, password }, rejectWithValue) => () => {
+	const is2FABackend = extractErrorMessage(err).includes("2fa");
+	if (is2FABackend && !has2FA) return rejectWithValue({ error: "2fa code missing" });
+	if (password === void 0) return Promise.reject();
+	const twoFAError = is2FABackend ? " and verification code" : "";
+	return rejectWithValue({ error: `There was a problem logging in. Please check your email${twoFAError ? "," : " and"} password${twoFAError}. If you still have problems, contact an administrator.` });
+};
+const loginUser = createAppAsyncThunk(`${sliceName$5}/loginUser`, ({ stayLoggedIn, ...userData }, { dispatch, rejectWithValue }) => Api$1.postLogin(`${useradmApiUrl}/auth/login`, {
+	...userData,
+	no_expiry: stayLoggedIn
+}).catch((err) => {
+	cleanUp();
+	return Promise.reject(dispatch(handleLoginError(err, userData, rejectWithValue)));
+}).then(({ text: token, contentType }) => {
+	if (contentType?.includes(APPLICATION_JSON_CONTENT_TYPE)) {
+		const { id, kind } = token;
+		const ssoLoginUrl = SSO_TYPES[kind.split("/")[1]].getStartUrl(id);
+		window.location.replace(ssoLoginUrl);
+		return;
+	}
+	if (contentType !== APPLICATION_JWT_CONTENT_TYPE || !token) return;
+	const now = /* @__PURE__ */ new Date();
+	now.setSeconds(now.getSeconds() + maxSessionAge);
+	const expiresAt = stayLoggedIn ? void 0 : now.toISOString();
+	setSessionInfo({
+		token,
+		expiresAt
+	});
+	cookies.remove("JWT", { path: "/" });
+	return dispatch(getUser("me")).unwrap().catch((e) => {
+		cleanUp();
+		return Promise.reject(dispatch(setSnackbar(extractErrorMessage(e))));
+	}).then(() => {
+		window.sessionStorage.removeItem("pendings-redirect");
+		if (window.location.pathname !== "/ui/") window.location.replace("/ui/");
+		return Promise.resolve(dispatch(actions$5.successfullyLoggedIn({
+			expiresAt,
+			token
+		})));
+	});
+}));
+const logoutUser = createAppAsyncThunk(`${sliceName$5}/logoutUser`, (_, { dispatch, getState }) => {
+	if (Object.keys(getState().app.uploadsById).length) return Promise.reject();
+	return Api.post(`${useradmApiUrl}/auth/logout`).finally(() => {
+		cleanUp();
+		clearAllRetryTimers(setSnackbar);
+		return Promise.resolve(dispatch({ type: USER_LOGOUT }));
+	});
+});
+const switchUserOrganization = createAppAsyncThunk(`${sliceName$5}/switchUserOrganization`, (tenantId, { getState }) => {
+	if (Object.keys(getState().app.uploadsById).length) return Promise.reject();
+	return Api.get(`${useradmApiUrl}/users/tenants/${tenantId}/token`).then(({ data: token }) => {
+		window.sessionStorage.setItem("tenantChanged", "true");
+		setSessionInfo({
+			...getSessionInfo(),
+			token
+		});
+		window.location.reload();
+	});
+});
+const passwordResetStart = createAppAsyncThunk(`${sliceName$5}/passwordResetStart`, (email, { dispatch }) => Api.post(`${useradmApiUrl}/auth/password-reset/start`, { email }).catch((err) => commonErrorHandler(err, `The password reset request cannot be processed:`, dispatch, void 0, true)));
+const passwordResetComplete = createAppAsyncThunk(`${sliceName$5}/passwordResetComplete`, ({ secretHash, newPassword }, { dispatch }) => Api.post(`${useradmApiUrl}/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(setSnackbar("The password reset request cannot be processed: " + errorMsg));
+	return Promise.reject(err);
+}));
+const verifyEmailStart = createAppAsyncThunk(`${sliceName$5}/verifyEmailStart`, (_, { dispatch, getState }) => Api.post(`${useradmApiUrl}/auth/verify-email/start`, { email: getCurrentUser(getState()).email }).catch((err) => commonErrorHandler(err, "An error occured starting the email verification process:", dispatch)).finally(() => Promise.resolve(dispatch(getUser("me")))));
+const verifyEmailComplete = createAppAsyncThunk(`${sliceName$5}/verifyEmailComplete`, (secret_hash, { dispatch, rejectWithValue }) => Api.post(`${useradmApiUrl}/auth/verify-email/complete`, { secret_hash }).catch((err) => rejectWithValue({
+	status: err.response?.status,
+	data: err.response?.data
+})).finally(() => Promise.resolve(dispatch(getUser("me")))));
+const verify2FA = createAppAsyncThunk(`${sliceName$5}/verify2FA`, (tfaData, { dispatch }) => Api$1.putVerifyTFA(`${useradmApiUrl}/2faverify`, tfaData).then(() => Promise.resolve(dispatch(getUser("me")))).catch((err) => commonErrorHandler(err, "An error occured validating the verification code: failed to verify token, please try again.", dispatch, void 0, true)));
+const getUserList = createAppAsyncThunk(`${sliceName$5}/getUserList`, (_, { dispatch, getState }) => Api.get(`${useradmApiUrl}/users`).then((res) => {
+	const currentUsersById = getUsersById(getState());
+	const users = res.data.reduce((accu, item) => {
+		accu[item.id] = {
+			...accu[item.id],
+			...item
+		};
+		return accu;
+	}, { ...currentUsersById });
+	return dispatch(actions$5.receivedUserList(users));
+}).catch((err) => commonErrorHandler(err, `Users couldn't be loaded.`, dispatch, commonErrorFallback)));
+const getUser = createAppAsyncThunk(`${sliceName$5}/getUser`, (id, { dispatch, rejectWithValue }) => Api.get(`${useradmApiUrl}/users/${id}`).then(({ data: user }) => Promise.all([
+	dispatch(actions$5.receivedUser(user)),
+	dispatch(setHideAnnouncement({
+		shouldHide: false,
+		userId: user.id
+	})),
+	dispatch(updateUserColumnSettings({ currentUserId: user.id })),
+	user
+])).catch((e) => rejectWithValue(e)));
+const initializeSelf = createAppAsyncThunk(`${sliceName$5}/initializeSelf`, (_, { dispatch }) => dispatch(getUser("me")));
+const updateUserColumnSettings = createAppAsyncThunk(`${sliceName$5}/updateUserColumnSettings`, ({ columns, currentUserId }, { dispatch, getState }) => {
+	const storageKey = `${currentUserId ?? getCurrentUser(getState()).id}-column-widths`;
+	let customColumns = [];
+	if (!columns) try {
+		customColumns = JSON.parse(window.localStorage.getItem(storageKey) || "") || customColumns;
+	} catch {}
+	else customColumns = columns;
+	window.localStorage.setItem(storageKey, JSON.stringify(customColumns));
+	return Promise.resolve(dispatch(actions$5.setCustomColumns(customColumns)));
+});
+const 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"
+	}
+};
+const userActionErrorHandler = (err, type, dispatch) => commonErrorHandler(err, `There was an error ${userActions[type].errorMessage} the user.`, dispatch);
+const createUser = createAppAsyncThunk(`${sliceName$5}/createUser`, ({ shouldResetPassword, ...userData }, { dispatch }) => Api.post(`${useradmApiUrl}/users`, {
+	...userData,
+	send_reset_password: shouldResetPassword
+}).then(() => Promise.all([dispatch(getUserList()), dispatch(setSnackbar(userActions.create.successMessage))])).catch((err) => userActionErrorHandler(err, "create", dispatch)));
+const removeUser = createAppAsyncThunk(`${sliceName$5}/removeUser`, (userId, { dispatch }) => Api.delete(`${useradmApiUrl}/users/${userId}`).then(() => Promise.all([
+	dispatch(actions$5.removedUser(userId)),
+	dispatch(getUserList()),
+	dispatch(setSnackbar(userActions.remove.successMessage))
+])).catch((err) => userActionErrorHandler(err, "remove", dispatch)));
+const editUser = createAppAsyncThunk(`${sliceName$5}/editUser`, ({ id, email, password, current_password, roles }, { dispatch, getState }) => {
+	const userData = stripUndefined({
+		email,
+		password,
+		current_password,
+		roles
+	});
+	return Api.put(`${useradmApiUrl}/users/${id}`, userData).then(() => Promise.all([dispatch(actions$5.updatedUser({
+		...userData,
+		id: id === "me" ? getCurrentUser(getState()).id : id
+	})), dispatch(setSnackbar(userActions.edit.successMessage))])).catch((err) => userActionErrorHandler(err, "edit", dispatch));
+});
+const checkEmailExists = createAppAsyncThunk(`${sliceName$5}/checkEmailExists`, async (email) => {
+	return (await Api.get(`${useradmApiUrl}/users/exists?email=${encodeURIComponent(email)}`)).data.exists;
+});
+const addUserToCurrentTenant = createAppAsyncThunk(`${sliceName$5}/addUserToTenant`, (userId, { dispatch, getState }) => {
+	const { id } = getOrganization(getState());
+	return Api.post(`${useradmApiUrl}/users/${userId}/assign`, { tenant_ids: [id] }).catch((err) => commonErrorHandler(err, `There was an error adding the user to your organization:`, dispatch)).then(() => Promise.all([dispatch(setSnackbar(userActions.add.successMessage)), dispatch(getUserList())]));
+});
+const enableUser2fa = createAppAsyncThunk(`${sliceName$5}/enableUser2fa`, (userId = "me", { dispatch }) => Api.post(`${useradmApiUrl}/users/${userId}/2fa/enable`).catch((err) => commonErrorHandler(err, `There was an error enabling Two Factor authentication for the user.`, dispatch)).then(() => Promise.resolve(dispatch(getUser(userId)))));
+const disableUser2fa = createAppAsyncThunk(`${sliceName$5}/disableUser2fa`, (userId = "me", { dispatch }) => Api.post(`${useradmApiUrl}/users/${userId}/2fa/disable`).catch((err) => commonErrorHandler(err, `There was an error disabling Two Factor authentication for the user.`, dispatch)).then(() => Promise.all([dispatch(getUser(userId)), dispatch(actions$5.receivedQrCode(null))])));
+const 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 collector = (endpointMatches.reduce((endpointAccu, endpoint) => [...endpointAccu, ...endpoint.uiPermissions], []) || 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;
+}, { ...emptyUiPermissions });
+const 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] } } : {}
+};
+const combinePermissions = (existingPermissions, additionalPermissions = {}) => Object.entries(additionalPermissions).reduce((accu, [name, permissions]) => {
+	const maybeExistingPermissions = accu[name] || [];
+	accu[name] = [...permissions, ...maybeExistingPermissions].filter(duplicateFilter);
+	return accu;
+}, existingPermissions);
+const tryParseCustomPermission = (permission) => {
+	const uiPermissions = permissionActionTypes[permission.action](permission.object);
+	return {
+		isCustom: true,
+		permission,
+		result: mergePermissions({ ...emptyUiPermissions }, uiPermissions)
+	};
+};
+const customPermissionHandler = (accu, permission) => {
+	const processor = tryParseCustomPermission(permission);
+	return {
+		...accu,
+		isCustom: accu.isCustom || processor.isCustom,
+		uiPermissions: mergePermissions(accu.uiPermissions, processor.result)
+	};
+};
+const mapPermissionSet = (permissionSetName, names, scope, existingGroupsPermissions = {}) => {
+	const permission = Object.values(uiPermissionsById).find((permission) => permission.permissionSets[scope] === permissionSetName)?.value;
+	const scopedPermissions = names.reduce((accu, name) => combinePermissions(accu, { [name]: [permission] }), existingGroupsPermissions);
+	return Object.entries(scopedPermissions).reduce((accu, [key, permissions]) => ({
+		...accu,
+		[key]: deriveImpliedAreaPermissions(scope, permissions)
+	}), {});
+};
+const isEmptyPermissionSet = (permissionSet) => !Object.values(permissionSet).reduce((accu, permissions) => {
+	if (Array.isArray(permissions)) return accu || !!permissions.length;
+	return accu || !isEmpty(permissions);
+}, false);
+const parseRolePermissions = ({ permission_sets_with_scope = [], permissions = [] }, permissionSets) => {
+	const preliminaryResult = permission_sets_with_scope.reduce((accu, permissionSet) => {
+		if (!permissionSet.name) return accu;
+		const processor = permissionSets[permissionSet.name];
+		if (!processor) return accu;
+		const scope = Object.keys(scopedPermissionAreas).find((scope) => uiPermissionsByArea[scope].scope === permissionSet.scope?.type);
+		if (scope) {
+			const result = mapPermissionSet(permissionSet.name, permissionSet.scope?.value ?? [], scope, accu.uiPermissions[scope]);
+			return {
+				...accu,
+				uiPermissions: {
+					...accu.uiPermissions,
+					[scope]: result
+				}
+			};
+		} else if (isEmptyPermissionSet(processor.result)) return processor.permissions?.reduce(customPermissionHandler, accu);
+		return {
+			...accu,
+			isCustom: accu.isCustom || processor.isCustom,
+			uiPermissions: mergePermissions(accu.uiPermissions, processor.result)
+		};
+	}, {
+		isCustom: false,
+		uiPermissions: {
+			...emptyUiPermissions,
+			groups: {},
+			releases: {}
+		}
+	});
+	return permissions.reduce(customPermissionHandler, preliminaryResult);
+};
+const normalizeRbacRoles = (roles, rolesById$1, permissionSets) => roles.reduce((accu, role) => {
+	let normalizedPermissions;
+	let isCustom = false;
+	if (rolesById$1[role.name]) normalizedPermissions = {
+		...rolesById$1[role.name].uiPermissions,
+		groups: { ...rolesById$1[role.name].uiPermissions.groups },
+		releases: { ...rolesById$1[role.name].uiPermissions.releases }
+	};
+	else {
+		const result = parseRolePermissions(role, permissionSets);
+		normalizedPermissions = result.uiPermissions;
+		isCustom = result.isCustom;
+	}
+	const roleState = accu[role.name] ?? { ...emptyRole };
+	accu[role.name] = {
+		...roleState,
+		...role,
+		description: roleState.description ? roleState.description : role.description,
+		editable: !rolesById[role.name] && !isCustom && (typeof roleState.editable !== "undefined" ? roleState.editable : true),
+		isCustom,
+		name: roleState.name ? roleState.name : role.name,
+		uiPermissions: normalizedPermissions
+	};
+	return accu;
+}, { ...rolesById$1 });
+const getPermissionSets = createAppAsyncThunk(`${sliceName$5}/getPermissionSets`, (_, { dispatch, getState }) => Api.get(`${useradmApiUrlv2}/permission_sets?per_page=500`).then(({ data }) => {
+	const permissionSets = data.reduce((accu, permissionSet) => {
+		let permissionSetObject = {
+			...accu[permissionSet.name] ?? {},
+			...permissionSet
+		};
+		permissionSetObject.result = Object.values(uiPermissionsById).reduce((accu, item) => Object.entries(item.permissionSets).reduce((collector, [area, permissionSet]) => {
+			if (scopedPermissionAreas[area]) return collector;
+			if (permissionSet === permissionSetObject.name) collector[area] = [...collector[area], item.value].filter(duplicateFilter);
+			return collector;
+		}, accu), {
+			...emptyUiPermissions,
+			...permissionSetObject.result ?? {}
+		});
+		permissionSetObject = Object.values(scopedPermissionAreas).reduce((accu, { key, scopeType }) => {
+			if (permissionSetObject.supported_scope_types?.includes(key) || permissionSetObject.supported_scope_types?.includes(scopeType)) accu.push(key);
+			return accu;
+		}, []).reduce((accu, scope) => {
+			accu.result = {
+				...accu.result,
+				[scope]: mapPermissionSet(permissionSetObject.name, [scopedPermissionAreas[scope].excessiveAccessSelector], scope)
+			};
+			return accu;
+		}, permissionSetObject);
+		accu[permissionSet.name] = permissionSetObject;
+		return accu;
+	}, { ...getState().users.permissionSetsById });
+	return Promise.all([Promise.resolve(dispatch(actions$5.receivedPermissionSets(permissionSets))), Promise.resolve(permissionSets)]);
+}).catch(() => console.log("Permission set retrieval failed - likely accessing a non-RBAC backend")));
+const getRoles = createAppAsyncThunk(`${sliceName$5}/getRoles`, async (_, { dispatch, getState }) => {
+	try {
+		const [{ data: roles }, permissionSetResult] = await Promise.all([Api.get(`${useradmApiUrlv2}/roles?per_page=500`), dispatch(getPermissionSets())]);
+		const permissionSetTasks = permissionSetResult.payload;
+		const rolesById = normalizeRbacRoles(roles, getRolesById(getState()), permissionSetTasks[permissionSetTasks.length - 1]);
+		return dispatch(actions$5.receivedRoles(rolesById));
+	} catch {
+		console.log("Role retrieval failed - likely accessing a non-RBAC backend");
+	} finally {
+		dispatch(actions$5.finishedRoleInitialization(true));
+	}
+});
+const 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;
+	}, []);
+};
+/**
+* transforms [{ group: "groupName",  uiPermissions: ["read", "manage", "connect"] }, ...] to
+* [{ name: "ReadDevices", scope: { type: "DeviceGroups", value: ["groupName", ...] } }, ...]
+*/
+const transformAreaRoleDataToScopedPermissionsSets = (area, areaPermissions, excessiveAccessSelector) => {
+	const permissionSetObject = areaPermissions.reduce((accu, { item, uiPermissions }) => {
+		accu = deriveImpliedAreaPermissions(area, uiPermissions, scopedPermissionAreas.releases.key === area && item !== ALL_RELEASES ? [uiPermissionsById.upload.value] : []).reduce((itemPermissionAccu, impliedPermission) => {
+			const permissionSetState = itemPermissionAccu[uiPermissionsById[impliedPermission].permissionSets[area]] ?? {
+				type: uiPermissionsByArea[area].scope,
+				value: []
+			};
+			itemPermissionAccu[uiPermissionsById[impliedPermission].permissionSets[area]] = {
+				...permissionSetState,
+				value: [...permissionSetState.value, item]
+			};
+			return itemPermissionAccu;
+		}, accu);
+		return accu;
+	}, {});
+	return Object.entries(permissionSetObject).map(([name, { value, ...scope }]) => {
+		if (value.includes(excessiveAccessSelector)) return { name };
+		return {
+			name,
+			scope: {
+				...scope,
+				value: value.filter(duplicateFilter)
+			}
+		};
+	});
+};
+const transformRoleDataToRole = (roleData, roleState = {}) => {
+	const role = {
+		...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: {
+			...emptyRole,
+			name,
+			description: description ? description : roleState.description || "",
+			uiPermissions: {
+				...emptyUiPermissions,
+				...roleUiPermissions,
+				...maybeUiPermissions
+			}
+		}
+	};
+};
+const 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"
+	}
+};
+const roleActionErrorHandler = (err, type, dispatch, meta) => {
+	let errorContext = `There was an error ${roleActions[type].errorMessage} the role.`;
+	if (meta) {
+		const { permissionSetsCreated, name } = meta;
+		errorContext += ` Tried to ${type} role ${name} with ${permissionSetsCreated} permission sets.`;
+	}
+	return commonErrorHandler(err, errorContext, dispatch);
+};
+const createRole = createAppAsyncThunk(`${sliceName$5}/createRole`, (roleData, { dispatch }) => {
+	const { permissionSetsWithScope, role } = transformRoleDataToRole(roleData);
+	return Api.post(`${useradmApiUrlv2}/roles`, {
+		name: role.name,
+		description: role.description,
+		permission_sets_with_scope: permissionSetsWithScope
+	}).then(() => Promise.all([
+		dispatch(actions$5.createdRole(role)),
+		dispatch(getRoles()),
+		dispatch(setSnackbar(roleActions.create.successMessage))
+	])).catch((err) => roleActionErrorHandler(err, "create", dispatch, {
+		permissionSetsCreated: permissionSetsWithScope.length,
+		name: role.name
+	}));
+});
+const editRole = createAppAsyncThunk(`${sliceName$5}/editRole`, (roleData, { dispatch, getState }) => {
+	const { permissionSetsWithScope, role } = transformRoleDataToRole(roleData, getRolesById(getState())[roleData.name]);
+	return Api.put(`${useradmApiUrlv2}/roles/${role.name}`, {
+		description: role.description,
+		name: role.name,
+		permission_sets_with_scope: permissionSetsWithScope
+	}).then(() => Promise.all([
+		dispatch(actions$5.createdRole(role)),
+		dispatch(getRoles()),
+		dispatch(setSnackbar(roleActions.edit.successMessage))
+	])).catch((err) => roleActionErrorHandler(err, "edit", dispatch, {
+		permissionSetsCreated: permissionSetsWithScope.length,
+		name: role.name
+	}));
+});
+const removeRole = createAppAsyncThunk(`${sliceName$5}/removeRole`, (roleId, { dispatch }) => Api.delete(`${useradmApiUrlv2}/roles/${roleId}`).then(() => Promise.all([
+	dispatch(actions$5.removedRole(roleId)),
+	dispatch(getRoles()),
+	dispatch(setSnackbar(roleActions.remove.successMessage))
+])).catch((err) => roleActionErrorHandler(err, "remove", dispatch)));
+const getGlobalSettings = createAppAsyncThunk(`${sliceName$5}/getGlobalSettings`, async (_, { dispatch }) => {
+	const { data: settings, headers: { etag } } = await Api.get(`${useradmApiUrl}/settings`);
+	window.sessionStorage.setItem(settingsKeys.initialized, "true");
+	await Promise.all([dispatch(actions$5.setGlobalSettings(settings)), dispatch(setOfflineThreshold())]);
+	return { etag };
+});
+const saveGlobalSettings = createAppAsyncThunk(`${sliceName$5}/saveGlobalSettings`, ({ beOptimistic = false, notify = false, ...settings }, { dispatch, getState }) => {
+	if (!window.sessionStorage.getItem(settingsKeys.initialized) && !beOptimistic) return;
+	return dispatch(getGlobalSettings()).unwrap().then((result) => {
+		const updatedSettings = {
+			...getState().users.globalSettings,
+			...settings
+		};
+		if (getCurrentUser(getState()).verified) updatedSettings["2fa"] = twoFAStates.enabled;
+		else delete updatedSettings["2fa"];
+		const tasks = [Promise.resolve(dispatch(actions$5.setGlobalSettings(updatedSettings)))];
+		const headers = result.etag ? { "If-Match": result.etag } : {};
+		return Api.post(`${useradmApiUrl}/settings`, updatedSettings, { headers }).then(() => {
+			if (notify) tasks.push(Promise.resolve(dispatch(setSnackbar("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);
+		});
+	});
+});
+const getUserSettings = createAppAsyncThunk(`${sliceName$5}/getUserSettings`, async (_, { dispatch }) => {
+	const { data: settings, headers: { etag } } = await Api.get(`${useradmApiUrl}/settings/me`);
+	window.sessionStorage.setItem(settingsKeys.initialized, "true");
+	dispatch(actions$5.setUserSettings(settings));
+	return { etag };
+});
+const saveUserSettings = createAppAsyncThunk(`${sliceName$5}/saveUserSettings`, (settings = { onboarding: {} }, { dispatch, getState }) => {
+	if (!getCurrentUser(getState()).id) return Promise.resolve();
+	return dispatch(getUserSettings()).unwrap().then((result) => {
+		const userSettings = getUserSettings$1(getState());
+		const onboardingState = getOnboardingState$1(getState());
+		const tooltipState = getTooltipsState(getState());
+		const updatedSettings = {
+			...userSettings,
+			...settings,
+			firstLoginTimestamp: userSettings.firstLoginTimestamp ?? dayjs().format(),
+			onboarding: {
+				...onboardingState,
+				...settings.onboarding
+			},
+			tooltips: tooltipState
+		};
+		const headers = result.etag ? { "If-Match": result.etag } : {};
+		return Promise.all([Promise.resolve(dispatch(actions$5.setUserSettings(updatedSettings))), Api.post(`${useradmApiUrl}/settings/me`, updatedSettings, { headers })]).catch(() => dispatch(actions$5.setUserSettings(userSettings)));
+	});
+});
+const get2FAQRCode = createAppAsyncThunk(`${sliceName$5}/get2FAQRCode`, (_, { dispatch }) => Api.get(`${useradmApiUrl}/2faqr`).then((res) => dispatch(actions$5.receivedQrCode(res.data.qr))));
+const setHideAnnouncement = createAppAsyncThunk(`${sliceName$5}/setHideAnnouncement`, ({ shouldHide, userId }, { dispatch, getState }) => {
+	const currentUserId = userId || getCurrentUser(getState()).id;
+	const announcement = getHostedAnnouncement(getState());
+	const hash = announcement ? hashString(announcement) : "";
+	const announceCookie = cookies.get(`${currentUserId}${hash}`);
+	if (shouldHide || hash.length && typeof announceCookie !== "undefined") {
+		cookies.set(`${currentUserId}${hash}`, true, { maxAge: 604800 });
+		dispatch(setAnnouncement(""));
+	}
+});
+const getTokens = createAppAsyncThunk(`${sliceName$5}/getTokens`, (_, { dispatch, getState }) => Api.get(`${useradmApiUrl}/settings/tokens`).then(({ data: tokens }) => {
+	const updatedUser = {
+		...getCurrentUser(getState()),
+		tokens
+	};
+	return Promise.resolve(dispatch(actions$5.updatedUser(updatedUser)));
+}));
+const ONE_YEAR = 31536e3;
+const generateToken = createAppAsyncThunk(`${sliceName$5}/generateToken`, async ({ expiresIn = ONE_YEAR, name }, { dispatch }) => {
+	const { data: token } = await Api.post(`${useradmApiUrl}/settings/tokens`, {
+		name,
+		expires_in: expiresIn
+	}).catch((err) => commonErrorHandler(err, "There was an error creating the token:", dispatch));
+	await dispatch(getTokens());
+	return token;
+});
+const revokeToken = createAppAsyncThunk(`${sliceName$5}/revokeToken`, (token, { dispatch }) => Api.delete(`${useradmApiUrl}/settings/tokens/${token.id}`).then(() => Promise.resolve(dispatch(getTokens()))));
+const setTooltipReadState = createAppAsyncThunk(`${sliceName$5}/setTooltipReadState`, async ({ persist, ...remainder }, { dispatch }) => {
+	dispatch(actions$5.setTooltipState(remainder));
+	if (persist) await dispatch(saveUserSettings());
+});
+const setAllTooltipsReadState = createAppAsyncThunk(`${sliceName$5}/toggleHelptips`, ({ readState = READ_STATES.read, tooltipIds }, { dispatch }) => {
+	const updatedTips = tooltipIds.reduce((accu, id) => ({
+		...accu,
+		[id]: { readState }
+	}), {});
+	return Promise.resolve(dispatch(actions$5.setTooltipsState(updatedTips))).then(() => dispatch(saveUserSettings()));
+});
+const submitUserFeedback = createAppAsyncThunk(`${sliceName$5}/submitFeedback`, ({ formId, feedback }, { dispatch }) => Api.post(`${useradmApiUrlv2}/support/feedback/${formId}`, feedback).then(() => {
+	if (formId === "product") {
+		dispatch(saveUserSettings({ feedbackCollectedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] }));
+		setTimeout(() => dispatch(actions$5.setShowFeedbackDialog(false)), TIMEOUTS.threeSeconds);
+	}
+}));
+//#endregion
+export { abortDeployment, addDevicesToGroup, addDynamicGroup, addStaticGroup, addTenant, addUserToCurrentTenant, advanceOnboarding, applyDeviceConfig, cancelFileUpload, cancelRequest, cancelUpgrade, changeIntegration, changeNotificationSetting, changeSsoConfig, checkEmailExists, completeUpgrade, confirmCardUpdate, createArtifact, createBillingProfile, createDeployment, createIntegration, createOrganizationTrial, createRole, createUser, decommissionDevice, deleteAuthset, deleteIntegration, deleteSsoConfig, deriveDeploymentGroup, deviceFileUpload, disableUser2fa, downloadLicenseReport, editArtifact, editBillingProfile, editRole, editTenant, editUser, enableUser2fa, generateDeploymentLogAnalysis, generateToken, get2FAQRCode, getAllDeviceCounts, getAllDevicesByStatus, getAllDynamicGroupDevices, getAllGroupDevices, getArtifactInstallCount, getArtifactUrl, getAuditLogs, getAuditLogsCsvLink, getBillingPreview, getCurrentCard, getCurrentSubscription, getDeltaGenerationJobDetails, getDeltaGenerationJobs, getDeploymentDevices, getDeploymentsByStatus, getDeploymentsConfig, getDeviceAlerts, getDeviceAttributes, getDeviceAuth, getDeviceById, getDeviceConfig, getDeviceConnect, getDeviceDeployments, getDeviceFileDownloadLink, getDeviceInfo, getDeviceLimits, getDeviceLog, getDeviceMonitorConfig, getDeviceTwin, getDevicesByStatus, getDevicesWithAuth, getDynamicGroup, getDynamicGroups, getExistingReleaseTags, getGatewayDevices, getGlobalSettings, getGroupDevices, getGroups, getIntegrations, getIssueCountsByType, getLatestDeviceAlerts, getLatestReleaseInfo, getOnboardingState, getPermissionSets, getProducts, getRelease, getReleases, getReportDataWithoutBackendSupport, getRoles, getSessionDetails, getSingleDeployment, getSsoConfigById, getSsoConfigs, getSystemDevices, getTargetLocation, getTenants, getTokens, getUpdateTypes, getUser, getUserBilling, getUserList, getUserOrganization, getUserSettings, getUserSubscription, getWebhookEvents, initializeSelf, loginUser, logoutUser, normalizeRbacRoles, passwordResetComplete, passwordResetStart, preauthDevice, removeArtifact, removeDevicesFromGroup, removeDynamicGroup, removeRelease, removeReleases, removeReportsByGroupName, removeRole, removeStaticGroup, removeTenant, removeUser, requestPlanChange, requestPlanUpgrade, resetDeviceDeployments, revokeToken, saveDeltaDeploymentsConfig, saveGlobalSettings, saveUserSettings, searchDevices, selectGroup, selectRelease, sendSupportMessage, setAllTooltipsReadState, setAuditlogsState, setDeploymentsState, setDeviceConfig, setDeviceListState, setDeviceTags, setDeviceTwin, setFirstLoginAfterSignup, setHideAnnouncement, setOfflineThreshold, setOnboardingApproach, setOnboardingCanceled, setOnboardingComplete, setOnboardingDeviceType, setReleaseTags, setReleasesListState, setReleasesTags, setSearchState, setSingleReleaseTags, setTenantsListState, setTooltipReadState, startCardUpdate, startUpgrade, storeSsoConfig, submitUserFeedback, switchUserOrganization, tenantDataDivergedMessage, transformProductResponse, triggerDeviceUpdate, updateDeploymentControlMap, updateDeviceAuth, updateDevicesAuth, updateDynamicGroup, updateReleaseInfo, updateReportData, updateUserColumnSettings, uploadArtifact, verify2FA, verifyEmailComplete, verifyEmailStart };
+
 //# sourceMappingURL=thunks.js.map