@northern.tech/store 0.1.2 → 0.1.3

package/dist/actions.js

@@ -0,0 +1,1746 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/actions.ts
+var actions_exports = {};
+__export(actions_exports, {
+  default: () => actions_default
+});
+module.exports = __toCommonJS(actions_exports);
+
+// 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 = [__spreadProps(__spreadValues({}, 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 }
+};
+
+// 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 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({}),
+  userManagement: []
+});
+var emptyRole = Object.freeze({
+  name: void 0,
+  description: "",
+  permissions: [],
+  uiPermissions: Object.freeze(__spreadValues({}, emptyUiPermissions))
+});
+
+// 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 = __spreadProps(__spreadValues({}, 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]: __spreadValues({}, DEVICE_LIST_DEFAULTS),
+  [DEPLOYMENT_STATES.finished]: __spreadValues({}, DEVICE_LIST_DEFAULTS),
+  sort: { direction: SORTING_OPTIONS.desc }
+};
+var DEFAULT_PENDING_INPROGRESS_COUNT = 10;
+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 deploymentPrototype = {
+  devices: {},
+  name: void 0,
+  statistics: { status: {} }
+};
+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
+  }
+};
+var limitDefault = { min: 5, max: 100, default: 10 };
+
+// src/devicesSlice/constants.ts
+var emptyFilter = { key: null, value: "", operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "inventory" };
+var deviceAuthV2 = `${apiUrl.v2}/devauth`;
+var deviceConnect = `${apiUrl.v1}/deviceconnect`;
+var inventoryApiUrl = `${apiUrl.v1}/inventory`;
+var inventoryApiUrlV2 = `${apiUrl.v2}/inventory`;
+var deviceConfig = `${apiUrl.v1}/deviceconfig/configurations/device`;
+var reportingApiUrl = `${apiUrl.v1}/reporting`;
+var iotManagerBaseURL = `${apiUrl.v1}/iot-manager`;
+var 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 alertChannels = { email: "email" };
+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 emptyWebhook = {
+  description: "",
+  enabled: true,
+  credentials: {
+    type: EXTERNAL_PROVIDER.webhook.credentialsType,
+    [EXTERNAL_PROVIDER.webhook.credentialsType]: {
+      secret: "",
+      url: ""
+    }
+  }
+};
+var TENANT_LIST_DEFAULT = {
+  page: 1,
+  perPage: 20
+};
+
+// src/releasesSlice/constants.ts
+var rootfsImageVersion = "rootfs-image.version";
+var softwareTitleMap = { [rootfsImageVersion]: { title: "Root filesystem", priority: 0, key: rootfsImageVersion } };
+
+// src/usersSlice/constants.ts
+var useradmApiUrlv1 = `${apiUrl.v1}/useradm`;
+var useradmApiUrlv2 = `${apiUrl.v2}/useradm`;
+var staticRolesByName = {
+  admin: "RBAC_ROLE_PERMIT_ALL",
+  readOnly: "RBAC_ROLE_OBSERVER",
+  ci: "RBAC_ROLE_CI",
+  deploymentsManager: "RBAC_ROLE_DEPLOYMENTS_MANAGER",
+  terminalAccess: "RBAC_ROLE_REMOTE_TERMINAL"
+};
+var PermissionTypes = {
+  Any: "any",
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Delete: "DELETE",
+  Patch: "PATCH",
+  DeviceGroup: "DEVICE_GROUP",
+  DeviceId: "DEVICE_ID"
+};
+var permissionSetIds = {
+  Basic: "Basic",
+  ConfigureDevices: "ConfigureDevices",
+  ConnectToDevices: "ConnectToDevices",
+  DeployToDevices: "DeployToDevices",
+  ManageDevices: "ManageDevices",
+  ManageReleases: "ManageReleases",
+  ManageUsers: "ManageUsers",
+  ReadAuditLogs: "ReadAuditLogs",
+  ReadDevices: "ReadDevices",
+  ReadReleases: "ReadReleases",
+  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,
+      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,
+      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.",
+    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.",
+    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.",
+    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.",
+    scope: "ReleaseTags",
+    uiPermissions: [uiPermissionsById.read, uiPermissionsById.manage, uiPermissionsById.upload],
+    title: "Release 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",
+    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: __spreadProps(__spreadValues({}, 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: __spreadProps(__spreadValues({}, 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: __spreadProps(__spreadValues({}, emptyUiPermissions), {
+      releases: { [ALL_RELEASES]: uiPermissionsByArea.releases.uiPermissions.map(permissionMapper) }
+    })
+  },
+  [staticRolesByName.deploymentsManager]: {
+    name: "Deployments Manager",
+    value: staticRolesByName.deploymentsManager,
+    description: "",
+    permissions: [],
+    uiPermissions: __spreadProps(__spreadValues({}, 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: __spreadProps(__spreadValues({}, emptyUiPermissions), {
+      groups: { [ALL_DEVICES]: [uiPermissionsById.connect.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: __spreadValues({}, 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.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 = __spreadProps(__spreadValues({}, 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 READ_STATES = {
+  read: "read",
+  seen: "seen",
+  unread: "unread"
+};
+
+// src/appSlice/index.ts
+var import_toolkit = require("@reduxjs/toolkit");
+var sliceName = "app";
+var getYesterday = () => {
+  const today = /* @__PURE__ */ new Date();
+  today.setDate(today.getDate() - 1);
+  return today.toISOString();
+};
+var initialState = {
+  cancelSource: void 0,
+  demoArtifactLink: "https://dgsbl4vditpls.cloudfront.net/mender-demo-artifact.mender",
+  hostAddress: null,
+  snackbar: {
+    open: false,
+    message: "",
+    maxWidth: 900,
+    autoHideDuration: void 0,
+    action: void 0,
+    children: void 0,
+    onClick: void 0,
+    onClose: void 0
+  },
+  // return boolean rather than organization details
+  features: {
+    hasAuditlogs: false,
+    hasDeltaProgress: false,
+    hasMultitenancy: false,
+    hasDeviceConfig: false,
+    hasDeviceConnect: false,
+    hasFeedbackEnabled: false,
+    hasMonitor: false,
+    hasReporting: false,
+    isDemoMode: false,
+    isHosted: false,
+    isEnterprise: false
+  },
+  feedbackProbability: 0.3,
+  firstLoginAfterSignup: false,
+  hostedAnnouncement: "",
+  docsVersion: "",
+  recaptchaSiteKey: "",
+  searchState: {
+    deviceIds: [],
+    searchTerm: "",
+    searchTotal: 0,
+    sort: {
+      direction: SORTING_OPTIONS.desc
+      // key: null,
+      // scope: null
+    }
+  },
+  stripeAPIKey: "",
+  trackerCode: "",
+  uploadsById: {
+    // id: { uploading: false, uploadProgress: 0, cancelSource: undefined }
+  },
+  newThreshold: getYesterday(),
+  offlineThreshold: getYesterday(),
+  versionInformation: {
+    Integration: "",
+    "Mender-Client": "",
+    "Mender-Artifact": "",
+    "Meta-Mender": "",
+    Deployments: "",
+    Deviceauth: "",
+    Inventory: "",
+    GUI: "latest"
+  },
+  yesterday: void 0
+};
+var appSlice = (0, import_toolkit.createSlice)({
+  name: sliceName,
+  initialState,
+  reducers: {
+    setFeatures: (state, action) => {
+      state.features = __spreadValues(__spreadValues({}, state.features), action.payload);
+    },
+    setSnackbar: (state, { payload }) => {
+      let { message, autoHideDuration, action, children, onClick, onClose } = payload;
+      if (typeof payload === "string" || payload instanceof String) {
+        message = payload;
+      }
+      state.snackbar = {
+        open: message ? true : false,
+        message,
+        maxWidth: 900,
+        autoHideDuration,
+        action,
+        children,
+        onClick,
+        onClose
+      };
+    },
+    setFirstLoginAfterSignup: (state, action) => {
+      state.firstLoginAfterSignup = action.payload;
+    },
+    setAnnouncement: (state, action) => {
+      state.hostedAnnouncement = action.payload;
+    },
+    setSearchState: (state, action) => {
+      state.searchState = __spreadValues(__spreadValues({}, state.searchState), action.payload);
+    },
+    setOfflineThreshold: (state, action) => {
+      state.offlineThreshold = action.payload;
+    },
+    initUpload: (state, action) => {
+      const { id, upload } = action.payload;
+      state.uploadsById[id] = upload;
+    },
+    uploadProgress: (state, action) => {
+      const { id, progress } = action.payload;
+      state.uploadsById[id] = __spreadProps(__spreadValues({}, state.uploadsById[id]), {
+        progress
+      });
+    },
+    cleanUpUpload: (state, action) => {
+      var _a;
+      const _b = state.uploadsById, { [_a = action.payload]: current } = _b, remainder = __objRest(_b, [__restKey(_a)]);
+      state.uploadsById = remainder;
+    },
+    setVersionInformation: (state, action) => {
+      state.versionInformation = __spreadValues(__spreadValues({}, state.versionInformation), action.payload);
+    },
+    setEnvironmentData: (state, action) => {
+      return __spreadValues(__spreadValues({}, state), action.payload);
+    }
+  }
+});
+var actions = appSlice.actions;
+var appSlice_default = appSlice.reducer;
+
+// src/deploymentsSlice/index.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+var sliceName2 = "deployments";
+var initialState2 = {
+  byId: {
+    // [id]: { statistics: { status: {}, total_size }, devices: { [deploymentId]: { id, log } }, totalDeviceCount }
+  },
+  byStatus: {
+    finished: { deploymentIds: [], total: 0 },
+    inprogress: { deploymentIds: [], total: 0 },
+    pending: { deploymentIds: [], total: 0 },
+    scheduled: { deploymentIds: [], total: 0 }
+  },
+  config: {
+    binaryDelta: {
+      timeout: -1,
+      duplicatesWindow: -1,
+      compressionLevel: -1,
+      disableChecksum: false,
+      disableDecompression: false,
+      inputWindow: -1,
+      instructionBuffer: -1,
+      sourceWindow: -1
+    },
+    binaryDeltaLimits: {
+      timeout: __spreadProps(__spreadValues({}, limitDefault), { default: 60, max: 3600, min: 60 }),
+      sourceWindow: limitDefault,
+      inputWindow: limitDefault,
+      duplicatesWindow: limitDefault,
+      instructionBuffer: limitDefault
+    }
+  },
+  deploymentDeviceLimit: 5e3,
+  selectedDeviceIds: [],
+  selectionState: {
+    finished: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), { endDate: void 0, search: "", selection: [], startDate: void 0, total: 0, type: "" }),
+    inprogress: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), { perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] }),
+    pending: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), { perPage: DEFAULT_PENDING_INPROGRESS_COUNT, selection: [] }),
+    scheduled: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), { selection: [] }),
+    general: {
+      state: DEPLOYMENT_ROUTES.active.key,
+      showCreationDialog: false,
+      showReportDialog: false,
+      reportType: null
+      // DeploymentConstants.DEPLOYMENT_TYPES.configuration|DeploymentConstants.DEPLOYMENT_TYPES.software
+    },
+    selectedId: void 0
+  }
+};
+var deploymentsSlice = (0, import_toolkit2.createSlice)({
+  name: sliceName2,
+  initialState: initialState2,
+  reducers: {
+    createdDeployment: (state, action) => {
+      state.byId[action.payload.id] = __spreadValues(__spreadValues({}, deploymentPrototype), action.payload);
+      state.byStatus[DEPLOYMENT_STATES.pending].total = state.byStatus[DEPLOYMENT_STATES.pending].total + 1;
+      state.byStatus[DEPLOYMENT_STATES.pending].deploymentIds = [...state.byStatus.pending.deploymentIds, action.payload.id];
+      state.selectionState[DEPLOYMENT_STATES.pending].selection = [action.payload.id, ...state.selectionState[DEPLOYMENT_STATES.pending].selection], state.selectionState[DEPLOYMENT_STATES.pending].total = state.selectionState[DEPLOYMENT_STATES.pending].total + 1;
+    },
+    removedDeployment: (state, action) => {
+      var _a;
+      const _b = state.byId, { [_a = action.payload]: removedDeployment } = _b, remainder = __objRest(_b, [__restKey(_a)]);
+      state.byId = remainder;
+    },
+    receivedDeployment: (state, action) => {
+      state.byId[action.payload.id] = __spreadValues(__spreadValues({}, state.byId[action.payload.id] || {}), action.payload);
+    },
+    receivedDeploymentDeviceLog: (state, action) => {
+      const { id, deviceId, log } = action.payload;
+      const deployment = __spreadValues(__spreadValues({}, deploymentPrototype), state.byId[id]);
+      state.byId[id] = __spreadProps(__spreadValues({}, deployment), {
+        devices: __spreadProps(__spreadValues({}, deployment.devices), {
+          [deviceId]: __spreadProps(__spreadValues({}, deployment.devices[deviceId]), {
+            log
+          })
+        })
+      });
+    },
+    receivedDeploymentDevices: (state, action) => {
+      const { id, devices, selectedDeviceIds, totalDeviceCount } = action.payload;
+      state.byId[id] = __spreadProps(__spreadValues({}, state.byId[id]), {
+        devices,
+        totalDeviceCount
+      });
+      state.selectedDeviceIds = selectedDeviceIds;
+    },
+    receivedDeployments: (state, action) => {
+      state.byId = __spreadValues(__spreadValues({}, state.byId), action.payload);
+    },
+    receivedDeploymentsForStatus: (state, action) => {
+      const { status, deploymentIds, total } = action.payload;
+      state.byStatus[status].deploymentIds = deploymentIds;
+      state.byStatus[status].total = total;
+    },
+    selectDeploymentsForStatus: (state, action) => {
+      const { status, deploymentIds, total } = action.payload;
+      state.selectionState[status].selection = deploymentIds;
+      state.selectionState[status].total = total;
+    },
+    setDeploymentsState: (state, action) => {
+      state.selectionState = action.payload;
+    },
+    setDeploymentsConfig: (state, action) => {
+      state.config = action.payload;
+    }
+  }
+});
+var actions2 = deploymentsSlice.actions;
+var deploymentsSlice_default = deploymentsSlice.reducer;
+
+// src/devicesSlice/index.ts
+var import_helpers = require("@northern.tech/utils/helpers");
+var import_toolkit3 = require("@reduxjs/toolkit");
+var sliceName3 = "devices";
+var initialState3 = {
+  byId: {
+    // [deviceId]: {
+    //   ...,
+    //   twinsByIntegration: { [external.provider.id]: twinData }
+    // }
+  },
+  byStatus: {
+    [DEVICE_STATES.accepted]: { deviceIds: [], total: 0 },
+    active: { deviceIds: [], total: 0 },
+    inactive: { deviceIds: [], total: 0 },
+    [DEVICE_STATES.pending]: { deviceIds: [], total: 0 },
+    [DEVICE_STATES.preauth]: { deviceIds: [], total: 0 },
+    [DEVICE_STATES.rejected]: { deviceIds: [], total: 0 }
+  },
+  deviceList: __spreadProps(__spreadValues({
+    deviceIds: []
+  }, DEVICE_LIST_DEFAULTS), {
+    selectedAttributes: [],
+    selectedIssues: [],
+    selection: [],
+    sort: {
+      direction: SORTING_OPTIONS.desc
+      // key: null,
+      // scope: null
+    },
+    state: DEVICE_STATES.accepted,
+    total: 0
+  }),
+  filters: [
+    // { key: 'device_type', value: 'raspberry', operator: '$eq', scope: 'inventory' }
+  ],
+  filteringAttributes: { identityAttributes: [], inventoryAttributes: [], systemAttributes: [], tagAttributes: [] },
+  filteringAttributesLimit: 10,
+  filteringAttributesConfig: {
+    attributes: {
+      // inventory: ['some_attribute']
+    },
+    count: 0,
+    limit: 100
+  },
+  reports: [
+    // { items: [{ key: "someKey", count: 42  }], otherCount: 123, total: <otherCount + itemsCount> }
+  ],
+  total: 0,
+  limit: 0,
+  groups: {
+    byId: {
+      // groupName: { deviceIds: [], total: 0, filters: [] },
+      // dynamo: { deviceIds: [], total: 3, filters: [{ a: 1 }] }
+    },
+    selectedGroup: void 0
+  }
+};
+var devicesSlice = (0, import_toolkit3.createSlice)({
+  name: sliceName3,
+  initialState: initialState3,
+  reducers: {
+    receivedGroups: (state, action) => {
+      state.groups.byId = action.payload;
+    },
+    addToGroup: (state, action) => {
+      const { group, deviceIds } = action.payload;
+      const maybeExistingGroup = __spreadValues({
+        filters: [],
+        deviceIds: []
+      }, state.groups.byId[group]);
+      state.groups.byId[group] = __spreadProps(__spreadValues({}, maybeExistingGroup), {
+        deviceIds: [...maybeExistingGroup.deviceIds, ...deviceIds].filter(import_helpers.duplicateFilter),
+        total: (maybeExistingGroup.total || 0) + 1
+      });
+    },
+    removeFromGroup: (state, action) => {
+      const { group, deviceIds: removedIds } = action.payload;
+      const _a = state.groups.byId[group] || {}, { deviceIds = [], total = 0 } = _a, maybeExistingGroup = __objRest(_a, ["deviceIds", "total"]);
+      const changedGroup = __spreadProps(__spreadValues({}, maybeExistingGroup), {
+        deviceIds: deviceIds.filter((id) => !removedIds.includes(id)),
+        total: Math.max(total - removedIds.length, 0)
+      });
+      if (changedGroup.total || changedGroup.deviceIds.length) {
+        state.groups.byId[group] = changedGroup;
+        return;
+      } else if (state.groups.selectedGroup === group) {
+        state.groups.selectedGroup = void 0;
+      }
+      const _b = state.groups.byId, { [group]: removal } = _b, remainingById = __objRest(_b, [__restKey(group)]);
+      state.groups.byId = remainingById;
+    },
+    addGroup: (state, action) => {
+      const { groupName, group } = action.payload;
+      state.groups.byId[groupName] = __spreadValues(__spreadValues({}, state.groups.byId[groupName]), group);
+    },
+    selectGroup: (state, { payload: group }) => {
+      state.deviceList.deviceIds = state.groups.byId[group] && state.groups.byId[group].deviceIds.length > 0 ? state.groups.byId[group].deviceIds : [];
+      state.groups.selectedGroup = group;
+    },
+    removeGroup: (state, action) => {
+      var _a;
+      const _b = state.groups.byId, { [_a = action.payload]: removal } = _b, remainingById = __objRest(_b, [__restKey(_a)]);
+      state.groups.byId = remainingById;
+      state.groups.selectedGroup = state.groups.selectedGroup === action.payload ? void 0 : state.groups.selectedGroup;
+    },
+    setDeviceListState: (state, action) => {
+      state.deviceList = __spreadProps(__spreadValues(__spreadValues({}, state.deviceList), action.payload), {
+        sort: __spreadValues(__spreadValues({}, state.deviceList.sort), action.payload.sort)
+      });
+    },
+    setFilterAttributes: (state, action) => {
+      state.filteringAttributes = action.payload;
+    },
+    setFilterablesConfig: (state, action) => {
+      state.filteringAttributesConfig = action.payload;
+    },
+    receivedDevices: (state, action) => {
+      state.byId = __spreadValues(__spreadValues({}, state.byId), action.payload);
+    },
+    setDeviceFilters: (state, action) => {
+      if ((0, import_helpers.deepCompare)(action.payload, state.filters)) {
+        return;
+      }
+      state.filters = action.payload.filter((filter) => filter.key && filter.operator && filter.scope && typeof filter.value !== "undefined");
+    },
+    setInactiveDevices: (state, action) => {
+      const { activeDeviceTotal, inactiveDeviceTotal } = action.payload;
+      state.byStatus.active.total = activeDeviceTotal;
+      state.byStatus.inactive.total = inactiveDeviceTotal;
+    },
+    setDeviceReports: (state, action) => {
+      state.reports = action.payload;
+    },
+    setDevicesByStatus: (state, action) => {
+      const { forceUpdate, status, total, deviceIds } = action.payload;
+      state.byStatus[status] = total || forceUpdate ? { deviceIds, total } : state.byStatus[status];
+    },
+    setDevicesCountByStatus: (state, action) => {
+      const { count, status } = action.payload;
+      state.byStatus[status].total = count;
+    },
+    setTotalDevices: (state, action) => {
+      state.total = action.payload;
+    },
+    setDeviceLimit: (state, action) => {
+      state.limit = action.payload;
+    },
+    receivedDevice: (state, action) => {
+      state.byId[action.payload.id] = __spreadValues(__spreadValues({}, state.byId[action.payload.id]), action.payload);
+    },
+    maybeUpdateDevicesByStatus: (state, action) => {
+      const { deviceId, authId } = action.payload;
+      const device = state.byId[deviceId];
+      const hasMultipleAuthSets = authId ? device.auth_sets.filter((authset) => authset.id !== authId).length > 0 : false;
+      if (!hasMultipleAuthSets && Object.values(DEVICE_STATES).includes(device.status)) {
+        const deviceIds = state.byStatus[device.status].deviceIds.filter((id) => id !== deviceId);
+        state.byStatus[device.status] = { deviceIds, total: Math.max(0, state.byStatus[device.status].total - 1) };
+      }
+    }
+  }
+});
+var actions3 = devicesSlice.actions;
+var devicesSlice_default = devicesSlice.reducer;
+
+// src/monitorSlice/index.ts
+var import_toolkit4 = require("@reduxjs/toolkit");
+var sliceName4 = "monitor";
+var initialState4 = {
+  alerts: {
+    alertList: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), { total: 0 }),
+    byDeviceId: {}
+  },
+  issueCounts: {
+    byType: Object.values(DEVICE_ISSUE_OPTIONS).reduce((accu, { key }) => __spreadProps(__spreadValues({}, accu), { [key]: { filtered: 0, total: 0 } }), {})
+  },
+  settings: {
+    global: {
+      channels: __spreadValues({}, Object.keys(alertChannels).reduce((accu, item) => __spreadProps(__spreadValues({}, accu), { [item]: { enabled: true } }), {}))
+    }
+  }
+};
+var monitorSlice = (0, import_toolkit4.createSlice)({
+  name: sliceName4,
+  initialState: initialState4,
+  reducers: {
+    changeAlertChannel: (state, action) => {
+      const { channel, enabled } = action.payload;
+      state.settings.global.channels[channel] = { enabled };
+    },
+    receiveDeviceAlerts: (state, action) => {
+      const { deviceId, alerts } = action.payload;
+      state.alerts.byDeviceId[deviceId] = { alerts };
+    },
+    receiveLatestDeviceAlerts: (state, action) => {
+      const { deviceId, alerts } = action.payload;
+      state.alerts.byDeviceId[deviceId] = __spreadProps(__spreadValues({}, state.alerts.byDeviceId[deviceId]), { latest: alerts });
+    },
+    receiveDeviceIssueCounts: (state, action) => {
+      const { issueType, counts } = action.payload;
+      state.issueCounts.byType[issueType] = counts;
+    },
+    setAlertListState: (state, action) => {
+      state.alerts.alertList = __spreadValues(__spreadValues({}, state.alerts.alertList), action.payload);
+    }
+  }
+});
+var actions4 = monitorSlice.actions;
+var monitorSlice_default = monitorSlice.reducer;
+
+// src/onboardingSlice/index.ts
+var import_toolkit5 = require("@reduxjs/toolkit");
+var sliceName5 = "onboarding";
+var initialState5 = {
+  approach: null,
+  complete: false,
+  deviceType: null,
+  demoArtifactPort: 85,
+  progress: null,
+  showTips: null,
+  showTipsDialog: false
+};
+var onboardingSlice = (0, import_toolkit5.createSlice)({
+  name: sliceName5,
+  initialState: initialState5,
+  reducers: {
+    setOnboardingState: (state, action) => {
+      return __spreadValues(__spreadValues({}, state), action.payload);
+    },
+    setDemoArtifactPort: (state, action) => {
+      state.demoArtifactPort = action.payload;
+    },
+    setShowOnboardingHelp: (state, action) => {
+      state.showTips = action.payload;
+    },
+    setShowDismissOnboardingTipsDialog: (state, action) => {
+      state.showTipsDialog = action.payload;
+    },
+    setOnboardingComplete: (state, action) => {
+      state.complete = action.payload;
+    },
+    setOnboardingProgress: (state, action) => {
+      state.progress = action.payload;
+    },
+    setOnboardingDeviceType: (state, action) => {
+      state.deviceType = action.payload;
+    },
+    setOnboardingApproach: (state, action) => {
+      state.approach = action.payload;
+    }
+  }
+});
+var actions5 = onboardingSlice.actions;
+var onboardingSlice_default = onboardingSlice.reducer;
+
+// src/organizationSlice/index.ts
+var import_toolkit6 = require("@reduxjs/toolkit");
+var sliceName6 = "organization";
+var initialState6 = {
+  card: {
+    last4: "",
+    expiration: { month: 1, year: 2020 },
+    brand: ""
+  },
+  intentId: null,
+  organization: {
+    tenantList: __spreadProps(__spreadValues({}, TENANT_LIST_DEFAULT), {
+      total: 0,
+      tenants: [],
+      selectedTenant: null,
+      sort: {
+        direction: SORTING_OPTIONS.desc,
+        key: "name"
+      }
+    })
+    // id, name, status, tenant_token, plan
+  },
+  auditlog: {
+    events: [],
+    selectionState: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), {
+      detail: void 0,
+      endDate: void 0,
+      selectedIssue: void 0,
+      sort: { direction: SORTING_OPTIONS.desc },
+      startDate: void 0,
+      total: 0,
+      type: void 0,
+      user: void 0
+    })
+  },
+  externalDeviceIntegrations: [
+    // { <connection_string|x509|...>, id, provider }
+  ],
+  ssoConfigs: [],
+  webhooks: {
+    // [id]: { events: [] }
+    // for now:
+    events: [],
+    eventsTotal: 0
+  }
+};
+var organizationSlice = (0, import_toolkit6.createSlice)({
+  name: sliceName6,
+  initialState: initialState6,
+  reducers: {
+    receiveAuditLogs: (state, action) => {
+      const { events, total } = action.payload;
+      state.auditlog.events = events;
+      state.auditlog.selectionState.total = total;
+    },
+    setAuditLogState: (state, action) => {
+      state.auditlog.selectionState = __spreadValues(__spreadValues({}, state.auditlog.selectionState), action.payload);
+    },
+    receiveCurrentCard: (state, action) => {
+      state.card = action.payload;
+    },
+    receiveSetupIntent: (state, action) => {
+      state.intentId = action.payload;
+    },
+    setOrganization: (state, action) => {
+      state.organization = __spreadProps(__spreadValues(__spreadValues({}, state.organization), action.payload), {
+        tenantList: __spreadValues(__spreadValues({}, state.organization.tenantList), action.payload.tenantList)
+      });
+    },
+    setTenantListState: (state, action) => {
+      state.organization.tenantList = action.payload;
+    },
+    receiveExternalDeviceIntegrations: (state, action) => {
+      state.externalDeviceIntegrations = action.payload;
+    },
+    receiveSsoConfigs: (state, action) => {
+      state.ssoConfigs = action.payload;
+    },
+    receiveWebhookEvents: (state, action) => {
+      const { value, total } = action.payload;
+      state.webhooks.events = value;
+      state.webhooks.eventsTotal = total;
+    }
+  }
+});
+var actions6 = organizationSlice.actions;
+var organizationSlice_default = organizationSlice.reducer;
+
+// src/releasesSlice/index.ts
+var import_toolkit7 = require("@reduxjs/toolkit");
+var sliceName7 = "releases";
+var initialState7 = {
+  /*
+   * Return list of saved artifacts objects
+   */
+  /*
+   * return list of artifacts where duplicate names are collated with device compatibility lists combined
+   */
+  // artifacts: AppStore.getCollatedArtifacts(AppStore.getArtifactsRepo()),
+  artifacts: [],
+  /*
+   * Return list of saved release objects
+   */
+  byId: {
+    /*
+    [releaseName]: {
+      artifacts: [
+        {
+          id: '',
+          name: '',
+          description: '',
+          device_types_compatible: [],
+          ...
+          updates: [{
+            files: [
+              { size: 123, name: '' }
+            ],
+            type_info: { type: '' }
+          }],
+          url: '' // optional
+        }
+      ],
+      modified: ''
+      device_types_compatible,
+      name: '',
+      tags: ['something'],
+      notes: ''
+    }
+    */
+  },
+  releasesList: __spreadProps(__spreadValues({}, DEVICE_LIST_DEFAULTS), {
+    searchedIds: [],
+    releaseIds: [],
+    selection: [],
+    sort: {
+      direction: SORTING_OPTIONS.desc,
+      key: "modified"
+    },
+    isLoading: void 0,
+    searchTerm: "",
+    searchTotal: 0,
+    selectedTags: [],
+    total: 0,
+    type: ""
+  }),
+  tags: [],
+  updateTypes: [],
+  /*
+   * Return single release with corresponding Artifacts
+   */
+  selectedRelease: null
+};
+var releaseSlice = (0, import_toolkit7.createSlice)({
+  name: sliceName7,
+  initialState: initialState7,
+  reducers: {
+    receiveRelease: (state, action) => {
+      const { name } = action.payload;
+      state.byId[name] = action.payload;
+    },
+    receiveReleases: (state, action) => {
+      state.byId = action.payload;
+    },
+    receiveReleaseTags: (state, action) => {
+      state.tags = action.payload;
+    },
+    receiveReleaseTypes: (state, action) => {
+      state.updateTypes = action.payload;
+    },
+    removeRelease: (state, action) => {
+      var _a;
+      const _b = state.byId, { [_a = action.payload]: toBeRemoved } = _b, byId = __objRest(_b, [__restKey(_a)]);
+      state.byId = byId;
+      state.selectedRelease = action.payload === state.selectedRelease ? null : state.selectedRelease;
+    },
+    selectedRelease: (state, action) => {
+      state.selectedRelease = action.payload;
+    },
+    setReleaseListState: (state, action) => {
+      state.releasesList = action.payload;
+    }
+  }
+});
+var actions7 = releaseSlice.actions;
+var releasesSlice_default = releaseSlice.reducer;
+
+// src/usersSlice/index.ts
+var import_toolkit8 = require("@reduxjs/toolkit");
+var sliceName8 = "users";
+var initialState8 = {
+  activationCode: void 0,
+  byId: {},
+  currentUser: null,
+  currentSession: {
+    // { token: window.localStorage.getItem('JWT'), expiresAt: '2023-01-01T00:15:00.000Z' | undefined }, // expiresAt depending on the stay logged in setting
+  },
+  customColumns: [],
+  qrCode: null,
+  globalSettings: {
+    id_attribute: void 0,
+    previousFilters: [],
+    previousPhases: [],
+    retries: 0
+  },
+  permissionSetsById: __spreadValues({}, defaultPermissionSets),
+  rolesById: __spreadValues({}, rolesById),
+  settingsInitialized: false,
+  showConnectDeviceDialog: false,
+  showFeedbackDialog: false,
+  showStartupNotification: false,
+  tooltips: {
+    byId: {
+      // <id>: { readState: <read|unread> } // this object is getting enhanced by the tooltip texts in the app constants
+    }
+  },
+  userSettings: {
+    columnSelection: [],
+    onboarding: {}
+  },
+  userSettingsInitialized: false
+};
+var usersSlice = (0, import_toolkit8.createSlice)({
+  name: sliceName8,
+  initialState: initialState8,
+  reducers: {
+    receivedQrCode: (state, action) => {
+      state.qrCode = action.payload;
+    },
+    successfullyLoggedIn: (state, action) => {
+      state.currentSession = action.payload;
+    },
+    receivedUserList: (state, action) => {
+      state.byId = action.payload;
+    },
+    receivedActivationCode: (state, action) => {
+      state.activationCode = action.payload;
+    },
+    receivedUser: (state, action) => {
+      state.byId[action.payload.id] = action.payload;
+      state.currentUser = action.payload.id;
+    },
+    createdUser: (state, action) => {
+      state.byId[0] = action.payload;
+    },
+    removedUser: (state, action) => {
+      var _a;
+      const _b = state.byId, { [_a = action.payload]: removedUser } = _b, byId = __objRest(_b, [__restKey(_a)]);
+      state.byId = byId;
+      state.currentUser = state.currentUser === action.payload ? null : state.currentUser;
+    },
+    updatedUser: (state, action) => {
+      state.byId[action.payload.id] = __spreadValues(__spreadValues({}, state.byId[action.payload.id]), action.payload);
+    },
+    receivedPermissionSets: (state, action) => {
+      state.permissionSetsById = action.payload;
+    },
+    receivedRoles: (state, action) => {
+      state.rolesById = action.payload;
+    },
+    createdRole: (state, action) => {
+      state.rolesById[action.payload.name] = __spreadValues(__spreadValues({}, state.rolesById[action.payload.name]), action.payload);
+    },
+    removedRole: (state, action) => {
+      var _a;
+      const _b = state.rolesById, { [_a = action.payload]: toBeRemoved } = _b, rolesById2 = __objRest(_b, [__restKey(_a)]);
+      state.rolesById = rolesById2;
+    },
+    setCustomColumns: (state, action) => {
+      state.customColumns = action.payload;
+    },
+    setGlobalSettings: (state, action) => {
+      state.settingsInitialized = true;
+      state.globalSettings = __spreadValues(__spreadValues({}, state.globalSettings), action.payload);
+    },
+    setUserSettings: (state, action) => {
+      state.userSettingsInitialized = true;
+      state.userSettings = __spreadValues(__spreadValues({}, state.userSettings), action.payload);
+    },
+    setTooltipState: (state, action) => {
+      const { id, readState = READ_STATES.read } = action.payload;
+      state.tooltips.byId[id].readState = readState;
+    },
+    setTooltipsState: (state, action) => {
+      state.tooltips.byId = __spreadValues(__spreadValues({}, state.tooltips.byId), action.payload);
+    },
+    setShowFeedbackDialog: (state, action) => {
+      state.showFeedbackDialog = action.payload;
+    },
+    setShowConnectingDialog: (state, action) => {
+      state.showConnectDeviceDialog = action.payload;
+    },
+    setShowStartupNotification: (state, action) => {
+      state.showStartupNotification = action.payload;
+    }
+  }
+});
+var actions8 = usersSlice.actions;
+var usersSlice_default = usersSlice.reducer;
+
+// src/actions.ts
+var actions_default = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, actions), actions2), actions3), actions4), actions5), actions6), actions7), actions8);
+//# sourceMappingURL=actions.js.map