@overmap-ai/core 1.0.63-org-doc-improvements.2 → 1.0.63-selector-standardization.1

package/dist/overmap-core.js

@@ -379,15 +379,15 @@ const wrapMigration = (migrator) => (state) => {
 };
 const migrations = [initialVersioning, signOut, signOut, createOutboxState];
 const manifest = Object.fromEntries(migrations.map((migration2, i) => [i, wrapMigration(migration2)]));
-const initialState$C = {
+const initialState$B = {
   accessToken: "",
   refreshToken: "",
   isLoggedIn: false
 };
 const authSlice = createSlice({
   name: "auth",
-  initialState: initialState$C,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$C)),
+  initialState: initialState$B,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
   reducers: {
     setTokens: (state, action) => {
       state.accessToken = action.payload.accessToken;
@@ -857,11 +857,11 @@ function createModelAdapter(computeModelId) {
   };
 }
 const categoryAdapter = createModelAdapter((category) => category.offline_id);
-const initialState$B = categoryAdapter.getInitialState({});
+const initialState$A = categoryAdapter.getInitialState({});
 const categorySlice = createSlice({
   name: "categories",
-  initialState: initialState$B,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
+  initialState: initialState$A,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$A)),
   reducers: {
     initializeCategories: categoryAdapter.initialize,
     addCategory: categoryAdapter.addOne,
@@ -874,28 +874,131 @@ const selectCategoryMapping = (state) => state.categoryReducer.instances;
 const selectCategories = createSelector([selectCategoryMapping], (categoryMapping) => {
   return Object.values(categoryMapping);
 });
-const selectCategoriesOfWorkspace = restructureCreateSelectorWithArgs(
+const selectCategoryById = (id) => (state) => {
+  return state.categoryReducer.instances[id];
+};
+const selectCategoriesByIds = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectCategories, (_state, workspaceId) => workspaceId],
-    (categories, workspaceId) => categories.filter((category) => category.workspace === workspaceId)
+    [selectCategoryMapping, (_state, categoryIds) => categoryIds],
+    (categoryMapping, categoryIds) => {
+      const categories = [];
+      for (const categoryId of categoryIds) {
+        const category = categoryMapping[categoryId];
+        if (category) {
+          categories.push(category);
+        } else {
+          console.warn("selectCategoryByIds: No category exists with the id", categoryId);
+        }
+      }
+      return categories;
+    }
   )
 );
-const selectCategoryById = restructureCreateSelectorWithArgs(
+const selectCategoriesOfWorkspace = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectCategoryMapping, (_state, categoryId) => categoryId],
-    (mapping, categoryId) => mapping[categoryId]
+    [selectCategories, (_state, workspaceId) => workspaceId],
+    (categories, workspaceId) => categories.filter((category) => category.workspace === workspaceId)
   )
 );
 const selectIssueCountOfCategory = (categoryId) => (state) => {
   return Object.values(state.issueReducer.instances).filter((issue) => issue.category === categoryId).length;
 };
 const categoryReducer = categorySlice.reducer;
+const assetStageAdapter = createModelAdapter((assetStage) => assetStage.offline_id);
+const initialState$z = assetStageAdapter.getInitialState({});
+const assetStageSlice = createSlice({
+  name: "assetStages",
+  initialState: initialState$z,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
+  reducers: {
+    initializeStages: assetStageAdapter.initialize,
+    setStage: assetStageAdapter.setOne,
+    addStages: assetStageAdapter.addMany,
+    updateStage: assetStageAdapter.updateOne,
+    updateStages: assetStageAdapter.updateMany,
+    removeStages: assetStageAdapter.deleteMany
+  }
+});
+const selectStageMapping = (state) => state.assetStageReducer.instances;
+const selectAssetStageById = restructureCreateSelectorWithArgs(
+  createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
+    return stageMapping[stageId];
+  })
+);
+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 = {};
+    for (const [stageId, stage] of Object.entries(stagesMapping)) {
+      if (stage.asset_type === assetTypeId) {
+        assetTypeStagesMapping[stageId] = stage;
+      }
+    }
+    return assetTypeStagesMapping;
+  })
+);
+const selectStagesOfAssetType = restructureCreateSelectorWithArgs(
+  createSelector([selectAssetStages, (_state, assetTypeId) => assetTypeId], (stages, assetTypeId) => {
+    return stages.filter((stage) => stage.asset_type === assetTypeId).sort((a, b) => a.priority - b.priority);
+  })
+);
+const selectAssetStagesByIds = restructureCreateSelectorWithArgs(
+  createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
+    const assetStages = [];
+    for (const stageId of stageIds) {
+      const stage = stageMapping[stageId];
+      if (stage) {
+        assetStages.push(stage);
+      } else {
+        console.warn("selectStagesFromStageIds: No stage exists with the id", stageId);
+      }
+    }
+    return assetStages;
+  })
+);
+const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
+  createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
+    const ret = {};
+    for (const stageId of stageIds) {
+      const stage = stageMapping[stageId];
+      if (!stage) {
+        throw new Error("No stage exists with the id " + stageId);
+      }
+      if (stage.form) {
+        ret[stageId] = stage.form;
+      }
+    }
+    return ret;
+  })
+);
+const { initializeStages, setStage, addStages, updateStages, removeStages, updateStage } = assetStageSlice.actions;
+const assetStageReducer = assetStageSlice.reducer;
 const assetTypeAdapter = createModelAdapter((assetType) => assetType.offline_id);
-const initialState$A = assetTypeAdapter.getInitialState({});
+const initialState$y = assetTypeAdapter.getInitialState({});
 const assetTypeSlice = createSlice({
   name: "assetTypes",
-  initialState: initialState$A,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$A)),
+  initialState: initialState$y,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
   reducers: {
     initializeAssetTypes: assetTypeAdapter.initialize,
     addAssetType: assetTypeAdapter.addOne,
@@ -908,43 +1011,33 @@ const selectAssetTypes = createSelector(
   [selectAssetTypesMapping],
   (mapping) => Object.values(mapping)
 );
-const selectAssetType = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAssetTypesMapping, (_state, assetTypeId) => assetTypeId],
-    (mapping, assetTypeId) => mapping[assetTypeId]
-  )
-);
-const selectNumberOfAssetTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
+const selectAssetTypeById = (id) => (state) => {
+  return state.assetTypeReducer.instances[id];
+};
+const selectAssetTypesByIds = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectAssetTypesMapping, (_state, args) => args],
-    (mapping, args) => {
-      var _a2;
-      const name = ((_a2 = args.name) == null ? void 0 : _a2.toLowerCase()) ?? null;
-      return Object.values(mapping).filter(
-        (assetType) => {
-          var _a3;
-          return (((_a3 = assetType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && assetType.offline_id !== args.assetTypeId;
+    [selectStageMapping, (_state, assetTypeIds) => assetTypeIds],
+    (assetTypeMapping, assetTypeIds) => {
+      const assetTypes = [];
+      for (const stageId of assetTypeIds) {
+        const stage = assetTypeMapping[stageId];
+        if (stage) {
+          assetTypes.push(stage);
+        } else {
+          console.warn("selectAssetTypesByIds: No stage exists with the id", stageId);
         }
-      ).length;
+      }
+      return assetTypes;
     }
   )
 );
-const selectAssetTypesByName = restructureCreateSelectorWithArgs(
-  createSelector([selectAssetTypesMapping, (_state, name) => name], (mapping, name) => {
-    name = (name == null ? void 0 : name.toLowerCase()) ?? null;
-    return Object.values(mapping).filter((assetType) => {
-      var _a2;
-      return (((_a2 = assetType.name) == null ? void 0 : _a2.toLowerCase()) ?? null) === name;
-    });
-  })
-);
 const assetTypeReducer = assetTypeSlice.reducer;
 const assetAdapter = createModelAdapter((asset) => asset.offline_id);
-const initialState$z = assetAdapter.getInitialState({});
+const initialState$x = assetAdapter.getInitialState({});
 const assetSlice = createSlice({
   name: "assets",
-  initialState: initialState$z,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
+  initialState: initialState$x,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
   reducers: {
     initializeAssets: (state, action) => {
       assetAdapter.initialize(state, action);
@@ -1008,9 +1101,20 @@ const selectAssetsOfAssetType = restructureCreateSelectorWithArgs(
     return components.filter((asset) => asset.asset_type === assetTypeId);
   })
 );
-const selectAsset = (assetId) => (state) => {
+const selectAssetById = (assetId) => (state) => {
   return state.assetReducer.instances[assetId];
 };
+const selectAssetsByIds = restructureCreateSelectorWithArgs(
+  createSelector([selectAssetsMapping, (_, assetIds) => assetIds], (assetsMapping, assetIds) => {
+    const assets = [];
+    for (const assetId of assetIds) {
+      const asset = assetsMapping[assetId];
+      if (asset)
+        assets.push(asset);
+    }
+    return assets;
+  })
+);
 const selectAssetToAssetTypeMapping = createSelector(
   [selectAssets, selectAssetTypesMapping],
   (assets, assetTypeMapping) => {
@@ -1047,11 +1151,11 @@ const selectAssetTypesFromIds = (assetTypeIds) => (state) => {
 };
 const assetReducer = assetSlice.reducer;
 const assetAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-const initialState$y = assetAttachmentAdapter.getInitialState({});
+const initialState$w = assetAttachmentAdapter.getInitialState({});
 const assetAttachmentSlice = createSlice({
   name: "assetAttachments",
-  initialState: initialState$y,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
+  initialState: initialState$w,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
   reducers: {
     initializeAssetAttachments: assetAttachmentAdapter.initialize,
     addAssetAttachment: assetAttachmentAdapter.addOne,
@@ -1109,13 +1213,13 @@ const selectAttachmentsOfAssetByType = restructureCreateSelectorWithArgs(
   )
 );
 const assetAttachmentReducer = assetAttachmentSlice.reducer;
-const initialState$x = {
+const initialState$v = {
   completionsByAssetId: {}
 };
 const assetStageCompletionSlice = createSlice({
   name: "assetStageCompletions",
-  initialState: initialState$x,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
+  initialState: initialState$v,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
   reducers: {
     addStageCompletion: (state, action) => {
       let stageToCompletionDateMapping = state.completionsByAssetId[action.payload.asset];
@@ -1166,97 +1270,14 @@ const selectCompletedStageIdsForAsset = restructureCreateSelectorWithArgs(
   })
 );
 const assetStageCompletionReducer = assetStageCompletionSlice.reducer;
-const assetStageAdapter = createModelAdapter((assetStage) => assetStage.offline_id);
-const initialState$w = assetStageAdapter.getInitialState({});
-const assetStageSlice = createSlice({
-  name: "assetStages",
-  initialState: initialState$w,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
-  reducers: {
-    initializeStages: assetStageAdapter.initialize,
-    setStage: assetStageAdapter.setOne,
-    addStages: assetStageAdapter.addMany,
-    updateStage: assetStageAdapter.updateOne,
-    updateStages: assetStageAdapter.updateMany,
-    removeStages: assetStageAdapter.deleteMany
-  }
-});
-const selectStageMapping = (state) => state.assetStageReducer.instances;
-const selectStage = restructureCreateSelectorWithArgs(
-  createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
-    return stageMapping[stageId];
-  })
-);
-const selectStages = createSelector(
-  [selectStageMapping],
-  (stageMapping) => {
-    return Object.values(stageMapping);
-  }
-);
-const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
-  createSelector([selectStages, (_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 = {};
-    for (const [stageId, stage] of Object.entries(stagesMapping)) {
-      if (stage.asset_type === assetTypeId) {
-        assetTypeStagesMapping[stageId] = stage;
-      }
-    }
-    return assetTypeStagesMapping;
-  })
-);
-const selectStagesOfAssetType = restructureCreateSelectorWithArgs(
-  createSelector([selectStages, (_state, assetTypeId) => assetTypeId], (stages, assetTypeId) => {
-    return stages.filter((stage) => stage.asset_type === assetTypeId).sort((a, b) => a.priority - b.priority);
-  })
-);
-const selectStagesFromStageIds = restructureCreateSelectorWithArgs(
-  createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
-    return stageIds.map((offline_id) => stageMapping[offline_id]).filter((stage) => !!stage);
-  })
-);
-const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
-  createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
-    const ret = {};
-    for (const stageId of stageIds) {
-      const stage = stageMapping[stageId];
-      if (!stage) {
-        throw new Error("No stage exists with the id " + stageId);
-      }
-      if (stage.form) {
-        ret[stageId] = stage.form;
-      }
-    }
-    return ret;
-  })
-);
-const { initializeStages, setStage, addStages, updateStages, removeStages, updateStage } = assetStageSlice.actions;
-const assetStageReducer = assetStageSlice.reducer;
 const assetTypeAttachmentAdapter = createModelAdapter(
   (attachment) => attachment.offline_id
 );
-const initialState$v = assetTypeAttachmentAdapter.getInitialState({});
+const initialState$u = assetTypeAttachmentAdapter.getInitialState({});
 const assetTypeAttachmentSlice = createSlice({
   name: "assetTypeAttachments",
-  initialState: initialState$v,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
+  initialState: initialState$u,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$u)),
   reducers: {
     initializeAssetTypeAttachments: assetTypeAttachmentAdapter.initialize,
     addAssetTypeAttachment: assetTypeAttachmentAdapter.addOne,
@@ -1315,10 +1336,10 @@ const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
 );
 const assetTypeAttachmentReducer = assetTypeAttachmentSlice.reducer;
 const workspaceAdapter = createModelAdapter((workspace) => workspace.offline_id);
-const initialState$u = workspaceAdapter.getInitialState({});
+const initialState$t = workspaceAdapter.getInitialState({});
 const workspaceSlice = createSlice({
   name: "workspace",
-  initialState: initialState$u,
+  initialState: initialState$t,
   reducers: {
     initializeWorkspaces: workspaceAdapter.initialize,
     setWorkspaces: workspaceAdapter.setMany,
@@ -1350,14 +1371,14 @@ const selectPermittedWorkspaceIds = createSelector(
 const workspaceReducer = workspaceSlice.reducer;
 const maxRecentIssues = 10;
 const issueAdapter = createModelAdapter((issue) => issue.offline_id);
-const initialState$t = issueAdapter.getInitialState({
+const initialState$s = issueAdapter.getInitialState({
   recentIssueIds: []
 });
 const issueSlice = createSlice({
   name: "issues",
-  initialState: initialState$t,
+  initialState: initialState$s,
   extraReducers: (builder) => builder.addCase("RESET", (state) => {
-    Object.assign(state, initialState$t);
+    Object.assign(state, initialState$s);
   }),
   reducers: {
     initializeIssues: issueAdapter.initialize,
@@ -1405,11 +1426,9 @@ const {
 } = issueSlice.actions;
 const selectIssueMapping = (state) => state.issueReducer.instances;
 const selectRecentIssueIds = (state) => state.issueReducer.recentIssueIds;
-const selectIssue = restructureCreateSelectorWithArgs(
-  createSelector([selectIssueMapping, (_state, id) => id], (mapping, id) => {
-    return mapping[id];
-  })
-);
+const selectIssueById = (id) => (state) => {
+  return state.issueReducer.instances[id];
+};
 const searchIssues = restructureCreateSelectorWithArgs(
   createSelector(
     [selectIssueMapping, selectWorkspaceMapping, (_state, searchArgs) => searchArgs],
@@ -1465,6 +1484,20 @@ const searchIssues = restructureCreateSelectorWithArgs(
     }
   )
 );
+const selectIssuesByIds = restructureCreateSelectorWithArgs(
+  createSelector([selectIssueMapping, (_, issueIds) => issueIds], (issuesMapping, issueIds) => {
+    const issues = [];
+    for (const issueId of issueIds) {
+      const issue = issuesMapping[issueId];
+      if (issue) {
+        issues.push(issue);
+      } else {
+        console.warn("selectIssuesByIds: No issue exists with the id", issueId);
+      }
+    }
+    return issues;
+  })
+);
 const selectRecentIssuesAsSearchResults = createSelector(
   [selectIssueMapping, selectRecentIssueIds, selectWorkspaceMapping],
   (issueMapping, recentIssueIds, workspaceMapping) => {
@@ -1501,12 +1534,12 @@ const selectRecentIssuesAsSearchResults = createSelector(
 );
 const issueReducer = issueSlice.reducer;
 const issueTypeAdapter = createModelAdapter((issueType) => issueType.offline_id);
-const initialState$s = issueTypeAdapter.getInitialState({});
+const initialState$r = issueTypeAdapter.getInitialState({});
 const issueTypeSlice = createSlice({
   name: "issueTypes",
-  initialState: initialState$s,
+  initialState: initialState$r,
   extraReducers: (builder) => builder.addCase("RESET", (state) => {
-    Object.assign(state, initialState$s);
+    Object.assign(state, initialState$r);
   }),
   reducers: {
     initializeIssueTypes: issueTypeAdapter.initialize,
@@ -1526,14 +1559,21 @@ const selectIssueTypes = createSelector(
     return Object.values(issueTypes);
   }
 );
-const selectIssueType = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectIssueTypeMapping, (_, issueTypeId) => issueTypeId],
-    (issueTypesMapping, issueTypeId) => {
-      return issueTypesMapping[issueTypeId];
+const selectIssueTypeById = (issueTypeId) => (state) => {
+  return state.issueTypeReducer.instances[issueTypeId];
+};
+const selectIssueTypesByIds = (issueTypeIds) => (state) => {
+  const issueTypes = [];
+  for (const issueTypeId of issueTypeIds) {
+    const issueType = state.issueTypeReducer.instances[issueTypeId];
+    if (issueType) {
+      issueTypes.push(issueType);
+    } else {
+      console.warn("selectIssueTypesByIds: No issue type exists with the id", issueTypeId);
     }
-  )
-);
+  }
+  return issueTypes;
+};
 const selectIssueTypesOfOrganization = restructureCreateSelectorWithArgs(
   createSelector(
     [selectIssueTypes, (_, organizationId) => organizationId],
@@ -1555,15 +1595,15 @@ const selectIssuesOfIssueTypeCount = (issueTypeId) => (state) => {
   return ((_a2 = selectIssuesOfIssueType(issueTypeId)(state)) == null ? void 0 : _a2.length) ?? 0;
 };
 const issueTypeReducer = issueTypeSlice.reducer;
-const initialState$r = {
+const initialState$q = {
   s3Urls: {}
 };
 const msPerHour = 1e3 * 60 * 60;
 const msPerWeek = msPerHour * 24 * 7;
 const fileSlice = createSlice({
   name: "file",
-  initialState: initialState$r,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
+  initialState: initialState$q,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
   reducers: {
     setUploadUrl: (state, action) => {
       const { url, fields, sha1 } = action.payload;
@@ -1644,7 +1684,7 @@ var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
   LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
   return LicenseStatus2;
 })(LicenseStatus || {});
-const initialState$q = {
+const initialState$p = {
   users: {},
   currentUser: {
     id: 0,
@@ -1655,8 +1695,8 @@ const initialState$q = {
 };
 const userSlice = createSlice({
   name: "users",
-  initialState: initialState$q,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
+  initialState: initialState$p,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
   reducers: {
     setUsers: (state, action) => {
       const usersMapping = {};
@@ -1709,23 +1749,40 @@ const {
   setTourStep,
   removeUser
 } = userSlice.actions;
+const userReducer = userSlice.reducer;
 const selectCurrentUser = (state) => state.userReducer.currentUser;
+const selectUsersMapping = (state) => state.userReducer.users;
 const selectUser = (userId) => (state) => {
   if (userId === null)
     return void 0;
   return state.userReducer.users[userId];
 };
-const selectUsersAsMapping = (state) => state.userReducer.users;
+const selectUserById = (userId) => (state) => {
+  return state.userReducer.users[userId];
+};
+const selectUsersByIds = restructureCreateSelectorWithArgs(
+  createSelector([selectUsersMapping, (_state, userIds) => userIds], (usersMapping, userIds) => {
+    const users = [];
+    for (const userId of userIds) {
+      const user = usersMapping[userId];
+      if (user) {
+        users.push(user);
+      } else {
+        console.warn("selectUsersByIds: No user exists with the id", userId);
+      }
+    }
+    return users;
+  })
+);
 const selectFavouriteProjects = (state) => state.userReducer.currentUser.profile.favourite_project_ids;
-const userReducer = userSlice.reducer;
 const organizationAccessAdapter = createModelAdapter(
   (organizationAccess) => organizationAccess.offline_id
 );
-const initialState$p = organizationAccessAdapter.getInitialState({});
+const initialState$o = organizationAccessAdapter.getInitialState({});
 const organizationAccessSlice = createSlice({
   name: "organizationAccess",
-  initialState: initialState$p,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
+  initialState: initialState$o,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
   reducers: {
     initializeOrganizationAccesses: organizationAccessAdapter.initialize,
     updateOrganizationAccess: organizationAccessAdapter.updateOne,
@@ -1736,7 +1793,7 @@ const { initializeOrganizationAccesses, updateOrganizationAccess, deleteOrganiza
 const selectOrganizationAccesses = (state) => {
   return state.organizationAccessReducer.instances;
 };
-const selectOrganizationAccess = (organizationAccessId) => (state) => {
+const selectOrganizationAccessById = (organizationAccessId) => (state) => {
   return state.organizationAccessReducer.instances[organizationAccessId];
 };
 const selectActiveOrganizationAccess = createSelector(
@@ -1762,11 +1819,11 @@ const selectOrganizationAccessUserMapping = (state) => {
 };
 const organizationAccessReducer = organizationAccessSlice.reducer;
 const licenseAdapter = createModelAdapter((license) => license.offline_id);
-const initialState$o = licenseAdapter.getInitialState({});
+const initialState$n = licenseAdapter.getInitialState({});
 const licenseSlice = createSlice({
   name: "license",
-  initialState: initialState$o,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
+  initialState: initialState$n,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
   reducers: {
     initializeLicences: licenseAdapter.initialize,
     addLicenses: licenseAdapter.addMany,
@@ -1792,11 +1849,11 @@ const selectLicensesForProjectsMapping = createSelector(
 );
 const licenseReducer = licenseSlice.reducer;
 const projectAccessAdapter = createModelAdapter((projectAccess) => projectAccess.offline_id);
-const initialState$n = projectAccessAdapter.getInitialState({});
+const initialState$m = projectAccessAdapter.getInitialState({});
 const projectAccessSlice = createSlice({
   name: "projectAccess",
-  initialState: initialState$n,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
+  initialState: initialState$m,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
   reducers: {
     initializeProjectAccesses: projectAccessAdapter.initialize,
     updateProjectAccess: projectAccessAdapter.updateOne,
@@ -1814,14 +1871,9 @@ const selectProjectAccesses = createSelector(
     return Object.values(projectAccesses);
   }
 );
-const selectProjectAccess = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectProjectAccessMapping, (_state, projectAccessId) => projectAccessId],
-    (projectAccesses, projectAccessId) => {
-      return projectAccesses[projectAccessId];
-    }
-  )
-);
+const selectProjectAccessById = (projectAccessId) => (state) => {
+  return state.projectAccessReducer.instances[projectAccessId];
+};
 const selectActiveProjectAccess = (state) => {
   const currentUser = state.userReducer.currentUser;
   const activeProjectId = state.projectReducer.activeProjectId;
@@ -1842,14 +1894,14 @@ const selectProjectAccessUserMapping = (state) => {
   return projectAccesses;
 };
 const projectAccessReducer = projectAccessSlice.reducer;
-const initialState$m = {
+const initialState$l = {
   projects: {},
   activeProjectId: null
 };
 const projectSlice = createSlice({
   name: "projects",
-  initialState: initialState$m,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
+  initialState: initialState$l,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
   reducers: {
     setProjects: (state, action) => {
       const projectsMap = {};
@@ -1914,7 +1966,8 @@ const {
   addActiveProjectIssuesCount,
   addActiveProjectFormSubmissionsCount
 } = projectSlice.actions;
-const selectProjects = (state) => state.projectReducer.projects;
+const projectReducer = projectSlice.reducer;
+const selectProjectMapping = (state) => state.projectReducer.projects;
 const selectActiveProjectId = (state) => state.projectReducer.activeProjectId;
 const selectActiveProject = (state) => {
   const activeProjectId = selectActiveProjectId(state);
@@ -1923,23 +1976,19 @@ const selectActiveProject = (state) => {
   }
   return state.projectReducer.projects[activeProjectId] ?? null;
 };
-const selectProject = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectProjects, (_state, projectId) => projectId],
-    (projects, projectId) => projects[projectId]
-  )
-);
-const projectReducer = projectSlice.reducer;
+const selectProjectById = (projectId) => (state) => {
+  return state.projectReducer.projects[projectId];
+};
 const selectProjectUsersIds = createSelector(
   [selectProjectAccessMapping],
   (projectAccesses) => Object.values(projectAccesses).map((projectAccess) => projectAccess.user)
 );
 const selectProjectUsersAsMapping = createSelector(
-  [selectProjectUsersIds, selectUsersAsMapping],
+  [selectProjectUsersIds, selectUsersMapping],
   (projectUserIds, users) => projectUserIds.reduce((accum, userId) => ({ ...accum, [userId]: users[userId] }), {})
 );
 const selectProjectsWithAccess = createSelector(
-  [selectProjects],
+  [selectProjectMapping],
   (projects) => Object.values(projects).filter((project) => !project.invited)
 );
 const selectSortedProjectUsers = createSelector(
@@ -1963,13 +2012,13 @@ const selectSortedProjectUsers = createSelector(
     });
   }
 );
-const initialState$l = {
+const initialState$k = {
   organizations: {}
 };
 const organizationSlice = createSlice({
   name: "organizations",
-  initialState: initialState$l,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
+  initialState: initialState$k,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$k)),
   reducers: {
     setOrganizations: (state, action) => {
       for (const org of action.payload) {
@@ -1997,9 +2046,12 @@ const selectOrganizationUsersIds = createSelector(
   (organizationAccesses) => Object.values(organizationAccesses).map((organizationAccess) => organizationAccess.user)
 );
 const selectProjectsOfOrganization = restructureCreateSelectorWithArgs(
-  createSelector([selectProjects, (_, organizationId) => organizationId], (projects, organizationId) => {
-    return Object.values(projects).filter((project) => project.organization_owner === organizationId);
-  })
+  createSelector(
+    [selectProjectMapping, (_, organizationId) => organizationId],
+    (projects, organizationId) => {
+      return Object.values(projects).filter((project) => project.organization_owner === organizationId);
+    }
+  )
 );
 const selectLicensesOfOrganization = restructureCreateSelectorWithArgs(
   createSelector([selectLicenses, (_, organizationId) => organizationId], (licenses, organizationId) => {
@@ -2007,7 +2059,7 @@ const selectLicensesOfOrganization = restructureCreateSelectorWithArgs(
   })
 );
 const selectOrganizationUsersAsMapping = createSelector(
-  [selectOrganizationUsersIds, selectUsersAsMapping],
+  [selectOrganizationUsersIds, selectUsersMapping],
   (organizationUserIds, users) => organizationUserIds.reduce((accum, userId) => ({ ...accum, [userId]: users[userId] }), {})
 );
 const selectSortedOrganizationUsers = createSelector(
@@ -2052,14 +2104,14 @@ const createOfflineAction = (request2, baseUrl, serviceName) => {
     }
   };
 };
-const initialState$k = {
+const initialState$j = {
   deletedRequests: [],
   latestRetryTime: 0
 };
 const outboxSlice = createSlice({
   name: "outbox",
-  initialState: initialState$k,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$k)),
+  initialState: initialState$j,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
   reducers: {
     // enqueueActions is a reducer that does nothing but enqueue API request to the Redux Offline outbox
     // Whenever an issue is being created, a reducer addIssue() is responsible for adding it to the offline store
@@ -2091,15 +2143,15 @@ const selectDeletedRequests = (state) => state.outboxReducer.deletedRequests;
 const selectLatestRetryTime = (state) => state.outboxReducer.latestRetryTime;
 const { enqueueRequest, markForDeletion, markAsDeleted, _setLatestRetryTime } = outboxSlice.actions;
 const outboxReducer = outboxSlice.reducer;
-const initialState$j = {
+const initialState$i = {
   projectFiles: {},
   activeProjectFileId: null,
   isImportingProjectFile: false
 };
 const projectFileSlice = createSlice({
   name: "projectFiles",
-  initialState: initialState$j,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
+  initialState: initialState$i,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
   reducers: {
     addOrReplaceProjectFiles: (state, action) => {
       for (let fileObj of action.payload) {
@@ -2184,11 +2236,11 @@ const selectProjectFileById = (id) => (state) => {
 };
 const projectFileReducer = projectFileSlice.reducer;
 const projectAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-const initialState$i = projectAttachmentAdapter.getInitialState({});
+const initialState$h = projectAttachmentAdapter.getInitialState({});
 const projectAttachmentSlice = createSlice({
   name: "projectAttachments",
-  initialState: initialState$i,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
+  initialState: initialState$h,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$h)),
   reducers: {
     initializeProjectAttachments: projectAttachmentAdapter.initialize,
     addProjectAttachment: projectAttachmentAdapter.addOne,
@@ -2246,12 +2298,12 @@ const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
   )
 );
 const projectAttachmentReducer = projectAttachmentSlice.reducer;
-const initialState$h = {
+const initialState$g = {
   isRehydrated: false
 };
 const rehydratedSlice = createSlice({
   name: "rehydrated",
-  initialState: initialState$h,
+  initialState: initialState$g,
   // The `reducers` field lets us define reducers and generate associated actions
   reducers: {
     setRehydrated: (state, action) => {
@@ -2262,22 +2314,6 @@ const rehydratedSlice = createSlice({
 const { setRehydrated } = rehydratedSlice.actions;
 const selectRehydrated = (state) => state.rehydratedReducer.isRehydrated;
 const rehydratedReducer = rehydratedSlice.reducer;
-const initialState$g = {
-  isFetchingInitialData: false
-};
-const settingSlice = createSlice({
-  name: "settings",
-  initialState: initialState$g,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
-  reducers: {
-    setIsFetchingInitialData: (state, action) => {
-      state.isFetchingInitialData = action.payload;
-    }
-  }
-});
-const { setIsFetchingInitialData } = settingSlice.actions;
-const settingReducer = settingSlice.reducer;
-const selectIsFetchingInitialData = (state) => state.settingReducer.isFetchingInitialData;
 const formRevisionSortFn = (formRevisionA, formRevisionB) => {
   const revisionA = formRevisionA.revision;
   const revisionB = formRevisionB.revision;
@@ -2319,7 +2355,7 @@ const selectFormRevisions = createSelector(
   [selectFormRevisionMapping],
   (formRevisions) => Object.values(formRevisions)
 );
-const selectFormRevision = (formRevisionId) => (state) => {
+const selectFormRevisionById = (formRevisionId) => (state) => {
   return state.formRevisionReducer.instances[formRevisionId];
 };
 const _selectLatestFormRevision = (formRevisions, formId) => {
@@ -2450,12 +2486,12 @@ const selectFilteredForms = restructureCreateSelectorWithArgs(
     { memoizeOptions: { equalityCheck: shallowEqual } }
   )
 );
-const selectForm = (formId) => (state) => {
-  return state.formReducer.instances[formId];
-};
 const selectFormMapping = (state) => {
   return state.formReducer.instances;
 };
+const selectFormById = (formId) => (state) => {
+  return state.formReducer.instances[formId];
+};
 const selectFormOfAssetType = restructureCreateSelectorWithArgs(
   createSelector(
     [selectFormMapping, (_state, assetTypeId) => assetTypeId],
@@ -2517,7 +2553,7 @@ const selectFormSubmissions = createSelector(
     return Object.values(submissions);
   }
 );
-const selectFormSubmission = (submissionId) => (state) => {
+const selectFormSubmissionById = (submissionId) => (state) => {
   return state.formSubmissionReducer.instances[submissionId];
 };
 const selectFormSubmissionsOfForm = restructureCreateSelectorWithArgs(
@@ -2723,6 +2759,15 @@ const {
 const selectFormSubmissionAttachmentsMapping = (state) => {
   return state.formSubmissionAttachmentReducer.instances;
 };
+const selectFormSubmissionAttachemntsByIds = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectFormSubmissionAttachmentsMapping, (_, attachmentIds) => attachmentIds],
+    (mapping, attachmentIds) => {
+      const attachmentIdsSet = new Set(attachmentIds);
+      return Object.values(mapping).filter((attachment) => attachmentIdsSet.has(attachment.offline_id));
+    }
+  )
+);
 const selectAttachmentsOfFormSubmission = restructureCreateSelectorWithArgs(
   createSelector(
     [selectFormSubmissionAttachmentsMapping, (_state, submissionId) => submissionId],
@@ -2954,10 +2999,24 @@ const selectDocuments = createSelector(
   [selectDocumentsMapping],
   (mapping) => Object.values(mapping)
 );
-const selectDocument = restructureCreateSelectorWithArgs(
+const selectDocumentById = (documentId) => (state) => {
+  return state.documentsReducer.documents[documentId];
+};
+const selectDocumentsByIds = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectDocumentsMapping, (_state, documentId) => documentId],
-    (mapping, documentId) => mapping[documentId]
+    [selectDocumentsMapping, (_state, documentIds) => documentIds],
+    (mapping, documentIds) => {
+      const documents = [];
+      for (const documentId of documentIds) {
+        const document2 = mapping[documentId];
+        if (document2) {
+          documents.push(document2);
+        } else {
+          console.warn("selectDocumentByIds: No document exists with the id", documentId);
+        }
+      }
+      return documents;
+    }
   )
 );
 const selectAncestorIdsOfDocument = restructureCreateSelectorWithArgs(
@@ -3061,7 +3120,7 @@ const selectTeamsMapping = (state) => state.teamReducer.instances;
 const selectTeams = createSelector([selectTeamsMapping], (teams) => {
   return Object.values(teams);
 });
-const selectTeam = (teamId) => (state) => {
+const selectTeamById = (teamId) => (state) => {
   return state.teamReducer.instances[teamId];
 };
 const selectTeamsOfOrganization = restructureCreateSelectorWithArgs(
@@ -3318,6 +3377,9 @@ const {
   deleteIssueAssociations
 } = issueAssociationSlice.actions;
 const selectIssueAssociationMapping = (state) => state.issueAssociationReducer.instances;
+const selectIssueAssociations = createSelector([selectIssueAssociationMapping], (associations) => {
+  return Object.values(associations);
+});
 const selectIssueAssociationById = (id) => (state) => {
   return state.issueAssociationReducer.instances[id];
 };
@@ -3402,7 +3464,6 @@ const overmapReducers = {
   organizationAccessReducer,
   projectFileReducer,
   rehydratedReducer,
-  settingReducer,
   formReducer,
   formRevisionReducer,
   formRevisionAttachmentReducer,
@@ -4211,7 +4272,7 @@ class AssetService extends BaseApiService {
   async remove(assetId) {
     const { store } = this.client;
     const state = store.getState();
-    const assetToBeDeleted = selectAsset(assetId)(state);
+    const assetToBeDeleted = selectAssetById(assetId)(state);
     if (!assetToBeDeleted)
       throw new Error(`No asset with id ${assetId} found in the store`);
     const attachmentsOfAssets = selectAttachmentsOfAsset(assetId)(state);
@@ -4327,7 +4388,7 @@ class AssetStageCompletionService extends BaseApiService {
   add(assetId, stageId) {
     var _a2;
     const { store } = this.client;
-    const assetTypeId = (_a2 = selectAsset(assetId)(store.getState())) == null ? void 0 : _a2.asset_type;
+    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`);
     }
@@ -4433,12 +4494,7 @@ class AssetStageService extends BaseApiService {
   async bulkUpdateStages(stagesToUpdate, assetTypeId) {
     const store = this.client.store;
     const state = store.getState();
-    const prevStages = selectStagesFromStageIds(
-      stagesToUpdate.map(({ offline_id }) => offline_id)
-    )(state);
-    if (!prevStages) {
-      throw new Error("Could not find the desired stages to update within the store");
-    }
+    const prevStages = selectAssetStagesByIds(stagesToUpdate.map(({ offline_id }) => offline_id))(state);
     this.dispatch(updateStages(stagesToUpdate));
     return this.enqueueRequest({
       description: "Edit asset stages",
@@ -4761,7 +4817,7 @@ class AssetTypeService extends BaseApiService {
   async delete(assetTypeId) {
     const { store } = this.client;
     const state = store.getState();
-    const assetType = selectAssetType(assetTypeId)(state);
+    const assetType = selectAssetTypeById(assetTypeId)(state);
     if (!assetType) {
       throw new Error(`Expected asset type with offline_id ${assetTypeId} to exist`);
     }
@@ -5015,7 +5071,7 @@ class IssueService extends BaseApiService {
   }
   update(issue) {
     const state = this.client.store.getState();
-    const issueToBeUpdated = selectIssue(issue.offline_id)(state);
+    const issueToBeUpdated = selectIssueById(issue.offline_id)(state);
     if (!issueToBeUpdated) {
       throw new Error(
         `Attempting to update an issue with offline_id ${issue.offline_id} that doesn't exist in the store`
@@ -5109,7 +5165,7 @@ class IssueService extends BaseApiService {
   async remove(id) {
     const { store } = this.client;
     const state = store.getState();
-    const backup = selectIssue(id)(state);
+    const backup = selectIssueById(id)(state);
     if (!backup) {
       throw new Error(`No issue with id ${id} found in the store`);
     }
@@ -5190,7 +5246,7 @@ class IssueTypeService extends BaseApiService {
         offline_id: offlineIssueType.offline_id,
         submitted_at: offlineIssueType.submitted_at,
         icon: offlineIssueType.icon,
-        icon_color: offlineIssueType.color,
+        color: offlineIssueType.color,
         name: offlineIssueType.name,
         description: offlineIssueType.description
       },
@@ -5204,24 +5260,24 @@ class IssueTypeService extends BaseApiService {
     });
     return [offlineIssueType, promise];
   }
-  update(issueTypeFields) {
+  update(payload) {
     const { store } = this.client;
     const state = store.getState();
-    const issueTypeToBeUpdated = selectIssueType(issueTypeFields.offline_id)(state);
+    const issueTypeToBeUpdated = selectIssueTypeById(payload.offline_id)(state);
     if (!issueTypeToBeUpdated) {
-      throw new Error(`IssueType with offline_id ${issueTypeFields.offline_id} does not exist in the store.`);
+      throw new Error(`IssueType with offline_id ${payload.offline_id} does not exist in the store.`);
     }
     const offlineUpdatedIssueType = {
       ...issueTypeToBeUpdated,
-      ...issueTypeFields
+      ...payload
     };
     this.dispatch(updateIssueType(offlineUpdatedIssueType));
     const promise = this.enqueueRequest({
       method: HttpMethod.PATCH,
-      url: `/issues/types/${issueTypeFields.offline_id}/`,
-      payload: issueTypeFields,
-      blockers: [issueTypeFields.offline_id],
-      blocks: [issueTypeFields.offline_id]
+      url: `/issues/types/${payload.offline_id}/`,
+      payload,
+      blockers: [payload.offline_id],
+      blocks: [payload.offline_id]
     });
     promise.then((updatedIssueType) => {
       this.dispatch(setIssueType(updatedIssueType));
@@ -5233,7 +5289,7 @@ class IssueTypeService extends BaseApiService {
   delete(issueTypeId) {
     const { store } = this.client;
     const state = store.getState();
-    const issueTypeToDelete = selectIssueType(issueTypeId)(state);
+    const issueTypeToDelete = selectIssueTypeById(issueTypeId)(state);
     if (!issueTypeToDelete) {
       throw new Error(`IssueType with offline_id ${issueTypeId} does not exist in the store.`);
     }
@@ -5481,7 +5537,7 @@ class ProjectService extends BaseApiService {
   async delete(projectId) {
     const { store } = this.client;
     const state = store.getState();
-    const projects = selectProjects(state);
+    const projects = selectProjectMapping(state);
     const project = projects[projectId];
     if (!project) {
       throw new Error("Expected project to exist");
@@ -5824,7 +5880,7 @@ class FormService extends BaseUploadService {
   async delete(formId) {
     const { store } = this.client;
     const state = store.getState();
-    const form = selectForm(formId)(state);
+    const form = selectFormById(formId)(state);
     if (!form) {
       throw new Error("Expected form to exist");
     }
@@ -6001,6 +6057,25 @@ class FormSubmissionService extends BaseUploadService {
     });
     return [offlineFormSubmissionAttachments, promise.then(({ attachments }) => attachments)];
   }
+  async bulkDeleteSubmissionAttachments(submissionId, attachmentsIds) {
+    const { store } = this.client;
+    const state = store.getState();
+    const formSubmissionAttachments = selectFormSubmissionAttachemntsByIds(attachmentsIds)(state);
+    this.dispatch(deleteFormSubmissionAttachments(attachmentsIds));
+    try {
+      await this.enqueueRequest({
+        description: "Delete form submission attachments",
+        method: HttpMethod.DELETE,
+        url: `/forms/submissions/${submissionId}/attachments/bulk/`,
+        payload: { attachments: attachmentsIds },
+        blockers: [submissionId, ...attachmentsIds],
+        blocks: []
+      });
+    } catch (e) {
+      this.dispatch(addFormSubmissionAttachments(formSubmissionAttachments));
+      throw e;
+    }
+  }
   // Outer promise is for hashing and caching files for submission attachments
   async add(payload) {
     const { store } = this.client;
@@ -6140,10 +6215,64 @@ class FormSubmissionService extends BaseUploadService {
     });
     return batchPromises;
   }
+  async update(payload) {
+    const { store } = this.client;
+    const state = store.getState();
+    const submissionToBeUpdated = selectFormSubmissionById(payload.offline_id)(state);
+    if (!submissionToBeUpdated) {
+      throw new Error(`Expected submission with offline_id ${payload.offline_id} to exist`);
+    }
+    const { values, files } = separateFilesFromValues(payload.values ?? {});
+    const updatedSubmission = {
+      ...submissionToBeUpdated,
+      ...payload,
+      // values could also have a partial update
+      values: {
+        ...submissionToBeUpdated.values,
+        ...values
+      }
+    };
+    this.dispatch(updateFormSubmission(updatedSubmission));
+    const promise = this.enqueueRequest({
+      description: "Delete user form submissions",
+      method: HttpMethod.PATCH,
+      url: `/forms/submissions/${updatedSubmission.offline_id}/`,
+      payload: updatedSubmission,
+      blockers: [updatedSubmission.offline_id],
+      blocks: [updatedSubmission.offline_id]
+    });
+    const formSubmissionAttachments = selectAttachmentsOfFormSubmission(payload.offline_id)(state);
+    const formSubmissionAttachmentIdsToBeDeleted = [];
+    for (const attachment of formSubmissionAttachments) {
+      if (attachment.field_identifier in files) {
+        formSubmissionAttachmentIdsToBeDeleted.push(attachment.offline_id);
+      }
+    }
+    const [offlineFormSubmissionAttachments, attachmentsPromise] = await this.bulkAddSubmissionAttachments(
+      payload.offline_id,
+      files
+    );
+    const deleteAttachmentsPromise = this.bulkDeleteSubmissionAttachments(
+      payload.offline_id,
+      formSubmissionAttachmentIdsToBeDeleted
+    );
+    promise.then((result) => {
+      this.dispatch(setFormSubmission(result));
+    }).catch(() => {
+      this.dispatch(setFormSubmission(submissionToBeUpdated));
+    });
+    return [
+      updatedSubmission,
+      offlineFormSubmissionAttachments,
+      promise,
+      attachmentsPromise,
+      deleteAttachmentsPromise
+    ];
+  }
   async delete(submissionId) {
     const { store } = this.client;
     const state = store.getState();
-    const submissionToBeDeleted = selectFormSubmission(submissionId)(store.getState());
+    const submissionToBeDeleted = selectFormSubmissionById(submissionId)(state);
     if (!submissionToBeDeleted) {
       throw new Error(`Expected submission with offline_id ${submissionId} to exist`);
     }
@@ -7033,7 +7162,7 @@ class TeamService extends BaseApiService {
   // TODO: @Audiopolis / Magnus - should we pass a offline_id as one arg and a UpdatedTeamProps as a second arg instead of this set up?
   update(team) {
     const { store } = this.client;
-    const teamToBeUpdated = selectTeam(team.offline_id)(store.getState());
+    const teamToBeUpdated = selectTeamById(team.offline_id)(store.getState());
     if (!teamToBeUpdated) {
       throw new Error(`Expected team with offline_id ${team.offline_id} to exist`);
     }
@@ -7060,7 +7189,7 @@ class TeamService extends BaseApiService {
   async delete(teamId) {
     const { store } = this.client;
     const state = store.getState();
-    const team = selectTeam(teamId)(state);
+    const team = selectTeamById(teamId)(state);
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7080,7 +7209,7 @@ class TeamService extends BaseApiService {
   }
   async setMembers(teamId, members) {
     const { store } = this.client;
-    const team = selectTeam(teamId)(store.getState());
+    const team = selectTeamById(teamId)(store.getState());
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7105,7 +7234,7 @@ class TeamService extends BaseApiService {
   }
   async addMembers(teamId, members) {
     const { store } = this.client;
-    const team = selectTeam(teamId)(store.getState());
+    const team = selectTeamById(teamId)(store.getState());
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7114,7 +7243,7 @@ class TeamService extends BaseApiService {
   }
   async removeMembers(teamId, members) {
     const { store } = this.client;
-    const team = selectTeam(teamId)(store.getState());
+    const team = selectTeamById(teamId)(store.getState());
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7727,21 +7856,25 @@ export {
   selectAllDocumentAttachments,
   selectAllProjectAttachments,
   selectAncestorIdsOfDocument,
-  selectAsset,
   selectAssetAttachment,
   selectAssetAttachmentMapping,
   selectAssetAttachments,
+  selectAssetById,
+  selectAssetStageById,
+  selectAssetStages,
+  selectAssetStagesByIds,
   selectAssetToAssetTypeMapping,
-  selectAssetType,
   selectAssetTypeAttachment,
   selectAssetTypeAttachmentMapping,
   selectAssetTypeAttachments,
+  selectAssetTypeById,
   selectAssetTypeStagesMapping,
   selectAssetTypes,
-  selectAssetTypesByName,
+  selectAssetTypesByIds,
   selectAssetTypesFromIds,
   selectAssetTypesMapping,
   selectAssets,
+  selectAssetsByIds,
   selectAssetsMapping,
   selectAssetsOfAssetType,
   selectAttachedFormSubmissionsOfAsset,
@@ -7759,6 +7892,7 @@ export {
   selectAttachmentsOfProject,
   selectAttachmentsOfProjectByType,
   selectCategories,
+  selectCategoriesByIds,
   selectCategoriesOfWorkspace,
   selectCategoryById,
   selectCategoryMapping,
@@ -7770,27 +7904,29 @@ export {
   selectConversations,
   selectCurrentUser,
   selectDeletedRequests,
-  selectDocument,
   selectDocumentAttachment,
   selectDocumentAttachmentMapping,
+  selectDocumentById,
   selectDocuments,
+  selectDocumentsByIds,
   selectDocumentsMapping,
   selectEmailDomains,
   selectEmailDomainsAsMapping,
   selectEmailDomainsOfOrganization,
   selectFavouriteProjects,
   selectFilteredForms,
-  selectForm,
+  selectFormById,
   selectFormMapping,
   selectFormOfAssetType,
   selectFormOfIssueType,
-  selectFormRevision,
   selectFormRevisionAttachmentsMapping,
+  selectFormRevisionById,
   selectFormRevisionMapping,
   selectFormRevisions,
   selectFormRevisionsOfForm,
-  selectFormSubmission,
+  selectFormSubmissionAttachemntsByIds,
   selectFormSubmissionAttachmentsMapping,
+  selectFormSubmissionById,
   selectFormSubmissions,
   selectFormSubmissionsByAssets,
   selectFormSubmissionsByFormRevisions,
@@ -7806,27 +7942,29 @@ export {
   selectGeoImageMapping,
   selectGeoImages,
   selectGeoImagesOfProject,
-  selectIsFetchingInitialData,
   selectIsImportingProjectFile,
   selectIsLoggedIn,
-  selectIssue,
   selectIssueAssociationById,
   selectIssueAssociationMapping,
+  selectIssueAssociations,
   selectIssueAssociationsOfAsset,
   selectIssueAssociationsOfIssue,
   selectIssueAssociationsToIssue,
   selectIssueAttachment,
   selectIssueAttachmentMapping,
   selectIssueAttachments,
+  selectIssueById,
   selectIssueCommentMapping,
   selectIssueCountOfCategory,
   selectIssueMapping,
-  selectIssueType,
+  selectIssueTypeById,
   selectIssueTypeMapping,
   selectIssueTypes,
+  selectIssueTypesByIds,
   selectIssueTypesOfOrganization,
   selectIssueUpdateMapping,
   selectIssueUpdatesOfIssue,
+  selectIssuesByIds,
   selectIssuesOfIssueType,
   selectIssuesOfIssueTypeCount,
   selectLatestFormRevisionByForm,
@@ -7839,10 +7977,9 @@ export {
   selectLicensesForProjectsMapping,
   selectLicensesOfOrganization,
   selectMainWorkspace,
-  selectNumberOfAssetTypesMatchingCaseInsensitiveName,
   selectNumberOfAssetsOfAssetType,
   selectOrganization,
-  selectOrganizationAccess,
+  selectOrganizationAccessById,
   selectOrganizationAccessForUser,
   selectOrganizationAccessUserMapping,
   selectOrganizationAccesses,
@@ -7853,20 +7990,20 @@ export {
   selectOrganizationsMapping,
   selectOrganizationsWithAccess,
   selectPermittedWorkspaceIds,
-  selectProject,
-  selectProjectAccess,
+  selectProjectAccessById,
   selectProjectAccessForUser,
   selectProjectAccessMapping,
   selectProjectAccessUserMapping,
   selectProjectAccesses,
   selectProjectAttachment,
   selectProjectAttachmentMapping,
+  selectProjectById,
   selectProjectFileById,
   selectProjectFileMapping,
   selectProjectFiles,
+  selectProjectMapping,
   selectProjectUsersAsMapping,
   selectProjectUsersIds,
-  selectProjects,
   selectProjectsOfOrganization,
   selectProjectsWithAccess,
   selectRecentIssueIds,
@@ -7876,21 +8013,20 @@ export {
   selectSortedFormSubmissionsOfForm,
   selectSortedOrganizationUsers,
   selectSortedProjectUsers,
-  selectStage,
   selectStageFormIdsFromStageIds,
   selectStageMapping,
-  selectStages,
   selectStagesFromAssetTypeIds,
-  selectStagesFromStageIds,
   selectStagesOfAssetType,
-  selectTeam,
+  selectTeamById,
   selectTeams,
   selectTeamsMapping,
   selectTeamsOfOrganization,
   selectTeamsOfUser,
   selectUploadUrl,
   selectUser,
-  selectUsersAsMapping,
+  selectUserById,
+  selectUsersByIds,
+  selectUsersMapping,
   selectWorkspaceById,
   selectWorkspaceMapping,
   selectWorkspaces,
@@ -7917,7 +8053,6 @@ export {
   setFormSubmissions,
   setGeoImage,
   setGeoImages,
-  setIsFetchingInitialData,
   setIsImportingProjectFile,
   setIssueAssociation,
   setIssueAssociations,
@@ -7942,8 +8077,6 @@ export {
   setUploadUrl,
   setUsers,
   setWorkspaces,
-  settingReducer,
-  settingSlice,
   shallowEqual,
   slugify,
   spacesToDashesLower,