@overmap-ai/core 1.0.65-asset-models-improvements.3 → 1.0.65-error-message-fix.0

package/dist/overmap-core.js

@@ -7,20 +7,20 @@ var __publicField = (obj, key, value) => {
 var _a;
 import { DepGraph } from "dependency-graph";
 import { v4 } from "uuid";
-import { saveAs } from "file-saver";
-import React, { useRef, useEffect } from "react";
-import ColorCls from "color";
-import { gray, gold, brown, yellow, amber, orange, red, crimson, pink, plum, purple, violet, iris, indigo, blue, cyan, jade, grass, lime, mint, sky } from "@radix-ui/colors";
 import { offline as offline$1 } from "@redux-offline/redux-offline";
 import offlineConfig from "@redux-offline/redux-offline/lib/defaults";
 import localforage from "localforage";
 import createMigration from "redux-persist-migrate";
 import { createSlice, createSelector, combineReducers, createNextState } from "@reduxjs/toolkit";
 import request from "superagent";
+import { saveAs } from "file-saver";
+import React, { useRef, useEffect } from "react";
+import ColorCls from "color";
+import { gray, gold, brown, yellow, amber, orange, red, crimson, pink, plum, purple, violet, iris, indigo, blue, cyan, jade, grass, lime, mint, sky } from "@radix-ui/colors";
 import { RESET_STATE } from "@redux-offline/redux-offline/lib/constants";
 import jwtDecode from "jwt-decode";
-import { openDB } from "idb";
 import { unsafeShowToast } from "@overmap-ai/blocks";
+import { openDB } from "idb";
 var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
   HttpMethod2["GET"] = "GET";
   HttpMethod2["POST"] = "POST";
@@ -29,14 +29,6 @@ var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
   HttpMethod2["DELETE"] = "DELETE";
   return HttpMethod2;
 })(HttpMethod || {});
-var AttachmentModel = /* @__PURE__ */ ((AttachmentModel2) => {
-  AttachmentModel2["Issue"] = "issue";
-  AttachmentModel2["Asset"] = "asset";
-  AttachmentModel2["AssetType"] = "asset_type";
-  AttachmentModel2["Project"] = "project";
-  AttachmentModel2["Document"] = "document";
-  return AttachmentModel2;
-})(AttachmentModel || {});
 var IssuePriority = /* @__PURE__ */ ((IssuePriority2) => {
   IssuePriority2[IssuePriority2["LOWEST"] = 0] = "LOWEST";
   IssuePriority2[IssuePriority2["LOW"] = 2] = "LOW";
@@ -51,43 +43,6 @@ var IssueStatus = /* @__PURE__ */ ((IssueStatus2) => {
   IssueStatus2[IssueStatus2["DONE"] = 4] = "DONE";
   return IssueStatus2;
 })(IssueStatus || {});
-var IssueUpdateChange = /* @__PURE__ */ ((IssueUpdateChange2) => {
-  IssueUpdateChange2["STATUS"] = "status";
-  IssueUpdateChange2["PRIORITY"] = "priority";
-  IssueUpdateChange2["CATEGORY"] = "category";
-  IssueUpdateChange2["DESCRIPTION"] = "description";
-  IssueUpdateChange2["TITLE"] = "title";
-  IssueUpdateChange2["ASSIGNED_TO"] = "assigned_to";
-  IssueUpdateChange2["DUE_DATE"] = "due_date";
-  return IssueUpdateChange2;
-})(IssueUpdateChange || {});
-var ProjectAccessLevel = /* @__PURE__ */ ((ProjectAccessLevel2) => {
-  ProjectAccessLevel2[ProjectAccessLevel2["BASIC"] = 0] = "BASIC";
-  ProjectAccessLevel2[ProjectAccessLevel2["ADMIN"] = 2] = "ADMIN";
-  return ProjectAccessLevel2;
-})(ProjectAccessLevel || {});
-var OrganizationAccessLevel = /* @__PURE__ */ ((OrganizationAccessLevel2) => {
-  OrganizationAccessLevel2[OrganizationAccessLevel2["BASIC"] = 0] = "BASIC";
-  OrganizationAccessLevel2[OrganizationAccessLevel2["ADMIN"] = 2] = "ADMIN";
-  return OrganizationAccessLevel2;
-})(OrganizationAccessLevel || {});
-var PaddleCheckoutEvent = /* @__PURE__ */ ((PaddleCheckoutEvent2) => {
-  PaddleCheckoutEvent2["COMPLETED"] = "checkout.completed";
-  PaddleCheckoutEvent2["CLOSED"] = "checkout.closed";
-  return PaddleCheckoutEvent2;
-})(PaddleCheckoutEvent || {});
-var LicenseLevel = /* @__PURE__ */ ((LicenseLevel2) => {
-  LicenseLevel2[LicenseLevel2["PRO"] = 0] = "PRO";
-  return LicenseLevel2;
-})(LicenseLevel || {});
-var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
-  LicenseStatus2[LicenseStatus2["ACTIVE"] = 0] = "ACTIVE";
-  LicenseStatus2[LicenseStatus2["PAUSED"] = 2] = "PAUSED";
-  LicenseStatus2[LicenseStatus2["CANCELLED"] = 4] = "CANCELLED";
-  LicenseStatus2[LicenseStatus2["INACTIVE"] = 6] = "INACTIVE";
-  LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
-  return LicenseStatus2;
-})(LicenseStatus || {});
 class OutboxCoordinator {
   constructor() {
     __publicField(this, "graph");
@@ -274,13 +229,16 @@ const UNKNOWN_ERROR_MESSAGE = "An unknown error occurred";
 const MAX_ERROR_MESSAGE_LENGTH = 500;
 const _SPECIAL_KEYS = ["non_field_errors", "detail"];
 function extractErrorMessage(errorRes, err) {
+  console.debug("extracting error message from response", errorRes, err);
   let ret;
   if (errorRes == null ? void 0 : errorRes.body) {
     if (typeof errorRes.body === "object") {
       const responseBody = errorRes.body;
       if (typeof responseBody.error === "string") {
+        console.debug("body.error is string", responseBody.error);
         ret = responseBody.error;
       } else if (typeof responseBody.message === "string") {
+        console.debug("body.message is string", responseBody.message);
         ret = responseBody.message;
       } else if (responseBody.body) {
         try {
@@ -297,11 +255,13 @@ function extractErrorMessage(errorRes, err) {
             }
             return `${key}: ${JSON.stringify(value)}`;
           }).join("\n");
+          console.debug("parsing error body", ret);
         } catch (e) {
           console.error("Failed to extract error message from response body", e);
         }
       }
     } else if (typeof errorRes.body === "string") {
+      console.debug("error body is string", errorRes.body);
       ret = errorRes.body;
     }
   } else if (errorRes == null ? void 0 : errorRes.text) {
@@ -330,6 +290,130 @@ class APIError extends Error {
     this.options = options;
   }
 }
+class DeferredPromise {
+  constructor() {
+    __publicField(this, _a, "Promise");
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    __publicField(this, "_state", "pending");
+    this._resolve = null;
+    this._reject = null;
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  then(onFulfilled, onRejected) {
+    return this._promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this._promise.catch(onRejected);
+  }
+  resolve(value) {
+    if (!this._resolve)
+      throw new Error("No resolve callback");
+    this._resolve(value);
+    this._state = "fulfilled";
+  }
+  reject(reason) {
+    if (!this._reject)
+      throw reason;
+    this._reject(reason);
+    this._state = "rejected";
+  }
+  finally(_onFinally) {
+    throw new Error("`finally` not implemented");
+  }
+}
+_a = Symbol.toStringTag;
+var randomString = function randomString2() {
+  return Math.random().toString(36).substring(7).split("").join(".");
+};
+({
+  INIT: "@@redux/INIT" + randomString(),
+  REPLACE: "@@redux/REPLACE" + randomString(),
+  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
+    return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
+  }
+});
+function compose() {
+  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
+    funcs[_key] = arguments[_key];
+  }
+  if (funcs.length === 0) {
+    return function(arg) {
+      return arg;
+    };
+  }
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce(function(a, b) {
+    return function() {
+      return a(b.apply(void 0, arguments));
+    };
+  });
+}
+const VERSION_REDUCER_KEY$1 = "versioning";
+const latestVersion = () => migrations.length - 1;
+const initialVersioning = (state) => {
+  state[VERSION_REDUCER_KEY$1] = { version: latestVersion() };
+  return state;
+};
+const signOut = () => {
+  return initialVersioning({});
+};
+const createOutboxState = (state) => {
+  if (state.outboxReducer) {
+    state.outboxReducer.deletedRequests = [];
+  }
+  return state;
+};
+const wrapMigration = (migrator) => (state) => {
+  var _a2;
+  if (state === void 0) {
+    state = {};
+  }
+  if (((_a2 = state[VERSION_REDUCER_KEY$1]) == null ? void 0 : _a2.version) === latestVersion())
+    return state;
+  return migrator(state);
+};
+const migrations = [initialVersioning, signOut, signOut, createOutboxState];
+const manifest = Object.fromEntries(migrations.map((migration2, i) => [i, wrapMigration(migration2)]));
+const initialState$B = {
+  accessToken: "",
+  refreshToken: "",
+  isLoggedIn: false
+};
+const authSlice = createSlice({
+  name: "auth",
+  initialState: initialState$B,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
+  reducers: {
+    setTokens: (state, action) => {
+      state.accessToken = action.payload.accessToken;
+      state.refreshToken = action.payload.refreshToken;
+    },
+    clearTokens: (state) => {
+      state.accessToken = "";
+      state.refreshToken = "";
+    },
+    setLoggedIn: (state, action) => {
+      if (!action.payload) {
+        authSlice.caseReducers.clearTokens(state);
+      }
+      state.isLoggedIn = action.payload;
+    }
+  }
+});
+const { setTokens, clearTokens, setLoggedIn } = authSlice.actions;
+const selectAccessToken = (state) => state.authReducer.accessToken;
+const selectIsLoggedIn = (state) => state.authReducer.isLoggedIn;
+const authReducer = authSlice.reducer;
 const coordinatesToLiteral = (coordinates) => {
   return { lng: coordinates[0], lat: coordinates[1] };
 };
@@ -674,6 +758,19 @@ const Colors = {
   mint: mint.mint9,
   sky: sky.sky9
 };
+const AssetStageColors = {
+  indigo: indigo.indigo9,
+  red: red.red9,
+  violet: violet.violet9,
+  yellow: yellow.yellow9,
+  jade: jade.jade9,
+  cyan: cyan.cyan9,
+  gold: gold.gold9,
+  orange: orange.orange9,
+  lime: lime.lime9,
+  sky: sky.sky9,
+  pink: pink.pink9
+};
 const defaultBadgeColor = "#868686";
 const generateBadgeColors = (rawColor) => {
   const color = ColorCls(rawColor);
@@ -682,6 +779,9 @@ const generateBadgeColors = (rawColor) => {
   const textColor = color.hex() === safety.hex() ? "#000000" : "#FFFFFF";
   return { backgroundColor, textColor };
 };
+function getStageColor(index) {
+  return Object.values(AssetStageColors)[index % Object.keys(AssetStageColors).length];
+}
 const getLocalDateString = memoize((date) => {
   if (!date)
     return "";
@@ -704,130 +804,6 @@ const getLocalRelativeDateString = memoize((date, min, max) => {
     return getLocalDateString(date);
   return relative.format(days, "days");
 });
-class DeferredPromise {
-  constructor() {
-    __publicField(this, _a, "Promise");
-    __publicField(this, "_promise");
-    __publicField(this, "_resolve");
-    __publicField(this, "_reject");
-    __publicField(this, "_state", "pending");
-    this._resolve = null;
-    this._reject = null;
-    this._promise = new Promise((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
-    });
-  }
-  get state() {
-    return this._state;
-  }
-  then(onFulfilled, onRejected) {
-    return this._promise.then(onFulfilled, onRejected);
-  }
-  catch(onRejected) {
-    return this._promise.catch(onRejected);
-  }
-  resolve(value) {
-    if (!this._resolve)
-      throw new Error("No resolve callback");
-    this._resolve(value);
-    this._state = "fulfilled";
-  }
-  reject(reason) {
-    if (!this._reject)
-      throw reason;
-    this._reject(reason);
-    this._state = "rejected";
-  }
-  finally(_onFinally) {
-    throw new Error("`finally` not implemented");
-  }
-}
-_a = Symbol.toStringTag;
-var randomString = function randomString2() {
-  return Math.random().toString(36).substring(7).split("").join(".");
-};
-({
-  INIT: "@@redux/INIT" + randomString(),
-  REPLACE: "@@redux/REPLACE" + randomString(),
-  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
-    return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
-  }
-});
-function compose() {
-  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
-    funcs[_key] = arguments[_key];
-  }
-  if (funcs.length === 0) {
-    return function(arg) {
-      return arg;
-    };
-  }
-  if (funcs.length === 1) {
-    return funcs[0];
-  }
-  return funcs.reduce(function(a, b) {
-    return function() {
-      return a(b.apply(void 0, arguments));
-    };
-  });
-}
-const VERSION_REDUCER_KEY$1 = "versioning";
-const latestVersion = () => migrations.length - 1;
-const initialVersioning = (state) => {
-  state[VERSION_REDUCER_KEY$1] = { version: latestVersion() };
-  return state;
-};
-const signOut = () => {
-  return initialVersioning({});
-};
-const createOutboxState = (state) => {
-  if (state.outboxReducer) {
-    state.outboxReducer.deletedRequests = [];
-  }
-  return state;
-};
-const wrapMigration = (migrator) => (state) => {
-  var _a2;
-  if (state === void 0) {
-    state = {};
-  }
-  if (((_a2 = state[VERSION_REDUCER_KEY$1]) == null ? void 0 : _a2.version) === latestVersion())
-    return state;
-  return migrator(state);
-};
-const migrations = [initialVersioning, signOut, signOut, createOutboxState];
-const manifest = Object.fromEntries(migrations.map((migration2, i) => [i, wrapMigration(migration2)]));
-const initialState$B = {
-  accessToken: "",
-  refreshToken: "",
-  isLoggedIn: false
-};
-const authSlice = createSlice({
-  name: "auth",
-  initialState: initialState$B,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
-  reducers: {
-    setTokens: (state, action) => {
-      state.accessToken = action.payload.accessToken;
-      state.refreshToken = action.payload.refreshToken;
-    },
-    clearTokens: (state) => {
-      state.accessToken = "";
-      state.refreshToken = "";
-    },
-    setLoggedIn: (state, action) => {
-      if (!action.payload) {
-        authSlice.caseReducers.clearTokens(state);
-      }
-      state.isLoggedIn = action.payload;
-    }
-  }
-});
-const { setTokens, clearTokens, setLoggedIn } = authSlice.actions;
-const selectAccessToken = (state) => state.authReducer.accessToken;
-const selectIsLoggedIn = (state) => state.authReducer.isLoggedIn;
-const authReducer = authSlice.reducer;
 function createModelAdapter(computeModelId) {
   const addOne = (state, action) => {
     const id = computeModelId(action.payload);
@@ -1057,75 +1033,64 @@ const selectAttachmentsOfAssetByType = restructureCreateSelectorWithArgs(
       );
       return { fileAttachments, imageAttachments };
     }
-  )
-);
-const assetAttachmentReducer = assetAttachmentSlice.reducer;
-const assetStageCompletionAdapter = createModelAdapter(
-  (stageCompletion) => stageCompletion.offline_id
-);
-const initialState$x = assetStageCompletionAdapter.getInitialState({});
-const assetStageCompletionSlice = createSlice({
-  name: "assetStageCompletions",
-  initialState: initialState$x,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
-  reducers: {
-    initializeAssetStageCompletions: assetStageCompletionAdapter.initialize,
-    addAssetStageCompletion: assetStageCompletionAdapter.addOne,
-    addAssetStageCompletions: assetStageCompletionAdapter.addMany,
-    updateAssetStageCompletion: assetStageCompletionAdapter.updateOne,
-    updateAssetStageCompletions: assetStageCompletionAdapter.updateMany,
-    deleteAssetStageCompletion: assetStageCompletionAdapter.deleteOne,
-    deleteAssetStageCompletions: assetStageCompletionAdapter.deleteMany
+  )
+);
+const assetAttachmentReducer = assetAttachmentSlice.reducer;
+const initialState$x = {
+  completionsByAssetId: {}
+};
+const assetStageCompletionSlice = createSlice({
+  name: "assetStageCompletions",
+  initialState: initialState$x,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
+  reducers: {
+    addStageCompletion: (state, action) => {
+      let stageToCompletionDateMapping = state.completionsByAssetId[action.payload.asset];
+      if (!stageToCompletionDateMapping) {
+        stageToCompletionDateMapping = {};
+        state.completionsByAssetId[action.payload.asset] = stageToCompletionDateMapping;
+      }
+      stageToCompletionDateMapping[action.payload.stage] = (/* @__PURE__ */ new Date()).toISOString();
+    },
+    addStageCompletions: (state, action) => {
+      for (const [assetId, stageIdToCompletionDateMapping] of Object.entries(action.payload)) {
+        if (Object.keys(stageIdToCompletionDateMapping).length === 0)
+          throw new Error(`Encountered empty stageIdToCompletionDateMapping argument for asset ${assetId}`);
+        let thisAssetCompletions = state.completionsByAssetId[assetId];
+        if (thisAssetCompletions === void 0) {
+          thisAssetCompletions = {};
+        }
+        for (const [stageId, completionDate] of Object.entries(stageIdToCompletionDateMapping)) {
+          thisAssetCompletions[stageId] = completionDate;
+        }
+        state.completionsByAssetId[assetId] = thisAssetCompletions;
+      }
+    },
+    removeStageCompletions: (state, action) => {
+      for (const completion of action.payload) {
+        const thisAssetCompletions = state.completionsByAssetId[completion.asset];
+        if (!thisAssetCompletions || !(completion.stage in thisAssetCompletions)) {
+          console.warn(
+            "Skipping removal of uncompleted stage. This message indicates completion objects are created unnecessarily."
+          );
+          continue;
+        }
+        delete thisAssetCompletions[completion.stage];
+      }
+    },
+    setStageCompletions: (state, action) => {
+      state.completionsByAssetId = action.payload;
+    }
   }
 });
-const {
-  initializeAssetStageCompletions,
-  addAssetStageCompletion,
-  addAssetStageCompletions,
-  updateAssetStageCompletion,
-  updateAssetStageCompletions,
-  deleteAssetStageCompletion,
-  deleteAssetStageCompletions
-} = assetStageCompletionSlice.actions;
-const selectAssetStageCompletionMapping = (state) => {
-  return state.assetStageCompletionReducer.instances;
+const { addStageCompletion, addStageCompletions, removeStageCompletions, setStageCompletions } = assetStageCompletionSlice.actions;
+const selectCompletedStages = (state) => {
+  return state.assetStageCompletionReducer.completionsByAssetId;
 };
-const selectCompletedStagesByAsset = createSelector(
-  [selectAssetStageCompletionMapping],
-  (completedStagesMapping) => {
-    const completedStagesByAsset = {};
-    for (const stageCompletion of Object.values(completedStagesMapping)) {
-      const { asset, stage, submitted_at } = stageCompletion;
-      if (!completedStagesByAsset[asset])
-        completedStagesByAsset[asset] = {};
-      completedStagesByAsset[asset][stage] = submitted_at;
-    }
-    return completedStagesByAsset;
-  }
-);
 const selectCompletedStageIdsForAsset = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAssetStageCompletionMapping, (_state, asset) => asset],
-    (completedStages, asset) => {
-      return Object.keys(completedStages[asset.offline_id] ?? {});
-    }
-  )
-);
-const selectAssetStageCompletionById = (id) => (state) => {
-  return state.assetStageCompletionReducer.instances[id];
-};
-const selectAssetStageCompletionsByIds = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAssetStageCompletionMapping, (_, stageCompletionIds) => stageCompletionIds],
-    (stageCompletionMapping, stageCompletionIds) => {
-      const stageCompletionIdsSet = new Set(stageCompletionIds);
-      return fallbackToEmptyArray(
-        Object.values(stageCompletionMapping).filter(
-          (stageCompletion) => stageCompletionIdsSet.has(stageCompletion.offline_id)
-        )
-      );
-    }
-  )
+  createSelector([selectCompletedStages, (_state, asset) => asset], (completedStages, asset) => {
+    return Object.keys(completedStages[asset.offline_id] ?? {});
+  })
 );
 const assetStageCompletionReducer = assetStageCompletionSlice.reducer;
 const assetStageAdapter = createModelAdapter((assetStage) => assetStage.offline_id);
@@ -1135,29 +1100,14 @@ const assetStageSlice = createSlice({
   initialState: initialState$w,
   extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
   reducers: {
-    initializeAssetStages: assetStageAdapter.initialize,
-    setAssetStage: assetStageAdapter.setOne,
-    setAssetStages: assetStageAdapter.setMany,
-    addAssetStage: assetStageAdapter.addOne,
-    addAssetStages: assetStageAdapter.addMany,
-    updateAssetStage: assetStageAdapter.updateOne,
-    updateAssetStages: assetStageAdapter.updateMany,
-    deleteAssetStage: assetStageAdapter.deleteOne,
-    deleteAssetStages: assetStageAdapter.deleteMany
+    initializeStages: assetStageAdapter.initialize,
+    setStage: assetStageAdapter.setOne,
+    addStages: assetStageAdapter.addMany,
+    updateStage: assetStageAdapter.updateOne,
+    updateStages: assetStageAdapter.updateMany,
+    removeStages: assetStageAdapter.deleteMany
   }
 });
-const {
-  initializeAssetStages,
-  setAssetStage,
-  setAssetStages,
-  addAssetStage,
-  addAssetStages,
-  updateAssetStage,
-  updateAssetStages,
-  deleteAssetStage,
-  deleteAssetStages
-} = assetStageSlice.actions;
-const assetStageReducer = assetStageSlice.reducer;
 const selectStageMapping = (state) => state.assetStageReducer.instances;
 const selectAssetStageById = (id) => (state) => {
   return state.assetStageReducer.instances[id];
@@ -1165,6 +1115,24 @@ const selectAssetStageById = (id) => (state) => {
 const selectAssetStages = createSelector([selectStageMapping], (stageMapping) => {
   return Object.values(stageMapping);
 });
+const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
+  createSelector([selectAssetStages, (_state, assetTypeIds) => assetTypeIds], (stages, assetTypeIds) => {
+    const assetTypeIdsSet = new Set(assetTypeIds);
+    const ret = {};
+    for (const stage of stages) {
+      if (assetTypeIdsSet.has(stage.asset_type)) {
+        if (!ret[stage.asset_type]) {
+          ret[stage.asset_type] = [];
+        }
+        ret[stage.asset_type].push(stage);
+      }
+    }
+    for (const key in ret) {
+      ret[key] = ret[key].sort((a, b) => a.priority - b.priority);
+    }
+    return ret;
+  })
+);
 const selectAssetTypeStagesMapping = restructureCreateSelectorWithArgs(
   createSelector([selectStageMapping, (_state, assetTypeId) => assetTypeId], (stagesMapping, assetTypeId) => {
     const assetTypeStagesMapping = {};
@@ -1212,6 +1180,8 @@ const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
     return ret;
   })
 );
+const { initializeStages, setStage, addStages, updateStages, removeStages, updateStage } = assetStageSlice.actions;
+const assetStageReducer = assetStageSlice.reducer;
 const assetTypeAdapter = createModelAdapter((assetType) => assetType.offline_id);
 const initialState$v = assetTypeAdapter.getInitialState({});
 const assetTypeSlice = createSlice({
@@ -1220,27 +1190,11 @@ const assetTypeSlice = createSlice({
   extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
   reducers: {
     initializeAssetTypes: assetTypeAdapter.initialize,
-    setAssetType: assetTypeAdapter.setOne,
-    setAssetTypes: assetTypeAdapter.setMany,
     addAssetType: assetTypeAdapter.addOne,
-    addAssetTypes: assetTypeAdapter.addMany,
-    updateAssetType: assetTypeAdapter.updateOne,
-    updateAssetTypes: assetTypeAdapter.updateMany,
-    deleteAssetType: assetTypeAdapter.deleteOne,
-    deleteAssetTypes: assetTypeAdapter.deleteMany
+    deleteAssetType: assetTypeAdapter.deleteOne
   }
 });
-const {
-  initializeAssetTypes,
-  setAssetType,
-  setAssetTypes,
-  addAssetType,
-  addAssetTypes,
-  updateAssetType,
-  updateAssetTypes,
-  deleteAssetType,
-  deleteAssetTypes
-} = assetTypeSlice.actions;
+const { addAssetType, initializeAssetTypes, deleteAssetType } = assetTypeSlice.actions;
 const selectAssetTypesMapping = (state) => state.assetTypeReducer.instances;
 const selectAssetTypes = createSelector(
   [selectAssetTypesMapping],
@@ -1628,6 +1582,60 @@ const selectUploadUrl = (sha1) => (state) => {
   return url;
 };
 const fileReducer = fileSlice.reducer;
+var ProjectAccessLevel = /* @__PURE__ */ ((ProjectAccessLevel2) => {
+  ProjectAccessLevel2[ProjectAccessLevel2["BASIC"] = 0] = "BASIC";
+  ProjectAccessLevel2[ProjectAccessLevel2["ADMIN"] = 2] = "ADMIN";
+  return ProjectAccessLevel2;
+})(ProjectAccessLevel || {});
+var OrganizationAccessLevel = /* @__PURE__ */ ((OrganizationAccessLevel2) => {
+  OrganizationAccessLevel2[OrganizationAccessLevel2["BASIC"] = 0] = "BASIC";
+  OrganizationAccessLevel2[OrganizationAccessLevel2["ADMIN"] = 2] = "ADMIN";
+  return OrganizationAccessLevel2;
+})(OrganizationAccessLevel || {});
+var AttachmentModel = /* @__PURE__ */ ((AttachmentModel2) => {
+  AttachmentModel2["Issue"] = "issue";
+  AttachmentModel2["Asset"] = "asset";
+  AttachmentModel2["AssetType"] = "asset_type";
+  AttachmentModel2["Project"] = "project";
+  AttachmentModel2["Document"] = "document";
+  return AttachmentModel2;
+})(AttachmentModel || {});
+var IssueUpdateChange = /* @__PURE__ */ ((IssueUpdateChange2) => {
+  IssueUpdateChange2["STATUS"] = "status";
+  IssueUpdateChange2["PRIORITY"] = "priority";
+  IssueUpdateChange2["CATEGORY"] = "category";
+  IssueUpdateChange2["DESCRIPTION"] = "description";
+  IssueUpdateChange2["TITLE"] = "title";
+  IssueUpdateChange2["ASSIGNED_TO"] = "assigned_to";
+  IssueUpdateChange2["DUE_DATE"] = "due_date";
+  return IssueUpdateChange2;
+})(IssueUpdateChange || {});
+var VerificationCodeType = /* @__PURE__ */ ((VerificationCodeType2) => {
+  VerificationCodeType2[VerificationCodeType2["USER_REGISTRATION"] = 0] = "USER_REGISTRATION";
+  VerificationCodeType2[VerificationCodeType2["APPLICATION_INVITE"] = 2] = "APPLICATION_INVITE";
+  VerificationCodeType2[VerificationCodeType2["PROJECT_INVITE"] = 4] = "PROJECT_INVITE";
+  VerificationCodeType2[VerificationCodeType2["ORGANIZATION_INVITE"] = 6] = "ORGANIZATION_INVITE";
+  VerificationCodeType2[VerificationCodeType2["ADD_EMAIL_DOMAIN"] = 8] = "ADD_EMAIL_DOMAIN";
+  VerificationCodeType2[VerificationCodeType2["RESET_PASSWORD"] = 10] = "RESET_PASSWORD";
+  return VerificationCodeType2;
+})(VerificationCodeType || {});
+var PaddleCheckoutEvent = /* @__PURE__ */ ((PaddleCheckoutEvent2) => {
+  PaddleCheckoutEvent2["COMPLETED"] = "checkout.completed";
+  PaddleCheckoutEvent2["CLOSED"] = "checkout.closed";
+  return PaddleCheckoutEvent2;
+})(PaddleCheckoutEvent || {});
+var LicenseLevel = /* @__PURE__ */ ((LicenseLevel2) => {
+  LicenseLevel2[LicenseLevel2["PRO"] = 0] = "PRO";
+  return LicenseLevel2;
+})(LicenseLevel || {});
+var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
+  LicenseStatus2[LicenseStatus2["ACTIVE"] = 0] = "ACTIVE";
+  LicenseStatus2[LicenseStatus2["PAUSED"] = 2] = "PAUSED";
+  LicenseStatus2[LicenseStatus2["CANCELLED"] = 4] = "CANCELLED";
+  LicenseStatus2[LicenseStatus2["INACTIVE"] = 6] = "INACTIVE";
+  LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
+  return LicenseStatus2;
+})(LicenseStatus || {});
 const initialState$p = {
   users: {},
   currentUser: {
@@ -4169,70 +4177,42 @@ function chunkArray(arr, chunkSize) {
 }
 class AssetService extends BaseApiService {
   // Basic CRUD functions
-  add(payload) {
-    const { store } = this.client;
-    if (!payload.canvas_marker && !payload.geo_marker) {
+  add(asset, workspaceId) {
+    if (!asset.canvas_marker && !asset.geo_marker) {
       throw new Error("Asset must have either a canvas_marker or geo_marker");
     }
-    const createdBy = store.getState().userReducer.currentUser.id;
-    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const offlineAsset = offline({
-      ...payload,
-      created_by: createdBy,
-      submitted_at: submittedAt
-    });
+    const offlineAsset = offline(asset);
     this.dispatch(addAsset(offlineAsset));
     const promise = this.enqueueRequest({
       description: "Create asset",
       method: HttpMethod.POST,
-      url: "/assets/",
-      payload: {
-        offline_id: offlineAsset.offline_id,
-        submitted_at: offlineAsset.submitted_at,
-        geo_marker: offlineAsset.geo_marker,
-        canvas_marker: offlineAsset.canvas_marker,
-        label: offlineAsset.label,
-        description: offlineAsset.description,
-        asset_type: offlineAsset.asset_type
+      url: `/assets/types/${offlineAsset.asset_type}/add-assets/`,
+      queryParams: {
+        workspace_id: workspaceId.toString()
       },
-      blockers: [offlineAsset.asset_type],
+      payload: { assets: [offlineAsset] },
+      blockers: [],
       blocks: [offlineAsset.offline_id]
     });
-    promise.then((createdAsset) => {
-      this.dispatch(updateAsset(createdAsset));
-    }).catch(() => {
-      this.dispatch(deleteAsset(offlineAsset.offline_id));
-    });
     return [offlineAsset, promise];
   }
-  update(payload) {
-    const { store } = this.client;
-    if (!payload.canvas_marker && !payload.geo_marker) {
+  update(asset, workspaceId) {
+    if (!asset.canvas_marker && !asset.geo_marker) {
       throw new Error("Asset must have either a canvas_marker or geo_marker");
     }
-    const asset = selectAssetById(payload.offline_id)(store.getState());
-    if (!asset) {
-      throw new Error(`No asset with id ${payload.offline_id} found in the store`);
-    }
-    const updatedAsset = {
-      ...asset,
-      ...payload
-    };
-    this.dispatch(updateAsset(updatedAsset));
+    this.client.store.dispatch(updateAsset(asset));
     const promise = this.enqueueRequest({
       description: "Edit asset",
       method: HttpMethod.PATCH,
-      url: `/assets/${payload.offline_id}/`,
-      payload,
-      blockers: [payload.offline_id],
-      blocks: [payload.offline_id]
-    });
-    promise.then((result) => {
-      this.dispatch(updateAsset(result));
-    }).catch(() => {
-      this.dispatch(updateAsset(asset));
+      url: `/assets/${asset.offline_id}/`,
+      queryParams: {
+        workspace_id: workspaceId.toString()
+      },
+      payload: asset,
+      blockers: [asset.offline_id],
+      blocks: [asset.offline_id]
     });
-    return [updatedAsset, promise];
+    return [asset, promise];
   }
   async remove(assetId) {
     const { store } = this.client;
@@ -4270,17 +4250,39 @@ class AssetService extends BaseApiService {
       throw err;
     });
   }
-  bulkAdd(payloads, assetTypeId, batchSize) {
+  async deleteAllAssetsOfAssetType(assetTypeId) {
+    const { store } = this.client;
+    const state = store.getState();
+    const allAssetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state);
+    const allAssetsOfAssetTypeIds = allAssetsOfAssetType.map((c) => c.offline_id);
+    const affectedOfflineIds = [assetTypeId, ...allAssetsOfAssetTypeIds];
+    store.dispatch(deleteAssets(allAssetsOfAssetTypeIds));
+    return this.enqueueRequest({
+      description: "Delete all assets of asset type",
+      method: HttpMethod.DELETE,
+      url: `/assets/types/${assetTypeId}/delete-all-of-type/`,
+      blockers: affectedOfflineIds,
+      blocks: affectedOfflineIds
+    }).catch((err) => {
+      store.dispatch(addAssets(allAssetsOfAssetType));
+      throw err;
+    });
+  }
+  // TODO: payload does not require asset_type
+  bulkAdd(assetsToCreate, workspaceId, assetTypeId, batchSize) {
     const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
     const transactionId = v4();
-    const assetBatches = chunkArray(payloads, batchSize).map((assetBatch) => {
-      const assetPayloads = assetBatch.map((assetPayload) => offline(assetPayload));
+    const assetBatches = chunkArray(assetsToCreate, batchSize).map((assetBatch) => {
+      const assetPayloads = assetBatch.map((assetPayload) => {
+        return offline({
+          ...assetPayload,
+          submitted_at: submittedAt
+        });
+      });
       return {
         batchId: v4(),
         payload: {
           transaction_id: transactionId,
-          submitted_at: submittedAt,
-          asset_type: assetTypeId,
           assets: assetPayloads
         }
       };
@@ -4298,7 +4300,10 @@ class AssetService extends BaseApiService {
       const promise = this.enqueueRequest({
         description: "Batch create assets",
         method: HttpMethod.POST,
-        url: "/assets/bulk/",
+        url: `/assets/types/${assetTypeId}/add-assets/`,
+        queryParams: {
+          workspace_id: workspaceId.toString()
+        },
         payload,
         blockers,
         blocks
@@ -4324,152 +4329,117 @@ class AssetService extends BaseApiService {
   }
 }
 class AssetStageCompletionService extends BaseApiService {
-  add(payload) {
+  add(assetId, stageId) {
+    var _a2;
     const { store } = this.client;
-    const createdBy = store.getState().userReducer.currentUser.id;
-    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const assetTypeId = (_a2 = selectAssetById(assetId)(store.getState())) == null ? void 0 : _a2.asset_type;
+    if (!assetTypeId) {
+      throw new Error(`Asset with offline_id ${assetId} not found`);
+    }
     const offlineStageCompletion = offline({
-      ...payload,
-      created_by: createdBy,
-      submitted_at: submittedAt
+      asset: assetId,
+      stage: stageId
     });
-    this.dispatch(addAssetStageCompletion(offlineStageCompletion));
+    this.dispatch(addStageCompletion(offlineStageCompletion));
     const promise = this.enqueueRequest({
-      description: "Add asset stage completion",
+      description: "Complete stage",
       method: HttpMethod.POST,
-      url: "/assets/completions/",
-      payload: {
-        offline_id: offlineStageCompletion.offline_id,
-        submitted_at: submittedAt,
-        asset: payload.asset,
-        stage: payload.stage
-      },
-      blockers: [payload.asset, payload.stage],
+      url: `/assets/types/${assetTypeId}/complete-stages/`,
+      // TODO: Add submitted_at to model
+      payload: { completions: [{ ...offlineStageCompletion, submitted_at: (/* @__PURE__ */ new Date()).getTime() / 1e3 }] },
+      blockers: [assetId, stageId],
       blocks: [offlineStageCompletion.offline_id]
     });
-    promise.then((result) => {
-      this.dispatch(updateAssetStageCompletion(result));
-    }).catch(() => {
-      this.dispatch(deleteAssetStageCompletion(offlineStageCompletion.offline_id));
-    });
     return [offlineStageCompletion, promise];
   }
-  delete(id) {
-    const { store } = this.client;
-    const assetStageCompletion = selectAssetStageCompletionById(id)(store.getState());
-    if (!assetStageCompletion) {
-      throw new Error(`Expected asset stage completion with id ${id} to exist`);
-    }
-    this.dispatch(deleteAssetStageCompletion(id));
-    const promise = this.enqueueRequest({
-      description: "Delete asset stage completion",
-      method: HttpMethod.DELETE,
-      url: `/assets/completions/${id}/`,
-      blockers: [id],
+  async refreshStore(projectId) {
+    const result = await this.enqueueRequest({
+      description: "Get stage completions",
+      method: HttpMethod.GET,
+      url: `/projects/${projectId}/asset-stage-completions/`,
+      blockers: [],
       blocks: []
     });
-    promise.catch(() => {
-      this.dispatch(addAssetStageCompletion(assetStageCompletion));
-    });
-    return promise;
+    this.dispatch(addStageCompletions(result));
   }
-  bulkAdd(payloads) {
-    const { store } = this.client;
-    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const createdBy = store.getState().userReducer.currentUser.id;
-    const payload = payloads.map((payload2) => offline(payload2));
-    const offlineStageCompletions = payload.map((completion) => {
-      return {
-        ...completion,
-        created_by: createdBy,
-        submitted_at: submittedAt
-      };
-    });
-    const offlineIds = offlineStageCompletions.map(({ offline_id }) => offline_id);
-    this.dispatch(addAssetStageCompletions(offlineStageCompletions));
-    const promise = this.enqueueRequest({
-      description: "Bulk create asset stage completions",
+  /**
+   * Creates a collection of AssetStageCompletions, marking the referenced stages as completed for the referenced
+   * assets. It's REQUIRED that all assets referenced all have the SAME asset type.
+   * @param assetTypeId The ID of the asset type for which we are completing stages (we can only complete
+   * stages for one asset type at a time)
+   * @param stageCompletions
+   */
+  async bulkAdd(assetTypeId, stageCompletions) {
+    const offlineStageCompletions = stageCompletions.map((completion) => {
+      return offline(completion);
+    });
+    const asMapping = {};
+    for (const completion of stageCompletions) {
+      const stageToCompletionDateMapping = asMapping[completion.asset] || {};
+      stageToCompletionDateMapping[completion.stage] = (/* @__PURE__ */ new Date()).toISOString();
+      asMapping[completion.asset] = stageToCompletionDateMapping;
+    }
+    this.dispatch(addStageCompletions(asMapping));
+    await this.enqueueRequest({
+      description: "Bulk complete stages",
       method: HttpMethod.POST,
-      url: "/assets/completions/bulk/",
+      url: `/assets/types/${assetTypeId}/complete-stages/`,
       payload: {
-        submitted_at: submittedAt,
-        completions: payload
+        completions: offlineStageCompletions
       },
-      blockers: [...payloads.map((c) => c.asset), ...payloads.map((c) => c.stage)],
-      blocks: offlineIds
-    });
-    promise.then((result) => {
-      this.dispatch(updateAssetStageCompletions(result));
-    }).catch(() => {
-      this.dispatch(deleteAssetStageCompletions(offlineIds));
+      blockers: [assetTypeId, ...stageCompletions.map((c) => c.asset), ...stageCompletions.map((c) => c.stage)],
+      blocks: offlineStageCompletions.map((c) => c.offline_id)
     });
-    return [offlineStageCompletions, promise];
   }
-  bulkDelete(ids) {
-    const { store } = this.client;
-    const assetStageCompletions = selectAssetStageCompletionsByIds(ids)(store.getState());
-    this.dispatch(deleteAssetStageCompletions(ids));
-    const promise = this.enqueueRequest({
-      description: "Deleting asset stage completions",
+  bulkDelete(stageId, assetIds) {
+    const stageCompletionsToRemove = assetIds.map((assetId) => {
+      return {
+        asset: assetId,
+        stage: stageId
+      };
+    });
+    this.dispatch(removeStageCompletions(stageCompletionsToRemove));
+    return this.enqueueRequest({
+      description: `Undo stage for ${assetIds.length} assets(s)`,
+      // TODO: Rename to setCompletedStages
       method: HttpMethod.DELETE,
-      url: "/assets/completions/bulk/",
+      url: `/assets/stages/${stageId}/undo-stages/`,
       payload: {
-        completion_ids: ids
+        assets: assetIds
       },
-      blockers: ids,
-      blocks: []
-    });
-    promise.catch(() => {
-      this.dispatch(addAssetStageCompletions(assetStageCompletions));
-    });
-    return promise;
-  }
-  async refreshStore(projectId) {
-    const result = await this.enqueueRequest({
-      description: "Get asset stage completions",
-      method: HttpMethod.GET,
-      url: `/projects/${projectId}/asset-stage-completions/`,
-      blockers: [],
+      blockers: [stageId, ...assetIds],
       blocks: []
     });
-    this.dispatch(initializeAssetStageCompletions(result));
   }
 }
 class AssetStageService extends BaseApiService {
-  bulkAdd(stagesToSubmit, assetTypeId) {
-    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const createdBy = this.client.store.getState().userReducer.currentUser.id;
+  async bulkCreateStages(stagesToSubmit, assetTypeId, workspaceId) {
     const payload = stagesToSubmit.map((stage) => {
       return offline(stage);
     });
-    const offlineStages = payload.map((stage) => {
-      return { ...stage, asset_type: assetTypeId, created_by: createdBy, submitted_at: submittedAt };
+    const fullStages = payload.map((stage) => {
+      return { ...stage, asset_type: assetTypeId };
     });
-    this.dispatch(addAssetStages(offlineStages));
-    const promise = this.enqueueRequest({
+    this.dispatch(addStages(fullStages));
+    return this.enqueueRequest({
       description: "Add asset stages",
       method: HttpMethod.POST,
-      url: "/assets/stages/bulk/",
+      url: `/assets/types/${assetTypeId}/add-stages/`,
       payload: {
-        submitted_at: submittedAt,
-        asset_type: assetTypeId,
         stages: payload
       },
-      blockers: [assetTypeId],
+      queryParams: {
+        workspace_id: workspaceId.toString()
+      },
+      blockers: [assetTypeId, workspaceId],
       blocks: payload.map(({ offline_id }) => offline_id)
     });
-    promise.then((result) => {
-      this.dispatch(updateAssetStages(result));
-    }).catch(() => {
-      this.dispatch(deleteAssetStages(offlineStages.map(({ offline_id }) => offline_id)));
-    });
-    return [offlineStages, promise];
   }
-  async bulkUpdate(stagesToUpdate, assetTypeId) {
+  async bulkUpdateStages(stagesToUpdate, assetTypeId) {
     const store = this.client.store;
     const state = store.getState();
     const prevStages = selectAssetStagesByIds(stagesToUpdate.map(({ offline_id }) => offline_id))(state);
-    this.dispatch(updateAssetStages(stagesToUpdate));
+    this.dispatch(updateStages(stagesToUpdate));
     return this.enqueueRequest({
       description: "Edit asset stages",
       method: HttpMethod.PATCH,
@@ -4480,58 +4450,33 @@ class AssetStageService extends BaseApiService {
       blockers: [assetTypeId],
       blocks: stagesToUpdate.map(({ offline_id }) => offline_id)
     }).catch((e) => {
-      this.dispatch(updateAssetStages(prevStages));
+      store.dispatch(updateStages(prevStages));
       throw e;
     });
   }
   async bulkDelete(idsToDelete) {
-    const { store } = this.client;
-    const assetStages = selectAssetStagesByIds(idsToDelete)(store.getState());
-    this.dispatch(deleteAssetStages(idsToDelete));
-    const promise = this.enqueueRequest({
+    this.dispatch(removeStages(idsToDelete));
+    return this.enqueueRequest({
       description: "Delete asset stages",
       method: HttpMethod.DELETE,
-      url: "/assets/stages/bulk/",
+      url: "/assets/stages/bulk-delete/",
       payload: {
         stage_ids: idsToDelete
       },
       blockers: idsToDelete,
       blocks: []
     });
-    promise.catch(() => {
-      this.dispatch(addAssetStages(assetStages));
-    });
-    return promise;
   }
-  update(payload) {
-    const { store } = this.client;
-    const assetStage = selectAssetStageById(payload.offline_id)(store.getState());
-    if (!assetStage)
-      throw new Error(`No asset stage with id ${payload.offline_id} found in the store`);
-    const updatedAssetStage = {
-      ...assetStage,
-      ...payload
-    };
-    this.dispatch(updateAssetStage(updatedAssetStage));
-    const promise = this.enqueueRequest({
+  async update(assetStage) {
+    this.dispatch(addStages([assetStage]));
+    return this.enqueueRequest({
       description: "Update asset stage",
       method: HttpMethod.PATCH,
       url: `/assets/stages/${assetStage.offline_id}/`,
-      payload: {
-        name: payload.name,
-        description: payload.description,
-        priority: payload.priority,
-        color: payload.color
-      },
+      payload: assetStage,
       blockers: [assetStage.offline_id],
       blocks: [assetStage.offline_id]
     });
-    promise.then((result) => {
-      this.dispatch(updateAssetStage(result));
-    }).catch(() => {
-      this.dispatch(setAssetStage(assetStage));
-    });
-    return [updatedAssetStage, promise];
   }
   async linkForm(stageId, formId) {
     const { store } = this.client;
@@ -4539,7 +4484,7 @@ class AssetStageService extends BaseApiService {
     if (!stage) {
       throw new Error(`No asset stage with id ${stageId} found in the store`);
     }
-    this.dispatch(updateAssetStage({ ...stage, form: formId }));
+    this.dispatch(updateStage({ ...stage, form: formId }));
     try {
       await this.enqueueRequest({
         description: "Link asset stage to form",
@@ -4550,7 +4495,7 @@ class AssetStageService extends BaseApiService {
         blocks: [stageId]
       });
     } catch (e) {
-      this.dispatch(setAssetStage(stage));
+      this.dispatch(setStage(stage));
       throw e;
     }
   }
@@ -4560,7 +4505,7 @@ class AssetStageService extends BaseApiService {
     if (!stage) {
       throw new Error(`No asset stage with id ${stageId} found in the store`);
     }
-    this.dispatch(updateAssetStage({ ...stage, form: void 0 }));
+    this.dispatch(updateStage({ ...stage, form: void 0 }));
     try {
       await this.enqueueRequest({
         description: "Unlink asset stage from form",
@@ -4570,7 +4515,7 @@ class AssetStageService extends BaseApiService {
         blocks: [stageId]
       });
     } catch (e) {
-      this.dispatch(setAssetStage(stage));
+      this.dispatch(setStage(stage));
       throw e;
     }
   }
@@ -4582,7 +4527,7 @@ class AssetStageService extends BaseApiService {
       blockers: [],
       blocks: []
     });
-    this.dispatch(initializeAssetStages(result));
+    this.dispatch(initializeStages(result));
   }
 }
 class BaseUploadService extends BaseApiService {
@@ -4789,61 +4734,29 @@ class AssetAttachmentService extends BaseAttachmentService {
   }
 }
 class AssetTypeService extends BaseApiService {
-  add(payload) {
-    const { store } = this.client;
-    const createdBy = store.getState().userReducer.currentUser.id;
-    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const offlineAssetType = offline({
-      ...payload,
-      created_by: createdBy,
-      submitted_at: submittedAt
-    });
+  add(assetType) {
+    const offlineAssetType = offline(assetType);
     this.dispatch(addAssetType(offlineAssetType));
     const promise = this.enqueueRequest({
       description: "Create asset type",
       method: HttpMethod.POST,
-      url: `/projects/${payload.project}/asset-types/`,
+      url: `/projects/${assetType.project}/asset-types/`,
       payload: { ...offlineAssetType },
       blockers: [],
       blocks: [offlineAssetType.offline_id]
     });
-    promise.then((result) => {
-      this.dispatch(updateAssetType(result));
-    }).catch(() => {
-      this.dispatch(deleteAssetType(offlineAssetType.offline_id));
-    });
     return [offlineAssetType, promise];
   }
-  update(payload) {
-    const { store } = this.client;
-    const assetType = selectAssetTypeById(payload.offline_id)(store.getState());
-    if (!assetType) {
-      throw new Error(`Expected asset type with offline_id ${payload.offline_id} to exist`);
-    }
-    const updatedAssetType = {
-      ...assetType,
-      ...payload
-    };
-    this.dispatch(updateAssetType(updatedAssetType));
-    const promise = this.enqueueRequest({
+  update(assetType) {
+    this.dispatch(addAssetType(assetType));
+    return this.enqueueRequest({
       description: "Update asset type",
       method: HttpMethod.PATCH,
-      url: `/assets/types/${payload.offline_id}/`,
-      payload: {
-        icon: payload.icon,
-        color: payload.color,
-        name: payload.name,
-        description: payload.description
-      },
+      url: `/assets/types/${assetType.offline_id}/`,
+      payload: assetType,
       blockers: [assetType.offline_id],
       blocks: [assetType.offline_id]
     });
-    promise.then((result) => {
-      this.dispatch(updateAssetType(result));
-    }).catch(() => {
-      this.dispatch(updateAssetType(assetType));
-    });
-    return [updatedAssetType, promise];
   }
   async delete(assetTypeId) {
     const { store } = this.client;
@@ -4852,13 +4765,17 @@ class AssetTypeService extends BaseApiService {
     if (!assetType) {
       throw new Error(`Expected asset type with offline_id ${assetTypeId} to exist`);
     }
-    const assetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state);
     const stagesOfAssetType = selectStagesOfAssetType(assetTypeId)(state);
     const attachmentsOfAssetType = selectAttachmentsOfAssetType(assetTypeId)(state);
     this.dispatch(deleteAssetType(assetTypeId));
-    this.dispatch(deleteAssets(assetsOfAssetType.map((asset) => asset.offline_id)));
-    this.dispatch(deleteAssetStages(stagesOfAssetType.map((assetStage) => assetStage.offline_id)));
-    this.dispatch(deleteAssetTypeAttachments(attachmentsOfAssetType.map(({ offline_id }) => offline_id)));
+    if (stagesOfAssetType.length > 0) {
+      const stagesOfAssetTypeIds = stagesOfAssetType.map((assetStage) => assetStage.offline_id);
+      this.dispatch(removeStages(stagesOfAssetTypeIds));
+    }
+    if (attachmentsOfAssetType.length > 0) {
+      const attachmentsOfAssetTypeIds = attachmentsOfAssetType.map(({ offline_id }) => offline_id);
+      this.dispatch(deleteAssetTypeAttachments(attachmentsOfAssetTypeIds));
+    }
     return this.enqueueRequest({
       description: "Delete asset type",
       method: HttpMethod.DELETE,
@@ -4867,8 +4784,7 @@ class AssetTypeService extends BaseApiService {
       blocks: []
     }).catch((e) => {
       this.dispatch(addAssetType(assetType));
-      this.dispatch(addAssets(assetsOfAssetType));
-      this.dispatch(addAssetStages(stagesOfAssetType));
+      this.dispatch(addStages(stagesOfAssetType));
       this.dispatch(addAssetTypeAttachments(attachmentsOfAssetType));
       throw e;
     });
@@ -5082,6 +4998,15 @@ class IssueService extends BaseApiService {
     void promise.then((result) => {
       this.dispatch(updateIssue(result));
     }).catch((error) => {
+      var _a2;
+      console.error(error);
+      if (error instanceof APIError) {
+        (_a2 = unsafeShowToast) == null ? void 0 : _a2({
+          title: "Could not create issue",
+          description: error.message,
+          accentColor: "red"
+        });
+      }
       this.dispatch(deleteIssue(issuePayload.offline_id));
       this.dispatch(addActiveProjectIssuesCount(-1));
       throw error;
@@ -7637,20 +7562,12 @@ class IssueAssociationService extends BaseUploadService {
     this.dispatch(initializeIssueAssociations(issueAssociations));
   }
 }
-var VerificationCodeType = /* @__PURE__ */ ((VerificationCodeType2) => {
-  VerificationCodeType2[VerificationCodeType2["USER_REGISTRATION"] = 0] = "USER_REGISTRATION";
-  VerificationCodeType2[VerificationCodeType2["APPLICATION_INVITE"] = 2] = "APPLICATION_INVITE";
-  VerificationCodeType2[VerificationCodeType2["PROJECT_INVITE"] = 4] = "PROJECT_INVITE";
-  VerificationCodeType2[VerificationCodeType2["ORGANIZATION_INVITE"] = 6] = "ORGANIZATION_INVITE";
-  VerificationCodeType2[VerificationCodeType2["ADD_EMAIL_DOMAIN"] = 8] = "ADD_EMAIL_DOMAIN";
-  VerificationCodeType2[VerificationCodeType2["RESET_PASSWORD"] = 10] = "RESET_PASSWORD";
-  return VerificationCodeType2;
-})(VerificationCodeType || {});
 export {
   APIError,
   AgentService,
   AssetAttachmentService,
   AssetService,
+  AssetStageColors,
   AssetStageCompletionService,
   AssetStageService,
   AssetTypeAttachmentService,
@@ -7712,14 +7629,9 @@ export {
   addAsset,
   addAssetAttachment,
   addAssetAttachments,
-  addAssetStage,
-  addAssetStageCompletion,
-  addAssetStageCompletions,
-  addAssetStages,
   addAssetType,
   addAssetTypeAttachment,
   addAssetTypeAttachments,
-  addAssetTypes,
   addAssets,
   addCategory,
   addConversation,
@@ -7757,6 +7669,9 @@ export {
   addOrReplaceProjects,
   addProjectAttachment,
   addProjectAttachments,
+  addStageCompletion,
+  addStageCompletions,
+  addStages,
   addTeam,
   addToRecentIssues,
   addUsers,
@@ -7797,14 +7712,9 @@ export {
   deleteAsset,
   deleteAssetAttachment,
   deleteAssetAttachments,
-  deleteAssetStage,
-  deleteAssetStageCompletion,
-  deleteAssetStageCompletions,
-  deleteAssetStages,
   deleteAssetType,
   deleteAssetTypeAttachment,
   deleteAssetTypeAttachments,
-  deleteAssetTypes,
   deleteAssets,
   deleteCategory,
   deleteDocumentAttachment,
@@ -7880,11 +7790,10 @@ export {
   getLocalRelativeDateString,
   getOutboxCoordinator,
   getRenamedFile,
+  getStageColor,
   hashFile,
   initSDK,
   initializeAssetAttachments,
-  initializeAssetStageCompletions,
-  initializeAssetStages,
   initializeAssetTypeAttachments,
   initializeAssetTypes,
   initializeAssets,
@@ -7907,6 +7816,7 @@ export {
   initializeOrganizationAccesses,
   initializeProjectAccesses,
   initializeProjectAttachments,
+  initializeStages,
   initializeTeams,
   initializeWorkspaces,
   isToday,
@@ -7964,6 +7874,8 @@ export {
   removeProjectFile,
   removeProjectFilesOfProject,
   removeRecentIssue,
+  removeStageCompletions,
+  removeStages,
   removeUser,
   resetProjectFileObjectUrls,
   resetRecentIssues,
@@ -7986,9 +7898,6 @@ export {
   selectAssetAttachments,
   selectAssetById,
   selectAssetStageById,
-  selectAssetStageCompletionById,
-  selectAssetStageCompletionMapping,
-  selectAssetStageCompletionsByIds,
   selectAssetStages,
   selectAssetStagesByIds,
   selectAssetTypeAttachmentById,
@@ -8024,7 +7933,7 @@ export {
   selectCategoryMapping,
   selectCommentsOfIssue,
   selectCompletedStageIdsForAsset,
-  selectCompletedStagesByAsset,
+  selectCompletedStages,
   selectConversation,
   selectConversationMapping,
   selectConversations,
@@ -8138,6 +8047,7 @@ export {
   selectSortedProjectUsers,
   selectStageFormIdsFromStageIds,
   selectStageMapping,
+  selectStagesFromAssetTypeIds,
   selectStagesOfAssetType,
   selectTeamById,
   selectTeams,
@@ -8157,12 +8067,8 @@ export {
   setAsset,
   setAssetAttachment,
   setAssetAttachments,
-  setAssetStage,
-  setAssetStages,
-  setAssetType,
   setAssetTypeAttachment,
   setAssetTypeAttachments,
-  setAssetTypes,
   setAssets,
   setConversation,
   setCurrentUser,
@@ -8195,6 +8101,8 @@ export {
   setProjectAttachments,
   setProjects,
   setRehydrated,
+  setStage,
+  setStageCompletions,
   setTeam,
   setTokens,
   setTourStep,
@@ -8213,14 +8121,8 @@ export {
   updateAsset,
   updateAssetAttachment,
   updateAssetAttachments,
-  updateAssetStage,
-  updateAssetStageCompletion,
-  updateAssetStageCompletions,
-  updateAssetStages,
-  updateAssetType,
   updateAssetTypeAttachment,
   updateAssetTypeAttachments,
-  updateAssetTypes,
   updateAssets,
   updateCategory,
   updateConversation,
@@ -8248,6 +8150,8 @@ export {
   updateProjectAccess,
   updateProjectAttachment,
   updateProjectAttachments,
+  updateStage,
+  updateStages,
   updateTeam,
   updateWorkspace,
   useMemoCompare,