@northern.tech/store 0.1.2 → 0.1.3

package/dist/api/users-api.js

@@ -0,0 +1,1026 @@
+"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 __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/api/users-api.ts
+var users_api_exports = {};
+__export(users_api_exports, {
+  default: () => users_api_default
+});
+module.exports = __toCommonJS(users_api_exports);
+var import_axios2 = __toESM(require("axios"));
+
+// src/auth.ts
+var import_universal_cookie = __toESM(require("universal-cookie"));
+
+// 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 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/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 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 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",
+  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}/.*` } }
+});
+
+// src/auth.ts
+var cookies = new import_universal_cookie.default();
+var emptySession = Object.freeze({ token: "", exiresAt: void 0 });
+var tokenCache = "";
+var getSessionInfo = () => {
+  var _a, _b;
+  let sessionInfo = __spreadValues({}, emptySession);
+  try {
+    sessionInfo = JSON.parse((_a = window.localStorage.getItem("JWT")) != null ? _a : "");
+  } catch (e) {
+  }
+  if (sessionInfo.expiresAt && new Date(sessionInfo.expiresAt) < /* @__PURE__ */ new Date()) {
+    cleanUp();
+    return __spreadValues({}, emptySession);
+  }
+  if (!sessionInfo.token) {
+    let jwtTokenFromCookie = (_b = cookies.get("JWT", { doNotParse: true })) != null ? _b : "";
+    if (jwtTokenFromCookie) {
+      setSessionInfo({ token: jwtTokenFromCookie, undefined: void 0 });
+      sessionInfo.token = jwtTokenFromCookie;
+      cookies.remove("JWT");
+      cookies.remove("JWT", { path: "/" });
+    }
+  }
+  sessionInfo.token = sessionInfo.token || void 0;
+  tokenCache = sessionInfo.token;
+  return sessionInfo;
+};
+var getToken = () => tokenCache ? tokenCache : getSessionInfo().token;
+var setSessionInfo = ({ token, expiresAt }) => {
+  tokenCache = token;
+  window.localStorage.setItem("JWT", JSON.stringify({ token, expiresAt }));
+};
+var cleanUp = () => {
+  tokenCache = "";
+  cookies.remove("JWT");
+  cookies.remove("JWT", { path: "/" });
+  window.localStorage.removeItem("JWT");
+  window.localStorage.removeItem("oauth");
+};
+
+// src/api/general-api.ts
+var import_axios = __toESM(require("axios"));
+var unauthorizedRedirect = (error) => {
+  var _a;
+  if (!(0, import_axios.isCancel)(error) && ((_a = error.response) == null ? void 0 : _a.status) === 401 && getToken()) {
+    cleanUp();
+    window.location.replace("/ui/");
+  }
+  return Promise.reject(error);
+};
+var commonRequestConfig = { timeout: TIMEOUTS.refreshDefault, headers: { "Content-Type": "application/json" } };
+var authenticatedRequest = import_axios.default.create(commonRequestConfig);
+authenticatedRequest.interceptors.response.use((res) => res, unauthorizedRedirect);
+authenticatedRequest.interceptors.request.use(
+  (config) => __spreadProps(__spreadValues({}, config), { headers: __spreadProps(__spreadValues({}, config.headers), { Authorization: `Bearer ${getToken()}` }) }),
+  (error) => Promise.reject(error)
+);
+var Api = {
+  get: authenticatedRequest.get,
+  delete: (url, data) => authenticatedRequest.request({ method: "delete", url, data }),
+  patch: authenticatedRequest.patch,
+  post: authenticatedRequest.post,
+  postUnauthorized: (url, data, config = {}) => import_axios.default.post(url, data, __spreadValues(__spreadValues({}, commonRequestConfig), config)),
+  put: authenticatedRequest.put,
+  upload: (url, formData, progress, cancelSignal) => authenticatedRequest.post(url, formData, {
+    headers: { "Content-Type": "multipart/form-data" },
+    onUploadProgress: progress,
+    timeout: 0,
+    signal: cancelSignal
+  }),
+  uploadPut: (url, formData, progress, cancelSignal) => authenticatedRequest.put(url, formData, {
+    headers: { "Content-Type": "multipart/form-data" },
+    onUploadProgress: progress,
+    timeout: 0,
+    signal: cancelSignal
+  })
+};
+
+// src/api/users-api.ts
+var Api2 = {
+  postLogin: (url, _a) => {
+    var _b = _a, { email: username, password } = _b, body = __objRest(_b, ["email", "password"]);
+    return import_axios2.default.post(url, body, __spreadProps(__spreadValues({}, commonRequestConfig), { auth: { username, password } })).then((res) => {
+      var _a2;
+      return { text: res.data, code: res.status, contentType: (_a2 = res.headers) == null ? void 0 : _a2["content-type"] };
+    });
+  },
+  putVerifyTFA: (url, userData) => {
+    let body = {};
+    if (userData.hasOwnProperty("token2fa")) {
+      body = { token2fa: userData.token2fa };
+    }
+    return import_axios2.default.put(url, body, __spreadProps(__spreadValues({}, commonRequestConfig), { headers: __spreadProps(__spreadValues({}, commonRequestConfig.headers), { Authorization: `Bearer ${getToken()}` }) }));
+  }
+};
+var users_api_default = Api2;
+//# sourceMappingURL=users-api.js.map