@northern.tech/store 0.2.1 → 0.3.1

package/dist/commonSelectors.js

@@ -1,1502 +1,55 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+import {
+  getAttrsEndpoint,
+  getAuditlogDevice,
+  getAvailableIssueOptionsByType,
+  getDemoDeviceAddress,
+  getDeploymentRelease,
+  getDeviceConfigDeployment,
+  getDeviceReportsForUser,
+  getFilterAttributes,
+  getGroupNames,
+  getIsEnterprise,
+  getMappedDevicesList,
+  getOnboardingState,
+  getRelevantRoles,
+  getSearchEndpoint,
+  getSelectedDeploymentData,
+  getTenantCapabilities,
+  getUserCapabilities,
+  getUserRoles
+} from "./chunk-ANB5BM5J.js";
+import "./chunk-KAQJH2YL.js";
+import "./chunk-VOCOFE4I.js";
+import "./chunk-RX55KAKX.js";
+import "./chunk-JIS4PA3R.js";
+import "./chunk-Q6M5TTDQ.js";
+import "./chunk-XXHONFSQ.js";
+import "./chunk-YO22XLHI.js";
+import "./chunk-YETZPQFR.js";
+import "./chunk-LIJIIRON.js";
+import "./chunk-A6CT6GTI.js";
+import "./chunk-CK6YE6AN.js";
+import "./chunk-MRCFLG45.js";
+import "./chunk-25AKG5HH.js";
+import "./chunk-4B3IMP4I.js";
+export {
+  getAttrsEndpoint,
+  getAuditlogDevice,
+  getAvailableIssueOptionsByType,
+  getDemoDeviceAddress,
+  getDeploymentRelease,
+  getDeviceConfigDeployment,
+  getDeviceReportsForUser,
+  getFilterAttributes,
+  getGroupNames,
+  getIsEnterprise,
+  getMappedDevicesList,
+  getOnboardingState,
+  getRelevantRoles,
+  getSearchEndpoint,
+  getSelectedDeploymentData,
+  getTenantCapabilities,
+  getUserCapabilities,
+  getUserRoles
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/commonSelectors.ts
-var commonSelectors_exports = {};
-__export(commonSelectors_exports, {
-  getAttrsEndpoint: () => getAttrsEndpoint,
-  getAuditlogDevice: () => getAuditlogDevice,
-  getAvailableIssueOptionsByType: () => getAvailableIssueOptionsByType,
-  getDemoDeviceAddress: () => getDemoDeviceAddress,
-  getDeploymentRelease: () => getDeploymentRelease,
-  getDeviceConfigDeployment: () => getDeviceConfigDeployment,
-  getDeviceReportsForUser: () => getDeviceReportsForUser,
-  getFilterAttributes: () => getFilterAttributes,
-  getGroupNames: () => getGroupNames,
-  getIsEnterprise: () => getIsEnterprise,
-  getMappedDevicesList: () => getMappedDevicesList,
-  getOnboardingState: () => getOnboardingState,
-  getRelevantRoles: () => getRelevantRoles,
-  getSearchEndpoint: () => getSearchEndpoint,
-  getSelectedDeploymentData: () => getSelectedDeploymentData,
-  getTenantCapabilities: () => getTenantCapabilities,
-  getUserCapabilities: () => getUserCapabilities,
-  getUserRoles: () => getUserRoles
-});
-module.exports = __toCommonJS(commonSelectors_exports);
-var import_helpers4 = require("@northern.tech/utils/helpers");
-var import_toolkit7 = require("@reduxjs/toolkit");
-
-// src/appSlice/constants.ts
-var import_icons_material = require("@mui/icons-material");
-var startingDeviceCount = {
-  os: "for first 50 devices",
-  professional: "for first 250 devices"
-};
-var apiRoot = "/api/management";
-var apiUrl = {
-  v1: `${apiRoot}/v1`,
-  v2: `${apiRoot}/v2`
-};
-var chartTypes = {
-  bar: { key: "bar", Icon: import_icons_material.BarChart },
-  pie: { key: "pie", Icon: import_icons_material.PieChartOutline }
-};
-var emptyChartSelection = { software: "", group: "", chartType: chartTypes.bar.key, attribute: "artifact_name" };
-var defaultReportType = "distribution";
-var defaultReports = [{ ...emptyChartSelection, group: null, attribute: "artifact_name", type: defaultReportType }];
-var PLANS = {
-  os: {
-    id: "os",
-    name: "Basic",
-    offer: true,
-    price: "$32/month",
-    deviceCount: startingDeviceCount.os,
-    offerprice: "$23/month for first 50 devices",
-    price2: "for first 6 months;\n$29/month thereafter",
-    features: ["Basic OTA features"]
-  },
-  professional: {
-    id: "professional",
-    name: "Professional",
-    offer: true,
-    price: "$269/month",
-    deviceCount: startingDeviceCount.professional,
-    offerprice: "$200/month for first 50 devices",
-    price2: "for first 6 months;\n$249/month thereafter",
-    features: ["+ Advanced OTA features", "+ Standard support"]
-  },
-  enterprise: {
-    id: "enterprise",
-    name: "Enterprise",
-    price: "Custom pricing",
-    deviceCount: "unlimited devices",
-    features: ["+ Enterprise-grade OTA features", "+ Premium support"]
-  }
-};
-var ADDONS = {
-  configure: {
-    id: "configure",
-    title: "Configure",
-    description: "Expand your plan with device configuration features",
-    needs: ["hasDeviceConfig"],
-    os: {
-      price: "$11/month",
-      deviceCount: startingDeviceCount.os
-    },
-    professional: {
-      price: "$65/month",
-      deviceCount: startingDeviceCount.professional
-    },
-    eligible: ["os", "professional", "enterprise"]
-  },
-  troubleshoot: {
-    id: "troubleshoot",
-    title: "Troubleshoot",
-    description: "Expand your plan with device troubleshooting features",
-    needs: ["hasDeviceConnect"],
-    os: {
-      price: "$27/month",
-      deviceCount: startingDeviceCount.os
-    },
-    professional: {
-      price: "$72/month",
-      deviceCount: startingDeviceCount.professional
-    },
-    eligible: ["os", "professional", "enterprise"]
-  },
-  monitor: {
-    id: "monitor",
-    title: "Monitor",
-    description: "Expand your plan with device monitoring features",
-    needs: ["hasMonitor"],
-    os: {
-      price: "-",
-      deviceCount: "-"
-    },
-    professional: {
-      price: "$86/month",
-      deviceCount: startingDeviceCount.professional
-    },
-    eligible: ["professional", "enterprise"]
-  }
-};
-var BENEFITS = {
-  auditlog: { id: "auditlog", benefit: "trace change across your devices and access troubleshooting session replay", requiredPlan: PLANS.professional.id },
-  dashboard: { id: "dashboard", benefit: "actionable insights into the devices you are updating with Mender", requiredPlan: PLANS.enterprise.id },
-  deltaGeneration: {
-    id: "deltaGeneration",
-    benefit: "automatic delta artifacts generation to minimize data transfer and improve the update delivery",
-    requiredPlan: PLANS.enterprise.id
-  },
-  deviceConfiguration: { id: "deviceConfiguration", benefit: "device configuration features", requiredAddon: ADDONS.configure.id },
-  deviceMonitor: { id: "deviceMonitor", benefit: "device monitoring features", requiredAddon: ADDONS.monitor.id, requiredPlan: PLANS.professional.id },
-  deviceTroubleshoot: { id: "deviceTroubleshoot", benefit: "device troubleshooting features", requiredAddon: ADDONS.troubleshoot.id },
-  dynamicGroups: { id: "dynamicGroups", benefit: "create dynamic groups to ease device management", requiredPlan: PLANS.enterprise.id },
-  fullFiltering: { id: "fullFiltering", benefit: "filtering by multiple attributes to improve the device overview", requiredPlan: PLANS.professional.id },
-  gateway: { id: "gateway", benefit: "see devices connected to your gateway device for easy access", requiredPlans: PLANS.professional.id },
-  pausedDeployments: {
-    id: "pausedDeployments",
-    benefit: "granular control about update rollout to allow synchronization across your fleet",
-    requiredPlan: PLANS.enterprise.id
-  },
-  phasedDeployments: { id: "phasedDeployments", benefit: "choose to roll out deployments in multiple phases", requiredPlan: PLANS.enterprise.id },
-  rbac: { id: "rbac", benefit: "granular role based access control", requiredPlan: PLANS.enterprise.id },
-  retryDeployments: { id: "retryDeployments", benefit: "optional retries for failed rollout attempts", requiredPlan: PLANS.professional.id },
-  scheduledDeployments: {
-    id: "scheduledDeployments",
-    benefit: "scheduled deployments to steer the distribution of your updates.",
-    requiredPlan: PLANS.professional.id
-  },
-  webhookEvents: {
-    id: "webhookEvents",
-    benefit: "receive inventory events and select which type(s) of events the webhook will receive",
-    requiredPlan: PLANS.professional.id
-  },
-  default: { id: "default", benefit: "gain access to this feature", requiredPlan: PLANS.enterprise.id }
-};
-var DARK_MODE = "dark";
-
-// src/appSlice/selectors.ts
-var import_helpers = require("@northern.tech/utils/helpers");
-var import_toolkit = require("@reduxjs/toolkit");
-var getAppDocsVersion = (state) => state.app.docsVersion;
-var getFeatures = (state) => state.app.features;
-var getFullVersionInformation = (state) => state.app.versionInformation;
-var getDocsVersion = (0, import_toolkit.createSelector)([getAppDocsVersion, getFeatures], (appDocsVersion, { isHosted }) => {
-  const docsVersion = appDocsVersion ? `${appDocsVersion}/` : "development/";
-  return isHosted ? "" : docsVersion;
-});
-var getSearchState = (state) => state.app.searchState;
-var getSearchedDevices = (0, import_toolkit.createSelector)([getSearchState], ({ deviceIds }) => deviceIds);
-var getVersionInformation = (0, import_toolkit.createSelector)(
-  [getFullVersionInformation, getFeatures],
-  ({ Integration, ...remainder }, { isHosted }) => isHosted && Integration !== "next" ? remainder : { ...remainder, Integration }
-);
-var getIsPreview = (0, import_toolkit.createSelector)([getFullVersionInformation], ({ Integration }) => (0, import_helpers.versionCompare)(Integration, "next") > -1);
-
-// src/commonConstants.tsx
-var import_react = __toESM(require("react"));
-var import_js = require("@mdi/js");
-var DEVICE_LIST_DEFAULTS = {
-  page: 1,
-  perPage: 20
-};
-var timeUnits = {
-  days: "days",
-  minutes: "minutes",
-  hours: "hours"
-};
-var ALL_DEVICES = "All devices";
-var UNGROUPED_GROUP = { id: "*|=ungrouped=|*", name: "Unassigned" };
-var DEVICE_LIST_MAXIMUM_LENGTH = 50;
-var DEVICE_FILTERING_OPTIONS = {
-  $eq: { key: "$eq", title: "equals", shortform: "=" },
-  $ne: { key: "$ne", title: "not equal", shortform: "!=" },
-  $gt: {
-    key: "$gt",
-    title: ">",
-    shortform: ">",
-    help: 'The "greater than" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $gte: {
-    title: ">=",
-    shortform: ">=",
-    help: 'The "greater than or equal" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $lt: {
-    key: "$lt",
-    title: "<",
-    shortform: "<",
-    help: 'The "lesser than" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $lte: {
-    title: "<=",
-    shortform: "<=",
-    help: 'The "lesser than or equal" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $ltne: {
-    key: "$ltne",
-    title: "$ltne",
-    shortform: "ltne",
-    help: 'The "lesser than or does not exist" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
-  },
-  $in: {
-    key: "$in",
-    title: "in",
-    shortform: "in",
-    help: 'The "in" operator accepts a list of comma-separated values. It matches if the selected field is equal to one of the specified values.'
-  },
-  $nin: {
-    key: "$nin",
-    title: "not in",
-    shortform: "not in",
-    help: `The "not in" operator accepts a list of comma-separated values. It matches if the selected field's value is not equal to any of the specified options.`
-  },
-  $exists: {
-    key: "$exists",
-    title: "exists",
-    shortform: "exists",
-    value: true,
-    help: `The "exists" operator matches if the selected field's value has a value. No value needs to be provided for this operator.`
-  },
-  $nexists: {
-    key: "$nexists",
-    title: `doesn't exist`,
-    shortform: `doesn't exist`,
-    value: true,
-    help: `The "doesn't exist" operator matches if the selected field's value has no value. No value needs to be provided for this operator.`
-  },
-  $regex: {
-    key: "$regex",
-    title: `matches regular expression`,
-    shortform: `matches`,
-    help: `The "regular expression" operator matches the selected field's value with a Perl compatible regular expression (PCRE), automatically anchored by ^. If the regular expression is not valid, the filter will produce no results. If you need to specify options and flags, you can provide the full regex in the format of /regex/flags, for example.`
-  }
-};
-var DEVICE_ISSUE_OPTIONS = {
-  issues: {
-    isCategory: true,
-    key: "issues",
-    title: "Devices with issues",
-    filterRule: {}
-  },
-  offline: {
-    issueCategory: "issues",
-    key: "offline",
-    needsFullFiltering: true,
-    needsMonitor: false,
-    needsReporting: false,
-    filterRule: {
-      scope: "system",
-      key: "check_in_time",
-      operator: DEVICE_FILTERING_OPTIONS.$ltne.key,
-      value: ({ offlineThreshold }) => offlineThreshold
-    },
-    title: "Offline devices"
-  },
-  failedLastUpdate: {
-    issueCategory: "issues",
-    key: "failedLastUpdate",
-    needsFullFiltering: false,
-    needsMonitor: false,
-    needsReporting: true,
-    filterRule: { scope: "monitor", key: "failed_last_update", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: true },
-    title: "Deployment failed"
-  },
-  monitoring: {
-    issueCategory: "issues",
-    key: "monitoring",
-    needsFullFiltering: false,
-    needsMonitor: true,
-    needsReporting: false,
-    filterRule: { scope: "monitor", key: "alerts", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: true },
-    title: "Monitoring alert"
-  },
-  authRequests: {
-    key: "authRequests",
-    needsFullFiltering: false,
-    needsMonitor: false,
-    needsReporting: true,
-    filterRule: { scope: "monitor", key: "auth_requests", operator: DEVICE_FILTERING_OPTIONS.$gt.key, value: 1 },
-    title: "Devices with new authentication requests"
-  },
-  gatewayDevices: {
-    key: "gatewayDevices",
-    needsFullFiltering: false,
-    needsMonitor: false,
-    needsReporting: true,
-    filterRule: { scope: "inventory", key: "mender_is_gateway", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: "true" },
-    title: "Gateway devices"
-  }
-};
-var oneSecond = 1e3;
-var TIMEOUTS = {
-  debounceDefault: 700,
-  debounceShort: 300,
-  halfASecond: 0.5 * oneSecond,
-  oneSecond,
-  twoSeconds: 2 * oneSecond,
-  threeSeconds: 3 * oneSecond,
-  fiveSeconds: 5 * oneSecond,
-  refreshDefault: 10 * oneSecond,
-  refreshLong: 60 * oneSecond
-};
-var SORTING_OPTIONS = {
-  asc: "asc",
-  desc: "desc"
-};
-var DEVICE_ONLINE_CUTOFF = { interval: 1, intervalName: timeUnits.days };
-var ATTRIBUTE_SCOPES = {
-  inventory: "inventory",
-  identity: "identity",
-  monitor: "monitor",
-  system: "system",
-  tags: "tags"
-};
-var defaultIdAttribute = Object.freeze({ attribute: "id", scope: ATTRIBUTE_SCOPES.identity });
-var credentialTypes = {
-  aws: "aws",
-  http: "http",
-  sas: "sas",
-  x509: "x509"
-};
-var EXTERNAL_PROVIDER = {
-  "iot-core": {
-    credentialsType: credentialTypes.aws,
-    icon: import_js.mdiAws,
-    title: "AWS IoT Core",
-    twinTitle: "Device Shadow",
-    provider: "iot-core",
-    enabled: true,
-    deviceTwin: true,
-    configHint: /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, "For help finding your AWS IoT Core connection string, check the AWS IoT documentation.")
-  },
-  "iot-hub": {
-    credentialsType: credentialTypes.sas,
-    icon: import_js.mdiMicrosoftAzure,
-    title: "Azure IoT Hub",
-    twinTitle: "Device Twin",
-    provider: "iot-hub",
-    enabled: true,
-    deviceTwin: true,
-    configHint: /* @__PURE__ */ import_react.default.createElement("span", null, "For help finding your Azure IoT Hub connection string, look under 'Shared access policies' in the Microsoft Azure UI as described", " ", /* @__PURE__ */ import_react.default.createElement(
-      "a",
-      {
-        href: "https://devblogs.microsoft.com/iotdev/understand-different-connection-strings-in-azure-iot-hub/#iothubconn",
-        target: "_blank",
-        rel: "noopener noreferrer"
-      },
-      "here"
-    ), ".")
-  },
-  webhook: {
-    credentialsType: credentialTypes.http,
-    deviceTwin: false,
-    // disable the webhook provider here, since it is treated different than other integrations, with a custom configuration & management view, etc.
-    enabled: false,
-    provider: "webhook"
-  }
-};
-var ALL_RELEASES = "All releases";
-var emptyUiPermissions = Object.freeze({
-  auditlog: [],
-  deployments: [],
-  groups: Object.freeze({}),
-  releases: Object.freeze({}),
-  tenantManagement: [],
-  userManagement: []
-});
-var emptyRole = Object.freeze({
-  name: void 0,
-  description: "",
-  permissions: [],
-  uiPermissions: Object.freeze({ ...emptyUiPermissions })
-});
-
-// src/deploymentsSlice/selectors.ts
-var import_toolkit2 = require("@reduxjs/toolkit");
-
-// src/devicesSlice/constants.ts
-var emptyFilter = { key: null, value: "", operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "inventory" };
-var deviceAuthV2 = `${apiUrl.v2}/devauth`;
-var deviceConnect = `${apiUrl.v1}/deviceconnect`;
-var inventoryApiUrl = `${apiUrl.v1}/inventory`;
-var inventoryApiUrlV2 = `${apiUrl.v2}/inventory`;
-var deviceConfig = `${apiUrl.v1}/deviceconfig/configurations/device`;
-var reportingApiUrl = `${apiUrl.v1}/reporting`;
-var iotManagerBaseURL = `${apiUrl.v1}/iot-manager`;
-var DEVICE_STATES = {
-  accepted: "accepted",
-  pending: "pending",
-  preauth: "preauthorized",
-  rejected: "rejected"
-};
-var geoAttributes = ["geo-lat", "geo-lon"].map((attribute) => ({ attribute, scope: "inventory" }));
-
-// src/monitorSlice/constants.ts
-var monitorApiUrlv1 = `${apiUrl.v1}/devicemonitor`;
-
-// src/onboardingSlice/constants.ts
-var onboardingSteps = {
-  ONBOARDING_START: "onboarding-start",
-  DEVICES_PENDING_ONBOARDING_START: "devices-pending-onboarding-start",
-  DASHBOARD_ONBOARDING_START: "dashboard-onboarding-start",
-  DASHBOARD_ONBOARDING_PENDINGS: "dashboard-onboarding-pendings",
-  DEVICES_DELAYED_ONBOARDING: "devices-delayed-onboarding",
-  DEVICES_PENDING_ONBOARDING: "devices-pending-onboarding",
-  DEVICES_ACCEPTED_ONBOARDING: "devices-accepted-onboarding",
-  DEVICES_PENDING_ACCEPTING_ONBOARDING: "devices-pending-accepting-onboarding",
-  DEVICES_DEPLOY_RELEASE_ONBOARDING: "devices-deploy-release-onboarding",
-  SCHEDULING_ARTIFACT_SELECTION: "scheduling-artifact-selection",
-  SCHEDULING_ALL_DEVICES_SELECTION: "scheduling-all-devices-selection",
-  SCHEDULING_GROUP_SELECTION: "scheduling-group-selection",
-  SCHEDULING_RELEASE_TO_DEVICES: "scheduling-release-to-devices",
-  DEPLOYMENTS_INPROGRESS: "deployments-inprogress",
-  DEPLOYMENTS_PAST: "deployments-past",
-  DEPLOYMENTS_PAST_COMPLETED: "deployments-past-completed",
-  DEPLOYMENTS_PAST_COMPLETED_FAILURE: "deployments-past-completed-failure",
-  ONBOARDING_CANCELED: "onboarding-canceled"
-};
-var orderedOnboardingSteps = [
-  onboardingSteps.DASHBOARD_ONBOARDING_START,
-  onboardingSteps.DEVICES_PENDING_ONBOARDING_START,
-  onboardingSteps.DEVICES_DELAYED_ONBOARDING,
-  onboardingSteps.DEVICES_PENDING_ONBOARDING,
-  onboardingSteps.DEVICES_PENDING_ACCEPTING_ONBOARDING,
-  onboardingSteps.DASHBOARD_ONBOARDING_PENDINGS,
-  onboardingSteps.DEVICES_ACCEPTED_ONBOARDING,
-  onboardingSteps.DEVICES_DEPLOY_RELEASE_ONBOARDING,
-  onboardingSteps.SCHEDULING_ALL_DEVICES_SELECTION,
-  onboardingSteps.SCHEDULING_GROUP_SELECTION,
-  onboardingSteps.SCHEDULING_ARTIFACT_SELECTION,
-  onboardingSteps.SCHEDULING_RELEASE_TO_DEVICES,
-  onboardingSteps.DEPLOYMENTS_INPROGRESS,
-  onboardingSteps.DEPLOYMENTS_PAST,
-  onboardingSteps.DEPLOYMENTS_PAST_COMPLETED,
-  onboardingSteps.DEPLOYMENTS_PAST_COMPLETED_FAILURE,
-  onboardingSteps.ONBOARDING_CANCELED
-];
-
-// src/organizationSlice/constants.ts
-var auditLogsApiUrl = `${apiUrl.v1}/auditlogs`;
-var tenantadmApiUrlv1 = `${apiUrl.v1}/tenantadm`;
-var tenantadmApiUrlv2 = `${apiUrl.v2}/tenantadm`;
-var ssoIdpApiUrlv1 = `${apiUrl.v1}/useradm/sso/idp/metadata`;
-var AUDIT_LOGS_TYPES = [
-  { title: "Artifact", queryParameter: "object_type", value: "artifact" },
-  { title: "Deployment", queryParameter: "object_deployment_name", value: "deployment" },
-  { title: "Device", queryParameter: "object_id", value: "device" },
-  { title: "User", queryParameter: "object_id", value: "user" }
-];
-var SP_AUDIT_LOGS_TYPES = [AUDIT_LOGS_TYPES[3], { title: "Tenant", queryParameter: "object_id", value: "tenant" }];
-var emptyWebhook = {
-  description: "",
-  enabled: true,
-  credentials: {
-    type: EXTERNAL_PROVIDER.webhook.credentialsType,
-    [EXTERNAL_PROVIDER.webhook.credentialsType]: {
-      secret: "",
-      url: ""
-    }
-  }
-};
-
-// src/releasesSlice/constants.ts
-var rootfsImageVersion = "rootfs-image.version";
-var softwareTitleMap = { [rootfsImageVersion]: { title: "Root filesystem", priority: 0, key: rootfsImageVersion } };
-
-// src/usersSlice/constants.ts
-var useradmApiUrlv1 = `${apiUrl.v1}/useradm`;
-var useradmApiUrlv2 = `${apiUrl.v2}/useradm`;
-var staticRolesByName = {
-  admin: "RBAC_ROLE_PERMIT_ALL",
-  readOnly: "RBAC_ROLE_OBSERVER",
-  ci: "RBAC_ROLE_CI",
-  deploymentsManager: "RBAC_ROLE_DEPLOYMENTS_MANAGER",
-  terminalAccess: "RBAC_ROLE_REMOTE_TERMINAL"
-};
-var PermissionTypes = {
-  Any: "any",
-  Get: "GET",
-  Post: "POST",
-  Put: "PUT",
-  Delete: "DELETE",
-  Patch: "PATCH",
-  DeviceGroup: "DEVICE_GROUP",
-  DeviceId: "DEVICE_ID"
-};
-var permissionSetIds = {
-  Basic: "Basic",
-  ConfigureDevices: "ConfigureDevices",
-  ConnectToDevices: "ConnectToDevices",
-  DeployToDevices: "DeployToDevices",
-  ManageDevices: "ManageDevices",
-  ManageReleases: "ManageReleases",
-  ManageTenants: "ManageTenants",
-  ManageUsers: "ManageUsers",
-  ReadAuditLogs: "ReadAuditLogs",
-  ReadDevices: "ReadDevices",
-  ReadReleases: "ReadReleases",
-  ReadTenants: "ReadTenants",
-  ReadUsers: "ReadUsers",
-  SuperUser: "SuperUser",
-  UploadArtifacts: "UploadArtifacts"
-};
-var uiPermissionsById = {
-  configure: {
-    explanations: { groups: `'Configure' allows the user to use mender-configure features and apply configurations.` },
-    permissionLevel: 2,
-    permissionSets: { groups: permissionSetIds.ConfigureDevices },
-    title: "Configure",
-    value: "configure",
-    verbs: [PermissionTypes.Get, PermissionTypes.Put, PermissionTypes.Post]
-  },
-  connect: {
-    explanations: { groups: `'Connect' allows the user to use mender-connect features and Troubleshoot add-ons.` },
-    permissionLevel: 2,
-    permissionSets: { groups: permissionSetIds.ConnectToDevices },
-    title: "Connect",
-    value: "connect",
-    verbs: [PermissionTypes.Get, PermissionTypes.Put]
-  },
-  deploy: {
-    explanations: { groups: `'Deploy' allows the user to deploy software or configuration updates to devices.` },
-    permissionLevel: 2,
-    permissionSets: { deployments: permissionSetIds.DeployToDevices, groups: permissionSetIds.DeployToDevices },
-    title: "Deploy",
-    value: "deploy",
-    verbs: [PermissionTypes.Post]
-  },
-  manage: {
-    explanations: {
-      groups: `'Manage' allows the user to edit device name, notes, and manage authentication status. For 'All devices' it also allows the user to edit and create device groups.`,
-      releases: `'Manage' allows the user to upload new artifacts, edit release descriptions and remove artifacts.`
-    },
-    permissionLevel: 2,
-    permissionSets: {
-      groups: permissionSetIds.ManageDevices,
-      releases: permissionSetIds.ManageReleases,
-      tenantManagement: permissionSetIds.ManageTenants,
-      userManagement: permissionSetIds.ManageUsers
-    },
-    title: "Manage",
-    value: "manage",
-    verbs: [PermissionTypes.Post, PermissionTypes.Put, PermissionTypes.Patch]
-  },
-  read: {
-    explanations: { groups: `'Read' allows the user to view devices.` },
-    permissionLevel: 1,
-    permissionSets: {
-      auditlog: permissionSetIds.ReadAuditLogs,
-      groups: permissionSetIds.ReadDevices,
-      releases: permissionSetIds.ReadReleases,
-      tenantManagement: permissionSetIds.ReadTenants,
-      userManagement: permissionSetIds.ReadUsers
-    },
-    title: "Read",
-    value: "read",
-    verbs: [PermissionTypes.Get, PermissionTypes.Post]
-  },
-  upload: {
-    explanations: { groups: `'Upload' allows the user to upload new Artifacts.` },
-    unscopedOnly: { releases: true },
-    permissionLevel: 1,
-    permissionSets: { releases: permissionSetIds.UploadArtifacts },
-    title: "Upload",
-    value: "upload",
-    verbs: [PermissionTypes.Post, PermissionTypes.Put, PermissionTypes.Patch]
-  }
-};
-var scopedPermissionAreas = {
-  groups: { key: "groups", excessiveAccessSelector: ALL_DEVICES, scopeType: "DeviceGroups" },
-  releases: { key: "releases", excessiveAccessSelector: ALL_RELEASES, scopeType: "Releases" }
-};
-var uiPermissionsByArea = {
-  auditlog: {
-    endpoints: [{ path: /\/(auditlog)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] }],
-    explanation: "Granting access to the audit log will allow tracing changes to devices, releases and user accounts, as well as providing information about deployments.",
-    key: "auditlog",
-    uiPermissions: [uiPermissionsById.read],
-    title: "System audit log"
-  },
-  deployments: {
-    endpoints: [
-      { path: /\/(deployments\/deployments)/i, types: [PermissionTypes.Post, PermissionTypes.Put], uiPermissions: [uiPermissionsById.deploy] },
-      { path: /\/(deployments\/deployments)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      { path: /\/(deployments\/config)/i, types: [PermissionTypes.Get, PermissionTypes.Put], uiPermissions: [uiPermissionsById.manage] }
-    ],
-    explanation: "Providing deploy permissions will allow deployments to be created using the releases and devices a user has access to.",
-    key: "deployments",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.deploy],
-    title: "Deployments"
-  },
-  groups: {
-    endpoints: [
-      {
-        path: /\/(devauth|inventory|deviceconfig|devicemonitor|deviceconnect\/devices)/i,
-        types: [PermissionTypes.Get],
-        uiPermissions: [uiPermissionsById.read]
-      },
-      { path: /\/(devauth|inventory)/i, types: [PermissionTypes.Put, PermissionTypes.Post], uiPermissions: [uiPermissionsById.manage] },
-      { path: /\/(deviceconfig)/i, types: [PermissionTypes.Get, PermissionTypes.Put, PermissionTypes.Post], uiPermissions: [uiPermissionsById.configure] },
-      { path: /\/(deviceconnect\/devices)/i, types: [PermissionTypes.Get, PermissionTypes.Post], uiPermissions: [uiPermissionsById.connect] }
-    ],
-    explanation: "Device group management permissions control the degree to which devices in a group can be accessed and moved to other groups.",
-    key: "groups",
-    scope: scopedPermissionAreas.groups.scopeType,
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage, uiPermissionsById.deploy, uiPermissionsById.configure, uiPermissionsById.connect],
-    title: "Group Management"
-  },
-  releases: {
-    endpoints: [
-      { path: /\/(deployments\/artifacts|deployments\/deployments\/releases)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      {
-        path: /\/(deployments\/artifacts|deployments\/deployments\/releases)/i,
-        types: [PermissionTypes.Post, PermissionTypes.Put],
-        uiPermissions: [uiPermissionsById.read, uiPermissionsById.upload]
-      },
-      {
-        path: /\/(deployments\/artifacts|deployments\/deployments\/releases)/i,
-        types: [PermissionTypes.Delete],
-        uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage]
-      }
-    ],
-    explanation: "Release permissions can be granted to allow artifact & release modifications, as well as the creation of new releases.",
-    key: "releases",
-    scope: "ReleaseTags",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage, uiPermissionsById.upload],
-    title: "Release Management"
-  },
-  tenantManagement: {
-    endpoints: [
-      { path: /\/(tenantadm\/tenants)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      { path: /\/(tenantadm\/tenants)/i, types: [PermissionTypes.Post, PermissionTypes.Put], uiPermissions: [uiPermissionsById.manage] },
-      { path: /\/(users\/exists)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.manage] }
-    ],
-    explanation: "Tenant management permissions allow listing, creating and modifying child tenants",
-    key: "tenantManagement",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage],
-    title: "Tenant Management"
-  },
-  userManagement: {
-    endpoints: [
-      { path: /\/(useradm)/i, types: [PermissionTypes.Get], uiPermissions: [uiPermissionsById.read] },
-      { path: /\/(useradm)/i, types: [PermissionTypes.Post], uiPermissions: [uiPermissionsById.manage] }
-    ],
-    explanation: "User management permissions should be granted carefully, as these allow privilege increases for any users managed by a user with user management permissions",
-    key: "userManagement",
-    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage],
-    title: "User Management"
-  }
-};
-var permissionMapper = (permission) => permission.value;
-var rolesById = Object.freeze({
-  [staticRolesByName.admin]: {
-    name: "Admin",
-    value: staticRolesByName.admin,
-    description: "Full access",
-    permissions: [],
-    // permissions refers to the values returned from the backend
-    uiPermissions: {
-      ...emptyUiPermissions,
-      auditlog: uiPermissionsByArea.auditlog.uiPermissions.map(permissionMapper),
-      deployments: uiPermissionsByArea.deployments.uiPermissions.map(permissionMapper),
-      groups: { [ALL_DEVICES]: uiPermissionsByArea.groups.uiPermissions.map(permissionMapper) },
-      releases: { [ALL_RELEASES]: uiPermissionsByArea.releases.uiPermissions.map(permissionMapper) },
-      userManagement: uiPermissionsByArea.userManagement.uiPermissions.map(permissionMapper)
-    }
-  },
-  [staticRolesByName.readOnly]: {
-    name: "Read Access",
-    value: staticRolesByName.readOnly,
-    description: "",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      deployments: [uiPermissionsById.read.value],
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value] },
-      releases: { [ALL_RELEASES]: [uiPermissionsById.read.value] },
-      userManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [staticRolesByName.ci]: {
-    name: "Releases Manager",
-    value: staticRolesByName.ci,
-    description: "",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      releases: { [ALL_RELEASES]: uiPermissionsByArea.releases.uiPermissions.map(permissionMapper) }
-    }
-  },
-  [staticRolesByName.deploymentsManager]: {
-    name: "Deployments Manager",
-    value: staticRolesByName.deploymentsManager,
-    description: "",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      deployments: uiPermissionsByArea.deployments.uiPermissions.map(permissionMapper),
-      groups: { [ALL_DEVICES]: [uiPermissionsById.deploy.value, uiPermissionsById.read.value] },
-      releases: { [ALL_RELEASES]: [uiPermissionsById.read.value] }
-    }
-  },
-  [staticRolesByName.terminalAccess]: {
-    name: "Troubleshooting",
-    value: staticRolesByName.terminalAccess,
-    description: "Access to the troubleshooting features: Remote Terminal, File Transfer, Port Forwarding",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      groups: { [ALL_DEVICES]: [uiPermissionsById.connect.value] }
-    }
-  }
-});
-var serviceProviderRolesById = {
-  admin: {
-    name: "Admin",
-    value: staticRolesByName.admin,
-    description: "Full access",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      auditlog: uiPermissionsByArea.auditlog.uiPermissions.map(permissionMapper),
-      userManagement: uiPermissionsByArea.userManagement.uiPermissions.map(permissionMapper),
-      tenantManagement: uiPermissionsByArea.tenantManagement.uiPermissions.map(permissionMapper)
-    }
-  },
-  readOnly: {
-    name: "Read access",
-    value: staticRolesByName.admin,
-    description: "This role can see all linked organizations but cannot make any changes",
-    permissions: [],
-    uiPermissions: {
-      ...emptyUiPermissions,
-      auditlog: [uiPermissionsById.read.value],
-      userManagement: [uiPermissionsById.read.value],
-      tenantManagement: [uiPermissionsById.read.value]
-    }
-  }
-};
-var defaultPermissionSets = {
-  [permissionSetIds.Basic]: {
-    name: permissionSetIds.Basic,
-    result: {
-      // this is needed to prevent the detailed permissions of the basic permission set from being interpreted as allowing read & management access to user endpoints
-      userManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.SuperUser]: {
-    name: permissionSetIds.SuperUser,
-    result: {
-      ...rolesById[staticRolesByName.admin].uiPermissions
-    }
-  },
-  [permissionSetIds.ManageUsers]: {
-    name: permissionSetIds.ManageUsers,
-    result: {
-      userManagement: [uiPermissionsById.manage.value]
-    }
-  },
-  [permissionSetIds.ReadAuditLogs]: {
-    name: permissionSetIds.ReadAuditLogs,
-    result: {
-      auditlog: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.ReadReleases]: {
-    name: permissionSetIds.ReadReleases,
-    result: {
-      releases: { [ALL_RELEASES]: [uiPermissionsById.read.value] }
-    }
-  },
-  [permissionSetIds.ReadTenants]: {
-    name: permissionSetIds.ReadTenants,
-    result: {
-      tenantManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.ManageTenants]: {
-    name: permissionSetIds.ManageTenants,
-    result: {
-      tenantManagement: [uiPermissionsById.manage.value]
-    }
-  },
-  [permissionSetIds.ReadUsers]: {
-    name: permissionSetIds.ReadUsers,
-    result: {
-      userManagement: [uiPermissionsById.read.value]
-    }
-  },
-  [permissionSetIds.UploadArtifacts]: {
-    name: permissionSetIds.UploadArtifacts,
-    result: {
-      releases: { [ALL_RELEASES]: [uiPermissionsById.upload.value] }
-    }
-  },
-  [permissionSetIds.ManageReleases]: {
-    name: permissionSetIds.ManageReleases,
-    result: {
-      releases: { [ALL_RELEASES]: [uiPermissionsById.manage.value] }
-    }
-  },
-  [permissionSetIds.ConfigureDevices]: {
-    name: permissionSetIds.ConfigureDevices,
-    result: {
-      deployments: [uiPermissionsById.read.value, uiPermissionsById.deploy.value],
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.configure.value] }
-    }
-  },
-  [permissionSetIds.ConnectToDevices]: {
-    name: permissionSetIds.ConnectToDevices,
-    result: {
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.connect.value] }
-    }
-  },
-  [permissionSetIds.DeployToDevices]: {
-    name: permissionSetIds.DeployToDevices,
-    result: {
-      deployments: [uiPermissionsById.deploy.value, uiPermissionsById.manage.value, uiPermissionsById.read.value],
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.deploy.value] }
-    }
-  },
-  [permissionSetIds.ManageDevices]: {
-    name: permissionSetIds.ManageDevices,
-    result: {
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value, uiPermissionsById.manage.value] }
-    }
-  },
-  [permissionSetIds.ReadDevices]: {
-    name: permissionSetIds.ReadDevices,
-    result: {
-      groups: { [ALL_DEVICES]: [uiPermissionsById.read.value] }
-    }
-  }
-};
-var rolesByName = {
-  ...staticRolesByName,
-  deploymentCreation: { action: "CREATE_DEPLOYMENT", object: { type: "DEVICE_GROUP", value: void 0 } },
-  groupAccess: { action: "VIEW_DEVICE", object: { type: "DEVICE_GROUP", value: void 0 } },
-  userManagement: { action: "http", object: { type: "any", value: `${useradmApiUrlv1}/.*` } }
-};
-var twoFAStates = {
-  enabled: "enabled",
-  disabled: "disabled",
-  unverified: "unverified"
-};
-var READ_STATES = {
-  read: "read",
-  seen: "seen",
-  unread: "unread"
-};
-
-// src/deploymentsSlice/constants.ts
-var alreadyInstalled = "already-installed";
-var deploymentsApiUrl = `${apiUrl.v1}/deployments`;
-var deploymentsApiUrlV2 = `${apiUrl.v2}/deployments`;
-var deploymentSubstates = {
-  aborted: "aborted",
-  alreadyInstalled,
-  decommissioned: "decommissioned",
-  downloading: "downloading",
-  failure: "failure",
-  installing: "installing",
-  noartifact: "noartifact",
-  pause_before_committing: "pause_before_committing",
-  pause_before_installing: "pause_before_installing",
-  pause_before_rebooting: "pause_before_rebooting",
-  pending: "pending",
-  rebooting: "rebooting",
-  success: "success"
-};
-var deploymentStatesToSubstates = {
-  failures: [deploymentSubstates.failure, deploymentSubstates.aborted, deploymentSubstates.decommissioned],
-  inprogress: [deploymentSubstates.downloading, deploymentSubstates.installing, deploymentSubstates.rebooting],
-  paused: [deploymentSubstates.pause_before_installing, deploymentSubstates.pause_before_rebooting, deploymentSubstates.pause_before_committing],
-  pending: [deploymentSubstates.pending],
-  successes: [deploymentSubstates.success, deploymentSubstates.alreadyInstalled, deploymentSubstates.noartifact]
-};
-var deploymentStatesToSubstatesWithSkipped = {
-  ...deploymentStatesToSubstates,
-  failures: [deploymentSubstates.failure],
-  skipped: [deploymentSubstates.aborted, deploymentSubstates.noartifact, deploymentSubstates.alreadyInstalled, deploymentSubstates.decommissioned],
-  successes: [deploymentSubstates.success]
-};
-var installationSubstatesMap = {
-  download: {
-    title: "download",
-    done: "downloaded",
-    successIndicators: [deploymentSubstates.installing, deploymentSubstates.rebooting, ...deploymentStatesToSubstates.paused, deploymentSubstates.success],
-    failureIndicators: deploymentStatesToSubstates.failures,
-    pauseConfigurationIndicator: "ArtifactInstall_Enter"
-  },
-  install: {
-    title: "install",
-    done: "installed",
-    successIndicators: [
-      deploymentSubstates.rebooting,
-      deploymentSubstates.pause_before_rebooting,
-      deploymentSubstates.pause_before_committing,
-      deploymentSubstates.success
-    ],
-    failureIndicators: deploymentStatesToSubstates.failures,
-    pauseConfigurationIndicator: "ArtifactReboot_Enter"
-  },
-  reboot: {
-    title: "reboot",
-    done: "rebooted",
-    successIndicators: [deploymentSubstates.pause_before_committing, deploymentSubstates.success],
-    failureIndicators: deploymentStatesToSubstates.failures,
-    pauseConfigurationIndicator: "ArtifactCommit_Enter"
-  },
-  commit: {
-    title: "commit",
-    done: "committed",
-    successIndicators: deploymentStatesToSubstates.successes,
-    failureIndicators: deploymentStatesToSubstates.failures,
-    pauseConfigurationIndicator: void 0
-  }
-};
-var DEPLOYMENT_STATES = {
-  finished: "finished",
-  inprogress: "inprogress",
-  pending: "pending",
-  scheduled: "scheduled"
-};
-var listDefaultsByState = {
-  [DEPLOYMENT_STATES.inprogress]: { page: 1, perPage: 10 },
-  [DEPLOYMENT_STATES.pending]: { page: 1, perPage: 10 },
-  [DEPLOYMENT_STATES.scheduled]: { ...DEVICE_LIST_DEFAULTS },
-  [DEPLOYMENT_STATES.finished]: { ...DEVICE_LIST_DEFAULTS },
-  sort: { direction: SORTING_OPTIONS.desc }
-};
-var DEPLOYMENT_ROUTES = {
-  active: {
-    key: "active",
-    route: "/deployments/active",
-    states: [DEPLOYMENT_STATES.pending, DEPLOYMENT_STATES.inprogress],
-    title: "Active"
-  },
-  finished: {
-    key: "finished",
-    route: "/deployments/finished",
-    states: [DEPLOYMENT_STATES.finished],
-    title: "Finished"
-  },
-  scheduled: {
-    key: "scheduled",
-    route: "/deployments/scheduled",
-    states: [DEPLOYMENT_STATES.scheduled],
-    title: "Scheduled"
-  }
-};
-var defaultStats = {
-  [deploymentSubstates.aborted]: 0,
-  [deploymentSubstates.alreadyInstalled]: 0,
-  [deploymentSubstates.decommissioned]: 0,
-  [deploymentSubstates.downloading]: 0,
-  [deploymentSubstates.failure]: 0,
-  [deploymentSubstates.installing]: 0,
-  [deploymentSubstates.noartifact]: 0,
-  [deploymentSubstates.pause_before_committing]: 0,
-  [deploymentSubstates.pause_before_installing]: 0,
-  [deploymentSubstates.pause_before_rebooting]: 0,
-  [deploymentSubstates.pending]: 0,
-  [deploymentSubstates.rebooting]: 0,
-  [deploymentSubstates.success]: 0
-};
-var pauseMap = {
-  [deploymentSubstates.pause_before_installing]: {
-    title: installationSubstatesMap.download.done,
-    followUp: installationSubstatesMap.download.pauseConfigurationIndicator
-  },
-  [deploymentSubstates.pause_before_rebooting]: {
-    title: installationSubstatesMap.install.done,
-    followUp: installationSubstatesMap.install.pauseConfigurationIndicator
-  },
-  [deploymentSubstates.pause_before_committing]: {
-    title: installationSubstatesMap.reboot.done,
-    followUp: installationSubstatesMap.reboot.pauseConfigurationIndicator
-  }
-};
-
-// src/deploymentsSlice/selectors.ts
-var getDeploymentsById = (state) => state.deployments.byId;
-var getDeploymentsByStatus = (state) => state.deployments.byStatus;
-var getSelectedDeploymentDeviceIds = (state) => state.deployments.selectedDeviceIds;
-var getDeploymentsSelectionState = (state) => state.deployments.selectionState;
-var getMappedDeploymentSelection = (0, import_toolkit2.createSelector)(
-  [getDeploymentsSelectionState, (_, deploymentsState) => deploymentsState, getDeploymentsById],
-  (selectionState, deploymentsState, deploymentsById) => {
-    const { selection = [] } = selectionState[deploymentsState] ?? {};
-    return selection.reduce((accu, id) => {
-      if (deploymentsById[id]) {
-        accu.push(deploymentsById[id]);
-      }
-      return accu;
-    }, []);
-  }
-);
-var relevantDeploymentStates = [DEPLOYMENT_STATES.pending, DEPLOYMENT_STATES.inprogress, DEPLOYMENT_STATES.finished];
-var DEPLOYMENT_CUTOFF = 3;
-var getRecentDeployments = (0, import_toolkit2.createSelector)(
-  [getDeploymentsById, getDeploymentsByStatus],
-  (deploymentsById, deploymentsByStatus) => Object.entries(deploymentsByStatus).reduce(
-    (accu, [state, byStatus]) => {
-      if (!relevantDeploymentStates.includes(state) || !byStatus.deploymentIds.length) {
-        return accu;
-      }
-      accu[state] = byStatus.deploymentIds.reduce((accu2, id) => {
-        if (deploymentsById[id]) {
-          accu2.push(deploymentsById[id]);
-        }
-        return accu2;
-      }, []).slice(0, DEPLOYMENT_CUTOFF);
-      accu.total += byStatus.total;
-      return accu;
-    },
-    { total: 0 }
-  )
-);
-
-// src/devicesSlice/selectors.ts
-var import_helpers2 = require("@northern.tech/utils/helpers");
-var import_toolkit3 = require("@reduxjs/toolkit");
-var getAcceptedDevices = (state) => state.devices.byStatus.accepted;
-var getDevicesByStatus = (state) => state.devices.byStatus;
-var getDevicesById = (state) => state.devices.byId;
-var getGroupsById = (state) => state.devices.groups.byId;
-var getSelectedGroup = (state) => state.devices.groups.selectedGroup;
-var getListedDevices = (state) => state.devices.deviceList.deviceIds;
-var getFilteringAttributes = (state) => state.devices.filteringAttributes;
-var getFilteringAttributesFromConfig = (state) => state.devices.filteringAttributesConfig.attributes;
-var getSortedFilteringAttributes = (0, import_toolkit3.createSelector)([getFilteringAttributes], (filteringAttributes) => ({
-  ...filteringAttributes,
-  identityAttributes: [...filteringAttributes.identityAttributes, "id"]
-}));
-var getDeviceLimit = (state) => state.devices.limit;
-var getFilteringAttributesLimit = (state) => state.devices.filteringAttributesLimit;
-var getDeviceIdentityAttributes = (0, import_toolkit3.createSelector)(
-  [getFilteringAttributes, getFilteringAttributesLimit],
-  ({ identityAttributes }, filteringAttributesLimit) => {
-    const attributes = identityAttributes.slice(0, filteringAttributesLimit);
-    return attributes.reduce(
-      (accu, value) => {
-        accu.push({ value, label: value, scope: "identity" });
-        return accu;
-      },
-      [
-        { value: "name", label: "Name", scope: "tags" },
-        { value: "id", label: "Device ID", scope: "identity" }
-      ]
-    );
-  }
-);
-var getDeviceCountsByStatus = (0, import_toolkit3.createSelector)(
-  [getDevicesByStatus],
-  (byStatus) => Object.values(DEVICE_STATES).reduce((accu, state) => {
-    accu[state] = byStatus[state].total || 0;
-    return accu;
-  }, {})
-);
-var getDeviceById = (0, import_toolkit3.createSelector)([getDevicesById, (_, deviceId) => deviceId], (devicesById, deviceId = "") => devicesById[deviceId] ?? {});
-var getSelectedGroupInfo = (0, import_toolkit3.createSelector)(
-  [getAcceptedDevices, getGroupsById, getSelectedGroup],
-  ({ total: acceptedDeviceTotal }, groupsById, selectedGroup) => {
-    let groupCount = acceptedDeviceTotal;
-    let groupFilters = [];
-    if (selectedGroup && groupsById[selectedGroup]) {
-      groupCount = groupsById[selectedGroup].total;
-      groupFilters = groupsById[selectedGroup].filters || [];
-    }
-    return { groupCount, selectedGroup, groupFilters };
-  }
-);
-var getLimitMaxed = (0, import_toolkit3.createSelector)(
-  [getAcceptedDevices, getDeviceLimit],
-  ({ total: acceptedDevices = 0 }, deviceLimit) => Boolean(deviceLimit && deviceLimit <= acceptedDevices)
-);
-var getGroupsByIdWithoutUngrouped = (0, import_toolkit3.createSelector)([getGroupsById], ({ [UNGROUPED_GROUP.id]: ungrouped, ...groups }) => groups);
-var getGroups = (0, import_toolkit3.createSelector)([getGroupsById], (groupsById) => {
-  const groupNames = Object.keys(groupsById).sort();
-  const groupedGroups = Object.entries(groupsById).sort((a, b) => a[0].localeCompare(b[0])).reduce(
-    (accu, [groupname, group]) => {
-      const name = groupname === UNGROUPED_GROUP.id ? UNGROUPED_GROUP.name : groupname;
-      const groupItem = { ...group, groupId: name, name: groupname };
-      if (group.filters.length > 0) {
-        if (groupname !== UNGROUPED_GROUP.id) {
-          accu.dynamic.push(groupItem);
-        } else {
-          accu.ungrouped.push(groupItem);
-        }
-      } else {
-        accu.static.push(groupItem);
-      }
-      return accu;
-    },
-    { dynamic: [], static: [], ungrouped: [] }
-  );
-  return { groupNames, ...groupedGroups };
-});
-var getAttributesList = (0, import_toolkit3.createSelector)(
-  [getFilteringAttributes, getFilteringAttributesFromConfig],
-  ({ identityAttributes = [], inventoryAttributes = [] }, { identity = [], inventory = [] }) => [...identityAttributes, ...inventoryAttributes, ...identity, ...inventory].filter(import_helpers2.duplicateFilter)
-);
-var getDeviceTypes = (0, import_toolkit3.createSelector)(
-  [getAcceptedDevices, getDevicesById],
-  ({ deviceIds = [] }, devicesById) => Object.keys(
-    deviceIds.slice(0, 200).reduce((accu, item) => {
-      const { device_type: deviceTypes = [] } = devicesById[item] ? devicesById[item].attributes : {};
-      accu = deviceTypes.reduce((deviceTypeAccu, deviceType) => {
-        if (deviceType.length > 1) {
-          deviceTypeAccu[deviceType] = deviceTypeAccu[deviceType] ? deviceTypeAccu[deviceType] + 1 : 1;
-        }
-        return deviceTypeAccu;
-      }, accu);
-      return accu;
-    }, {})
-  )
-);
-
-// src/monitorSlice/selectors.ts
-var getIssueCountsByType = (state) => state.monitor.issueCounts.byType;
-
-// src/onboardingSlice/selectors.ts
-var getOnboarding = (state) => state.onboarding;
-
-// src/organizationSlice/selectors.ts
-var import_toolkit4 = require("@reduxjs/toolkit");
-var getOrganization = (state) => state.organization.organization;
-var getExternalIntegrations = (state) => state.organization.externalDeviceIntegrations;
-var getAuditLog = (state) => state.organization.auditlog.events;
-var getAuditLogSelectionState = (state) => state.organization.auditlog.selectionState;
-var getWebhookEvents = (state) => state.organization.webhooks.events;
-var getWebhookEventTotal = (state) => state.organization.webhooks.eventTotal;
-var getDeviceTwinIntegrations = (0, import_toolkit4.createSelector)(
-  [getExternalIntegrations],
-  (integrations) => integrations.filter((integration) => integration.id && EXTERNAL_PROVIDER[integration.provider]?.deviceTwin)
-);
-var getIsServiceProvider = (state) => state.organization.organization.service_provider;
-var getWebhooks = (0, import_toolkit4.createSelector)(
-  [getExternalIntegrations],
-  (integrations) => integrations.filter((integration) => integration.id && integration.provider === EXTERNAL_PROVIDER.webhook.provider)
-);
-var getWebhookEventInfo = (0, import_toolkit4.createSelector)(
-  [getWebhooks, getWebhookEvents, getWebhookEventTotal],
-  (webhooks, events, eventTotal) => webhooks.length ? { events, eventTotal } : { events: [], eventTotal: 0 }
-);
-var getAuditLogEntry = (0, import_toolkit4.createSelector)([getAuditLog, getAuditLogSelectionState], (events, { selectedId }) => {
-  if (!selectedId) {
-    return;
-  }
-  const [eventAction, eventTime] = atob(selectedId).split("|");
-  return events.find((item) => item.action === eventAction && item.time === eventTime);
-});
-
-// src/utils.ts
-var import_helpers3 = require("@northern.tech/utils/helpers");
-var filterAliases = {
-  $nexists: { alias: DEVICE_FILTERING_OPTIONS.$exists.key, value: false }
-};
-var listItemMapper = (byId, ids, { defaultObject = {}, cutOffSize = DEVICE_LIST_MAXIMUM_LENGTH }) => {
-  return ids.slice(0, cutOffSize).reduce((accu, id) => {
-    if (id && byId[id]) {
-      accu.push({ ...defaultObject, ...byId[id] });
-    }
-    return accu;
-  }, []);
-};
-var mergePermissions = (existingPermissions = { ...emptyUiPermissions }, addedPermissions) => Object.entries(existingPermissions).reduce(
-  (accu, [key, value]) => {
-    let values;
-    if (!accu[key]) {
-      accu[key] = value;
-      return accu;
-    }
-    if (Array.isArray(value)) {
-      values = [...value, ...accu[key]].filter(import_helpers3.duplicateFilter);
-    } else {
-      values = mergePermissions(accu[key], { ...value });
-    }
-    accu[key] = values;
-    return accu;
-  },
-  { ...addedPermissions }
-);
-var mapUserRolesToUiPermissions = (userRoles, roles) => userRoles.reduce(
-  (accu, roleId) => {
-    if (!(roleId && roles[roleId])) {
-      return accu;
-    }
-    return mergePermissions(accu, roles[roleId].uiPermissions);
-  },
-  { ...emptyUiPermissions }
-);
-var isDarkMode = (mode) => mode === DARK_MODE;
-
-// src/releasesSlice/selectors.ts
-var import_toolkit5 = require("@reduxjs/toolkit");
-var getSelectedReleaseId = (state) => state.releases.selectedRelease;
-var getReleasesById = (state) => state.releases.byId;
-var getReleaseTags = (state) => state.releases.tags;
-var getReleaseListState = (state) => state.releases.releasesList;
-var getListedReleases = (state) => state.releases.releasesList.releaseIds;
-var getReleaseMappingDefaults = () => ({});
-var getReleasesList = (0, import_toolkit5.createSelector)([getReleasesById, getListedReleases, getReleaseMappingDefaults], listItemMapper);
-var getReleaseTagsById = (0, import_toolkit5.createSelector)([getReleaseTags], (releaseTags) => releaseTags.reduce((accu, key) => ({ ...accu, [key]: key }), {}));
-var getHasReleases = (0, import_toolkit5.createSelector)(
-  [getReleaseListState, getReleasesById],
-  ({ searchTotal, total }, byId) => !!(Object.keys(byId).length || total || searchTotal)
-);
-var getSelectedRelease = (0, import_toolkit5.createSelector)([getReleasesById, getSelectedReleaseId], (byId, id) => byId[id] ?? {});
-
-// src/usersSlice/selectors.ts
-var import_toolkit6 = require("@reduxjs/toolkit");
-var getRolesById = (state) => state.users.rolesById;
-var getTooltipsById = (state) => state.users.tooltips.byId;
-var getGlobalSettings = (state) => state.users.globalSettings;
-var getCurrentUserId = (state) => state.users.currentUser;
-var getUsersById = (state) => state.users.byId;
-var getCurrentUser = (0, import_toolkit6.createSelector)([getUsersById, getCurrentUserId], (usersById, userId) => usersById[userId] ?? {});
-var getUserSettings = (state) => state.users.userSettings;
-var getIsDarkMode = (0, import_toolkit6.createSelector)([getUserSettings], ({ mode }) => isDarkMode(mode));
-var getShowHelptips = (0, import_toolkit6.createSelector)(
-  [getTooltipsById],
-  (tooltips) => Object.values(tooltips).reduce((accu, { readState }) => accu || readState === READ_STATES.unread, false)
-);
-var getTooltipsState = (0, import_toolkit6.createSelector)(
-  [getTooltipsById, getUserSettings],
-  (byId, { tooltips = {} }) => Object.entries(byId).reduce(
-    (accu, [id, value]) => {
-      accu[id] = { ...accu[id], ...value };
-      return accu;
-    },
-    { ...tooltips }
-  )
-);
-var getHas2FA = (0, import_toolkit6.createSelector)(
-  [getCurrentUser],
-  (currentUser) => currentUser.hasOwnProperty("tfa_status") && currentUser.tfa_status === twoFAStates.enabled
-);
-var getIdAttribute = (0, import_toolkit6.createSelector)([getGlobalSettings], ({ id_attribute = { ...defaultIdAttribute } }) => id_attribute);
-var getOfflineThresholdSettings = (0, import_toolkit6.createSelector)([getGlobalSettings], ({ offlineThreshold }) => ({
-  interval: offlineThreshold?.interval || DEVICE_ONLINE_CUTOFF.interval,
-  intervalUnit: offlineThreshold?.intervalUnit || DEVICE_ONLINE_CUTOFF.intervalName
-}));
-var getRolesList = (0, import_toolkit6.createSelector)([getRolesById], (rolesById2) => Object.entries(rolesById2).map(([id, role]) => ({ id, ...role })));
-
-// src/commonSelectors.ts
-var getIsEnterprise = (0, import_toolkit7.createSelector)(
-  [getOrganization, getFeatures],
-  ({ plan = PLANS.os.id }, { isEnterprise, isHosted }) => isEnterprise || isHosted && plan === PLANS.enterprise.id
-);
-var getAttrsEndpoint = (0, import_toolkit7.createSelector)(
-  [getFeatures],
-  ({ hasReporting }) => hasReporting ? `${reportingApiUrl}/devices/search/attributes` : `${inventoryApiUrlV2}/filters/attributes`
-);
-var getSearchEndpoint = (0, import_toolkit7.createSelector)(
-  [getFeatures],
-  ({ hasReporting }) => hasReporting ? `${reportingApiUrl}/devices/search` : `${inventoryApiUrlV2}/filters/search`
-);
-var getUserRoles = (0, import_toolkit7.createSelector)(
-  [getCurrentUser, getRolesById, getIsEnterprise, getFeatures, getOrganization],
-  (currentUser, rolesById2, isEnterprise, { isHosted, hasMultitenancy }, { plan = PLANS.os.id }) => {
-    const isAdmin = currentUser.roles?.length ? currentUser.roles.some((role) => role === rolesByName.admin) : !(hasMultitenancy || isEnterprise || isHosted && plan !== PLANS.os.id);
-    const uiPermissions = isAdmin ? mapUserRolesToUiPermissions([rolesByName.admin], rolesById2) : mapUserRolesToUiPermissions(currentUser.roles || [], rolesById2);
-    return { isAdmin, uiPermissions };
-  }
-);
-var hasPermission = (thing, permission) => Object.values(thing).some((permissions) => permissions.includes(permission));
-var getUserCapabilities = (0, import_toolkit7.createSelector)([getUserRoles, getIsServiceProvider], ({ uiPermissions }, isServiceProvider) => {
-  const canManageReleases = hasPermission(uiPermissions.releases, uiPermissionsById.manage.value);
-  const canReadReleases = canManageReleases || hasPermission(uiPermissions.releases, uiPermissionsById.read.value);
-  const canUploadReleases = canManageReleases || hasPermission(uiPermissions.releases, uiPermissionsById.upload.value);
-  const canAuditlog = uiPermissions.auditlog.includes(uiPermissionsById.read.value);
-  const canReadUsers = uiPermissions.userManagement.includes(uiPermissionsById.read.value);
-  const canManageUsers = uiPermissions.userManagement.includes(uiPermissionsById.manage.value);
-  const canReadDevices = hasPermission(uiPermissions.groups, uiPermissionsById.read.value);
-  const canWriteDevices = Object.values(uiPermissions.groups).some(
-    (groupPermissions) => groupPermissions.includes(uiPermissionsById.read.value) && groupPermissions.length > 1
-  );
-  const canTroubleshoot = hasPermission(uiPermissions.groups, uiPermissionsById.connect.value);
-  const canManageDevices = hasPermission(uiPermissions.groups, uiPermissionsById.manage.value);
-  const canConfigure = hasPermission(uiPermissions.groups, uiPermissionsById.configure.value);
-  const canDeploy = uiPermissions.deployments.includes(uiPermissionsById.deploy.value) || hasPermission(uiPermissions.groups, uiPermissionsById.deploy.value);
-  const canReadDeployments = uiPermissions.deployments.includes(uiPermissionsById.read.value);
-  return {
-    canAuditlog,
-    canConfigure,
-    canDeploy,
-    canManageDevices,
-    canManageReleases,
-    canManageUsers,
-    canReadDeployments,
-    canReadDevices,
-    canReadReleases,
-    canReadUsers,
-    canTroubleshoot,
-    canUploadReleases,
-    canWriteDevices,
-    groupsPermissions: uiPermissions.groups,
-    releasesPermissions: uiPermissions.releases,
-    SPTenant: isServiceProvider
-  };
-});
-var getTenantCapabilities = (0, import_toolkit7.createSelector)(
-  [getFeatures, getOrganization, getIsEnterprise],
-  ({ hasAuditlogs: isAuditlogEnabled, hasDeviceConfig: isDeviceConfigEnabled, hasDeviceConnect: isDeviceConnectEnabled, hasMonitor: isMonitorEnabled }, { addons = [], plan = PLANS.os.id }, isEnterprise) => {
-    const canDelta = isEnterprise || plan === PLANS.professional.id;
-    const hasAuditlogs = isAuditlogEnabled && isEnterprise;
-    const hasDeviceConfig = isDeviceConfigEnabled && addons.some((addon) => addon.name === "configure" && Boolean(addon.enabled));
-    const hasDeviceConnect = isDeviceConnectEnabled && (!isEnterprise || addons.some((addon) => addon.name === "troubleshoot" && Boolean(addon.enabled)));
-    const hasMonitor = isMonitorEnabled && addons.some((addon) => addon.name === "monitor" && Boolean(addon.enabled));
-    return {
-      canDelta,
-      canRetry: canDelta,
-      canSchedule: canDelta,
-      hasAuditlogs,
-      hasDeviceConfig,
-      hasDeviceConnect,
-      hasFullFiltering: canDelta,
-      hasMonitor,
-      isEnterprise,
-      plan
-    };
-  }
-);
-var getFilterAttributes = (0, import_toolkit7.createSelector)(
-  [getGlobalSettings, getFilteringAttributes],
-  ({ previousFilters }, { identityAttributes, inventoryAttributes, systemAttributes, tagAttributes }) => {
-    const deviceNameAttribute = { key: "name", value: "Name", scope: ATTRIBUTE_SCOPES.tags, category: ATTRIBUTE_SCOPES.tags, priority: 1 };
-    const deviceIdAttribute = { key: "id", value: "Device ID", scope: ATTRIBUTE_SCOPES.identity, category: ATTRIBUTE_SCOPES.identity, priority: 1 };
-    const checkInAttribute = { key: "check_in_time", value: "Latest activity", scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 };
-    const updateAttribute = { ...checkInAttribute, key: "updated_ts", value: "Last inventory update" };
-    const firstRequestAttribute = { key: "created_ts", value: "First request", scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 };
-    const attributes = [
-      ...previousFilters.map((item) => ({
-        ...item,
-        value: deviceIdAttribute.key === item.key ? deviceIdAttribute.value : item.key,
-        category: "recently used",
-        priority: 0
-      })),
-      deviceNameAttribute,
-      deviceIdAttribute,
-      ...identityAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.identity, category: ATTRIBUTE_SCOPES.identity, priority: 1 })),
-      ...inventoryAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.inventory, category: ATTRIBUTE_SCOPES.inventory, priority: 2 })),
-      ...tagAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.tags, category: ATTRIBUTE_SCOPES.tags, priority: 3 })),
-      checkInAttribute,
-      updateAttribute,
-      firstRequestAttribute,
-      ...systemAttributes.map((item) => ({ key: item, value: item, scope: ATTRIBUTE_SCOPES.system, category: ATTRIBUTE_SCOPES.system, priority: 4 }))
-    ];
-    return (0, import_helpers4.attributeDuplicateFilter)(attributes, "key");
-  }
-);
-var getOnboardingState = (0, import_toolkit7.createSelector)([getOnboarding, getUserSettings], ({ complete, progress, showTips, ...remainder }, { onboarding = {} }) => ({
-  ...remainder,
-  ...onboarding,
-  complete: onboarding.complete || complete,
-  progress: Object.keys(onboardingSteps).findIndex((step) => step === progress) > Object.keys(onboardingSteps).findIndex((step) => step === onboarding.progress) ? progress : onboarding.progress,
-  showTips: !onboarding.showTips ? onboarding.showTips : showTips
-}));
-var getDemoDeviceAddress = (0, import_toolkit7.createSelector)([getDevicesById, getOnboarding], (devicesById, { approach, demoArtifactPort }) => {
-  const demoDeviceAddress = `http://${(0, import_helpers4.getDemoDeviceAddress)(Object.values(devicesById), approach)}`;
-  return demoArtifactPort ? `${demoDeviceAddress}:${demoArtifactPort}` : demoDeviceAddress;
-});
-var getDeviceConfigDeployment = (0, import_toolkit7.createSelector)([getDeviceById, getDeploymentsById], (device, deploymentsById) => {
-  const { config = {} } = device;
-  const { deployment_id: configDeploymentId } = config;
-  const deviceConfigDeployment = deploymentsById[configDeploymentId] || {};
-  return { device, deviceConfigDeployment };
-});
-var getDeploymentRelease = (0, import_toolkit7.createSelector)(
-  [getDeploymentsById, getDeploymentsSelectionState, getReleasesById],
-  (deploymentsById, { selectedId }, releasesById) => {
-    const deployment = deploymentsById[selectedId] || {};
-    return deployment.artifact_name && releasesById[deployment.artifact_name] ? releasesById[deployment.artifact_name] : { device_types_compatible: [] };
-  }
-);
-var getSelectedDeploymentData = (0, import_toolkit7.createSelector)(
-  [getDeploymentsById, getDeploymentsSelectionState, getDevicesById, getSelectedDeploymentDeviceIds],
-  (deploymentsById, { selectedId }, devicesById, selectedDeviceIds) => {
-    const deployment = deploymentsById[selectedId] ?? {};
-    const { devices = {} } = deployment;
-    return {
-      deployment,
-      selectedDevices: selectedDeviceIds.map((deviceId) => ({ ...devicesById[deviceId], ...devices[deviceId] }))
-    };
-  }
-);
-var getAvailableIssueOptionsByType = (0, import_toolkit7.createSelector)(
-  [getFeatures, getTenantCapabilities, getIssueCountsByType],
-  ({ hasReporting }, { hasFullFiltering, hasMonitor }, issueCounts) => Object.values(DEVICE_ISSUE_OPTIONS).reduce((accu, { isCategory, key, needsFullFiltering, needsMonitor, needsReporting, title }) => {
-    if (isCategory || needsReporting && !hasReporting || needsFullFiltering && !hasFullFiltering || needsMonitor && !hasMonitor) {
-      return accu;
-    }
-    accu[key] = { count: issueCounts[key].filtered, key, title };
-    return accu;
-  }, {})
-);
-var getGroupNames = (0, import_toolkit7.createSelector)([getGroupsById, getUserRoles, (_, options = {}) => options], (groupsById, { uiPermissions }, { staticOnly }) => {
-  const { [UNGROUPED_GROUP.id]: ungrouped, ...groups } = groupsById;
-  if (staticOnly) {
-    return Object.keys(uiPermissions.groups).sort();
-  }
-  return Object.keys(
-    Object.entries(groups).reduce((accu, [groupName, group]) => {
-      if (group.filterId || uiPermissions.groups[ALL_DEVICES]) {
-        accu[groupName] = group;
-      }
-      return accu;
-    }, uiPermissions.groups)
-  ).sort();
-});
-var getDeviceReportsForUser = (0, import_toolkit7.createSelector)(
-  [getUserSettings, getCurrentUser, getGlobalSettings, getDevicesById],
-  ({ reports }, { id: currentUserId }, globalSettings, devicesById) => {
-    return reports || globalSettings[`${currentUserId}-reports`] || (Object.keys(devicesById).length ? defaultReports : []);
-  }
-);
-var listTypeDeviceIdMap = {
-  deviceList: getListedDevices,
-  search: getSearchedDevices
-};
-var deviceMapDefault = { defaultObject: { auth_sets: [] }, cutOffSize: DEVICE_LIST_MAXIMUM_LENGTH };
-var getDeviceMappingDefaults = () => deviceMapDefault;
-var getMappedDevicesList = (0, import_toolkit7.createSelector)(
-  [getDevicesById, (state, listType) => listTypeDeviceIdMap[listType](state), getDeviceMappingDefaults],
-  listItemMapper
-);
-var getAuditlogDevice = (0, import_toolkit7.createSelector)([getAuditLogEntry, getDevicesById], (auditlogEvent, devicesById) => {
-  let auditlogDevice = {};
-  if (auditlogEvent) {
-    const { object = {} } = auditlogEvent;
-    const { device = {}, id, type } = object;
-    auditlogDevice = type === "device" ? { id, ...device } : auditlogDevice;
-  }
-  return { ...auditlogDevice, ...devicesById[auditlogDevice.id] };
-});
-var getRelevantRoles = (0, import_toolkit7.createSelector)([getOrganization, getRolesList], ({ service_provider }, roles) => {
-  if (service_provider) {
-    return roles.reduce((accu, role) => {
-      if (rolesById[role.id]) {
-        return accu;
-      }
-      accu.push(role);
-      return accu;
-    }, Object.values(serviceProviderRolesById));
-  }
-  return Object.keys(rolesById).reverse().reduce((accu, key) => {
-    const index = accu.findIndex(({ id }) => id === key);
-    accu = [accu[index], ...accu.filter((item, itemIndex) => index !== itemIndex)];
-    return accu;
-  }, roles);
-});
 //# sourceMappingURL=commonSelectors.js.map