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

package/dist/overmap-core.umd.cjs

@@ -367,15 +367,15 @@ var __publicField = (obj, key, value) => {
   };
   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 = toolkit.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;
@@ -845,11 +845,11 @@ var __publicField = (obj, key, value) => {
     };
   }
   const categoryAdapter = createModelAdapter((category) => category.offline_id);
-  const initialState$B = categoryAdapter.getInitialState({});
+  const initialState$A = categoryAdapter.getInitialState({});
   const categorySlice = toolkit.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,
@@ -862,28 +862,131 @@ var __publicField = (obj, key, value) => {
   const selectCategories = toolkit.createSelector([selectCategoryMapping], (categoryMapping) => {
     return Object.values(categoryMapping);
   });
-  const selectCategoriesOfWorkspace = restructureCreateSelectorWithArgs(
+  const selectCategoryById = (id) => (state) => {
+    return state.categoryReducer.instances[id];
+  };
+  const selectCategoriesByIds = restructureCreateSelectorWithArgs(
     toolkit.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(
     toolkit.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 = toolkit.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(
+    toolkit.createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
+      return stageMapping[stageId];
+    })
+  );
+  const selectAssetStages = toolkit.createSelector([selectStageMapping], (stageMapping) => {
+    return Object.values(stageMapping);
+  });
+  const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
+    toolkit.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(
+    toolkit.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(
+    toolkit.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(
+    toolkit.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(
+    toolkit.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 = toolkit.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,
@@ -896,43 +999,33 @@ var __publicField = (obj, key, value) => {
     [selectAssetTypesMapping],
     (mapping) => Object.values(mapping)
   );
-  const selectAssetType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAssetTypesMapping, (_state, assetTypeId) => assetTypeId],
-      (mapping, assetTypeId) => mapping[assetTypeId]
-    )
-  );
-  const selectNumberOfAssetTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
+  const selectAssetTypeById = (id) => (state) => {
+    return state.assetTypeReducer.instances[id];
+  };
+  const selectAssetTypesByIds = restructureCreateSelectorWithArgs(
     toolkit.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(
-    toolkit.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 = toolkit.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);
@@ -996,9 +1089,20 @@ var __publicField = (obj, key, value) => {
       return components.filter((asset) => asset.asset_type === assetTypeId);
     })
   );
-  const selectAsset = (assetId) => (state) => {
+  const selectAssetById = (assetId) => (state) => {
     return state.assetReducer.instances[assetId];
   };
+  const selectAssetsByIds = restructureCreateSelectorWithArgs(
+    toolkit.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 = toolkit.createSelector(
     [selectAssets, selectAssetTypesMapping],
     (assets, assetTypeMapping) => {
@@ -1035,11 +1139,11 @@ var __publicField = (obj, key, value) => {
   };
   const assetReducer = assetSlice.reducer;
   const assetAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$y = assetAttachmentAdapter.getInitialState({});
+  const initialState$w = assetAttachmentAdapter.getInitialState({});
   const assetAttachmentSlice = toolkit.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,
@@ -1097,13 +1201,13 @@ var __publicField = (obj, key, value) => {
     )
   );
   const assetAttachmentReducer = assetAttachmentSlice.reducer;
-  const initialState$x = {
+  const initialState$v = {
     completionsByAssetId: {}
   };
   const assetStageCompletionSlice = toolkit.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];
@@ -1154,97 +1258,14 @@ var __publicField = (obj, key, value) => {
     })
   );
   const assetStageCompletionReducer = assetStageCompletionSlice.reducer;
-  const assetStageAdapter = createModelAdapter((assetStage) => assetStage.offline_id);
-  const initialState$w = assetStageAdapter.getInitialState({});
-  const assetStageSlice = toolkit.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(
-    toolkit.createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
-      return stageMapping[stageId];
-    })
-  );
-  const selectStages = toolkit.createSelector(
-    [selectStageMapping],
-    (stageMapping) => {
-      return Object.values(stageMapping);
-    }
-  );
-  const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
-    toolkit.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(
-    toolkit.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(
-    toolkit.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(
-    toolkit.createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
-      return stageIds.map((offline_id) => stageMapping[offline_id]).filter((stage) => !!stage);
-    })
-  );
-  const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
-    toolkit.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 = toolkit.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,
@@ -1303,10 +1324,10 @@ var __publicField = (obj, key, value) => {
   );
   const assetTypeAttachmentReducer = assetTypeAttachmentSlice.reducer;
   const workspaceAdapter = createModelAdapter((workspace) => workspace.offline_id);
-  const initialState$u = workspaceAdapter.getInitialState({});
+  const initialState$t = workspaceAdapter.getInitialState({});
   const workspaceSlice = toolkit.createSlice({
     name: "workspace",
-    initialState: initialState$u,
+    initialState: initialState$t,
     reducers: {
       initializeWorkspaces: workspaceAdapter.initialize,
       setWorkspaces: workspaceAdapter.setMany,
@@ -1338,14 +1359,14 @@ var __publicField = (obj, key, value) => {
   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 = toolkit.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,
@@ -1393,11 +1414,9 @@ var __publicField = (obj, key, value) => {
   } = issueSlice.actions;
   const selectIssueMapping = (state) => state.issueReducer.instances;
   const selectRecentIssueIds = (state) => state.issueReducer.recentIssueIds;
-  const selectIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectIssueMapping, (_state, id) => id], (mapping, id) => {
-      return mapping[id];
-    })
-  );
+  const selectIssueById = (id) => (state) => {
+    return state.issueReducer.instances[id];
+  };
   const searchIssues = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [selectIssueMapping, selectWorkspaceMapping, (_state, searchArgs) => searchArgs],
@@ -1453,6 +1472,20 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
+  const selectIssuesByIds = restructureCreateSelectorWithArgs(
+    toolkit.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 = toolkit.createSelector(
     [selectIssueMapping, selectRecentIssueIds, selectWorkspaceMapping],
     (issueMapping, recentIssueIds, workspaceMapping) => {
@@ -1489,12 +1522,12 @@ var __publicField = (obj, key, value) => {
   );
   const issueReducer = issueSlice.reducer;
   const issueTypeAdapter = createModelAdapter((issueType) => issueType.offline_id);
-  const initialState$s = issueTypeAdapter.getInitialState({});
+  const initialState$r = issueTypeAdapter.getInitialState({});
   const issueTypeSlice = toolkit.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,
@@ -1514,14 +1547,21 @@ var __publicField = (obj, key, value) => {
       return Object.values(issueTypes);
     }
   );
-  const selectIssueType = restructureCreateSelectorWithArgs(
-    toolkit.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(
     toolkit.createSelector(
       [selectIssueTypes, (_, organizationId) => organizationId],
@@ -1543,15 +1583,15 @@ var __publicField = (obj, key, value) => {
     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 = toolkit.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;
@@ -1632,7 +1672,7 @@ var __publicField = (obj, key, value) => {
     LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
     return LicenseStatus2;
   })(LicenseStatus || {});
-  const initialState$q = {
+  const initialState$p = {
     users: {},
     currentUser: {
       id: 0,
@@ -1643,8 +1683,8 @@ var __publicField = (obj, key, value) => {
   };
   const userSlice = toolkit.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 = {};
@@ -1697,23 +1737,40 @@ var __publicField = (obj, key, value) => {
     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(
+    toolkit.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 = toolkit.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,
@@ -1724,7 +1781,7 @@ var __publicField = (obj, key, value) => {
   const selectOrganizationAccesses = (state) => {
     return state.organizationAccessReducer.instances;
   };
-  const selectOrganizationAccess = (organizationAccessId) => (state) => {
+  const selectOrganizationAccessById = (organizationAccessId) => (state) => {
     return state.organizationAccessReducer.instances[organizationAccessId];
   };
   const selectActiveOrganizationAccess = toolkit.createSelector(
@@ -1750,11 +1807,11 @@ var __publicField = (obj, key, value) => {
   };
   const organizationAccessReducer = organizationAccessSlice.reducer;
   const licenseAdapter = createModelAdapter((license) => license.offline_id);
-  const initialState$o = licenseAdapter.getInitialState({});
+  const initialState$n = licenseAdapter.getInitialState({});
   const licenseSlice = toolkit.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,
@@ -1780,11 +1837,11 @@ var __publicField = (obj, key, value) => {
   );
   const licenseReducer = licenseSlice.reducer;
   const projectAccessAdapter = createModelAdapter((projectAccess) => projectAccess.offline_id);
-  const initialState$n = projectAccessAdapter.getInitialState({});
+  const initialState$m = projectAccessAdapter.getInitialState({});
   const projectAccessSlice = toolkit.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,
@@ -1802,14 +1859,9 @@ var __publicField = (obj, key, value) => {
       return Object.values(projectAccesses);
     }
   );
-  const selectProjectAccess = restructureCreateSelectorWithArgs(
-    toolkit.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;
@@ -1830,14 +1882,14 @@ var __publicField = (obj, key, value) => {
     return projectAccesses;
   };
   const projectAccessReducer = projectAccessSlice.reducer;
-  const initialState$m = {
+  const initialState$l = {
     projects: {},
     activeProjectId: null
   };
   const projectSlice = toolkit.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 = {};
@@ -1902,7 +1954,8 @@ var __publicField = (obj, key, value) => {
     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);
@@ -1911,23 +1964,19 @@ var __publicField = (obj, key, value) => {
     }
     return state.projectReducer.projects[activeProjectId] ?? null;
   };
-  const selectProject = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectProjects, (_state, projectId) => projectId],
-      (projects, projectId) => projects[projectId]
-    )
-  );
-  const projectReducer = projectSlice.reducer;
+  const selectProjectById = (projectId) => (state) => {
+    return state.projectReducer.projects[projectId];
+  };
   const selectProjectUsersIds = toolkit.createSelector(
     [selectProjectAccessMapping],
     (projectAccesses) => Object.values(projectAccesses).map((projectAccess) => projectAccess.user)
   );
   const selectProjectUsersAsMapping = toolkit.createSelector(
-    [selectProjectUsersIds, selectUsersAsMapping],
+    [selectProjectUsersIds, selectUsersMapping],
     (projectUserIds, users) => projectUserIds.reduce((accum, userId) => ({ ...accum, [userId]: users[userId] }), {})
   );
   const selectProjectsWithAccess = toolkit.createSelector(
-    [selectProjects],
+    [selectProjectMapping],
     (projects) => Object.values(projects).filter((project) => !project.invited)
   );
   const selectSortedProjectUsers = toolkit.createSelector(
@@ -1951,13 +2000,13 @@ var __publicField = (obj, key, value) => {
       });
     }
   );
-  const initialState$l = {
+  const initialState$k = {
     organizations: {}
   };
   const organizationSlice = toolkit.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) {
@@ -1985,9 +2034,12 @@ var __publicField = (obj, key, value) => {
     (organizationAccesses) => Object.values(organizationAccesses).map((organizationAccess) => organizationAccess.user)
   );
   const selectProjectsOfOrganization = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectProjects, (_, organizationId) => organizationId], (projects, organizationId) => {
-      return Object.values(projects).filter((project) => project.organization_owner === organizationId);
-    })
+    toolkit.createSelector(
+      [selectProjectMapping, (_, organizationId) => organizationId],
+      (projects, organizationId) => {
+        return Object.values(projects).filter((project) => project.organization_owner === organizationId);
+      }
+    )
   );
   const selectLicensesOfOrganization = restructureCreateSelectorWithArgs(
     toolkit.createSelector([selectLicenses, (_, organizationId) => organizationId], (licenses, organizationId) => {
@@ -1995,7 +2047,7 @@ var __publicField = (obj, key, value) => {
     })
   );
   const selectOrganizationUsersAsMapping = toolkit.createSelector(
-    [selectOrganizationUsersIds, selectUsersAsMapping],
+    [selectOrganizationUsersIds, selectUsersMapping],
     (organizationUserIds, users) => organizationUserIds.reduce((accum, userId) => ({ ...accum, [userId]: users[userId] }), {})
   );
   const selectSortedOrganizationUsers = toolkit.createSelector(
@@ -2040,14 +2092,14 @@ var __publicField = (obj, key, value) => {
       }
     };
   };
-  const initialState$k = {
+  const initialState$j = {
     deletedRequests: [],
     latestRetryTime: 0
   };
   const outboxSlice = toolkit.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
@@ -2079,15 +2131,15 @@ var __publicField = (obj, key, value) => {
   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 = toolkit.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) {
@@ -2172,11 +2224,11 @@ var __publicField = (obj, key, value) => {
   };
   const projectFileReducer = projectFileSlice.reducer;
   const projectAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$i = projectAttachmentAdapter.getInitialState({});
+  const initialState$h = projectAttachmentAdapter.getInitialState({});
   const projectAttachmentSlice = toolkit.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,
@@ -2234,12 +2286,12 @@ var __publicField = (obj, key, value) => {
     )
   );
   const projectAttachmentReducer = projectAttachmentSlice.reducer;
-  const initialState$h = {
+  const initialState$g = {
     isRehydrated: false
   };
   const rehydratedSlice = toolkit.createSlice({
     name: "rehydrated",
-    initialState: initialState$h,
+    initialState: initialState$g,
     // The `reducers` field lets us define reducers and generate associated actions
     reducers: {
       setRehydrated: (state, action) => {
@@ -2250,22 +2302,6 @@ var __publicField = (obj, key, value) => {
   const { setRehydrated } = rehydratedSlice.actions;
   const selectRehydrated = (state) => state.rehydratedReducer.isRehydrated;
   const rehydratedReducer = rehydratedSlice.reducer;
-  const initialState$g = {
-    isFetchingInitialData: false
-  };
-  const settingSlice = toolkit.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;
@@ -2307,7 +2343,7 @@ var __publicField = (obj, key, value) => {
     [selectFormRevisionMapping],
     (formRevisions) => Object.values(formRevisions)
   );
-  const selectFormRevision = (formRevisionId) => (state) => {
+  const selectFormRevisionById = (formRevisionId) => (state) => {
     return state.formRevisionReducer.instances[formRevisionId];
   };
   const _selectLatestFormRevision = (formRevisions, formId) => {
@@ -2438,12 +2474,12 @@ var __publicField = (obj, key, value) => {
       { 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(
     toolkit.createSelector(
       [selectFormMapping, (_state, assetTypeId) => assetTypeId],
@@ -2505,7 +2541,7 @@ var __publicField = (obj, key, value) => {
       return Object.values(submissions);
     }
   );
-  const selectFormSubmission = (submissionId) => (state) => {
+  const selectFormSubmissionById = (submissionId) => (state) => {
     return state.formSubmissionReducer.instances[submissionId];
   };
   const selectFormSubmissionsOfForm = restructureCreateSelectorWithArgs(
@@ -2711,6 +2747,15 @@ var __publicField = (obj, key, value) => {
   const selectFormSubmissionAttachmentsMapping = (state) => {
     return state.formSubmissionAttachmentReducer.instances;
   };
+  const selectFormSubmissionAttachemntsByIds = restructureCreateSelectorWithArgs(
+    toolkit.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(
     toolkit.createSelector(
       [selectFormSubmissionAttachmentsMapping, (_state, submissionId) => submissionId],
@@ -2942,10 +2987,24 @@ var __publicField = (obj, key, value) => {
     [selectDocumentsMapping],
     (mapping) => Object.values(mapping)
   );
-  const selectDocument = restructureCreateSelectorWithArgs(
+  const selectDocumentById = (documentId) => (state) => {
+    return state.documentsReducer.documents[documentId];
+  };
+  const selectDocumentsByIds = restructureCreateSelectorWithArgs(
     toolkit.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(
@@ -3049,7 +3108,7 @@ var __publicField = (obj, key, value) => {
   const selectTeams = toolkit.createSelector([selectTeamsMapping], (teams) => {
     return Object.values(teams);
   });
-  const selectTeam = (teamId) => (state) => {
+  const selectTeamById = (teamId) => (state) => {
     return state.teamReducer.instances[teamId];
   };
   const selectTeamsOfOrganization = restructureCreateSelectorWithArgs(
@@ -3306,6 +3365,9 @@ var __publicField = (obj, key, value) => {
     deleteIssueAssociations
   } = issueAssociationSlice.actions;
   const selectIssueAssociationMapping = (state) => state.issueAssociationReducer.instances;
+  const selectIssueAssociations = toolkit.createSelector([selectIssueAssociationMapping], (associations) => {
+    return Object.values(associations);
+  });
   const selectIssueAssociationById = (id) => (state) => {
     return state.issueAssociationReducer.instances[id];
   };
@@ -3390,7 +3452,6 @@ var __publicField = (obj, key, value) => {
     organizationAccessReducer,
     projectFileReducer,
     rehydratedReducer,
-    settingReducer,
     formReducer,
     formRevisionReducer,
     formRevisionAttachmentReducer,
@@ -4199,7 +4260,7 @@ var __publicField = (obj, key, value) => {
     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);
@@ -4315,7 +4376,7 @@ var __publicField = (obj, key, value) => {
     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`);
       }
@@ -4421,12 +4482,7 @@ var __publicField = (obj, key, value) => {
     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",
@@ -4749,7 +4805,7 @@ var __publicField = (obj, key, value) => {
     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`);
       }
@@ -5003,7 +5059,7 @@ var __publicField = (obj, key, value) => {
     }
     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`
@@ -5097,7 +5153,7 @@ var __publicField = (obj, key, value) => {
     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`);
       }
@@ -5178,7 +5234,7 @@ var __publicField = (obj, key, value) => {
           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
         },
@@ -5192,24 +5248,24 @@ var __publicField = (obj, key, value) => {
       });
       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));
@@ -5221,7 +5277,7 @@ var __publicField = (obj, key, value) => {
     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.`);
       }
@@ -5469,7 +5525,7 @@ var __publicField = (obj, key, value) => {
     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");
@@ -5812,7 +5868,7 @@ var __publicField = (obj, key, value) => {
     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");
       }
@@ -5989,6 +6045,25 @@ var __publicField = (obj, key, value) => {
       });
       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;
@@ -6128,10 +6203,64 @@ var __publicField = (obj, key, value) => {
       });
       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`);
       }
@@ -7021,7 +7150,7 @@ var __publicField = (obj, key, value) => {
     // 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`);
       }
@@ -7048,7 +7177,7 @@ var __publicField = (obj, key, value) => {
     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`);
       }
@@ -7068,7 +7197,7 @@ var __publicField = (obj, key, value) => {
     }
     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`);
       }
@@ -7093,7 +7222,7 @@ var __publicField = (obj, key, value) => {
     }
     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`);
       }
@@ -7102,7 +7231,7 @@ var __publicField = (obj, key, value) => {
     }
     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`);
       }
@@ -7714,21 +7843,25 @@ var __publicField = (obj, key, value) => {
   exports2.selectAllDocumentAttachments = selectAllDocumentAttachments;
   exports2.selectAllProjectAttachments = selectAllProjectAttachments;
   exports2.selectAncestorIdsOfDocument = selectAncestorIdsOfDocument;
-  exports2.selectAsset = selectAsset;
   exports2.selectAssetAttachment = selectAssetAttachment;
   exports2.selectAssetAttachmentMapping = selectAssetAttachmentMapping;
   exports2.selectAssetAttachments = selectAssetAttachments;
+  exports2.selectAssetById = selectAssetById;
+  exports2.selectAssetStageById = selectAssetStageById;
+  exports2.selectAssetStages = selectAssetStages;
+  exports2.selectAssetStagesByIds = selectAssetStagesByIds;
   exports2.selectAssetToAssetTypeMapping = selectAssetToAssetTypeMapping;
-  exports2.selectAssetType = selectAssetType;
   exports2.selectAssetTypeAttachment = selectAssetTypeAttachment;
   exports2.selectAssetTypeAttachmentMapping = selectAssetTypeAttachmentMapping;
   exports2.selectAssetTypeAttachments = selectAssetTypeAttachments;
+  exports2.selectAssetTypeById = selectAssetTypeById;
   exports2.selectAssetTypeStagesMapping = selectAssetTypeStagesMapping;
   exports2.selectAssetTypes = selectAssetTypes;
-  exports2.selectAssetTypesByName = selectAssetTypesByName;
+  exports2.selectAssetTypesByIds = selectAssetTypesByIds;
   exports2.selectAssetTypesFromIds = selectAssetTypesFromIds;
   exports2.selectAssetTypesMapping = selectAssetTypesMapping;
   exports2.selectAssets = selectAssets;
+  exports2.selectAssetsByIds = selectAssetsByIds;
   exports2.selectAssetsMapping = selectAssetsMapping;
   exports2.selectAssetsOfAssetType = selectAssetsOfAssetType;
   exports2.selectAttachedFormSubmissionsOfAsset = selectAttachedFormSubmissionsOfAsset;
@@ -7746,6 +7879,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectAttachmentsOfProject = selectAttachmentsOfProject;
   exports2.selectAttachmentsOfProjectByType = selectAttachmentsOfProjectByType;
   exports2.selectCategories = selectCategories;
+  exports2.selectCategoriesByIds = selectCategoriesByIds;
   exports2.selectCategoriesOfWorkspace = selectCategoriesOfWorkspace;
   exports2.selectCategoryById = selectCategoryById;
   exports2.selectCategoryMapping = selectCategoryMapping;
@@ -7757,27 +7891,29 @@ var __publicField = (obj, key, value) => {
   exports2.selectConversations = selectConversations;
   exports2.selectCurrentUser = selectCurrentUser;
   exports2.selectDeletedRequests = selectDeletedRequests;
-  exports2.selectDocument = selectDocument;
   exports2.selectDocumentAttachment = selectDocumentAttachment;
   exports2.selectDocumentAttachmentMapping = selectDocumentAttachmentMapping;
+  exports2.selectDocumentById = selectDocumentById;
   exports2.selectDocuments = selectDocuments;
+  exports2.selectDocumentsByIds = selectDocumentsByIds;
   exports2.selectDocumentsMapping = selectDocumentsMapping;
   exports2.selectEmailDomains = selectEmailDomains;
   exports2.selectEmailDomainsAsMapping = selectEmailDomainsAsMapping;
   exports2.selectEmailDomainsOfOrganization = selectEmailDomainsOfOrganization;
   exports2.selectFavouriteProjects = selectFavouriteProjects;
   exports2.selectFilteredForms = selectFilteredForms;
-  exports2.selectForm = selectForm;
+  exports2.selectFormById = selectFormById;
   exports2.selectFormMapping = selectFormMapping;
   exports2.selectFormOfAssetType = selectFormOfAssetType;
   exports2.selectFormOfIssueType = selectFormOfIssueType;
-  exports2.selectFormRevision = selectFormRevision;
   exports2.selectFormRevisionAttachmentsMapping = selectFormRevisionAttachmentsMapping;
+  exports2.selectFormRevisionById = selectFormRevisionById;
   exports2.selectFormRevisionMapping = selectFormRevisionMapping;
   exports2.selectFormRevisions = selectFormRevisions;
   exports2.selectFormRevisionsOfForm = selectFormRevisionsOfForm;
-  exports2.selectFormSubmission = selectFormSubmission;
+  exports2.selectFormSubmissionAttachemntsByIds = selectFormSubmissionAttachemntsByIds;
   exports2.selectFormSubmissionAttachmentsMapping = selectFormSubmissionAttachmentsMapping;
+  exports2.selectFormSubmissionById = selectFormSubmissionById;
   exports2.selectFormSubmissions = selectFormSubmissions;
   exports2.selectFormSubmissionsByAssets = selectFormSubmissionsByAssets;
   exports2.selectFormSubmissionsByFormRevisions = selectFormSubmissionsByFormRevisions;
@@ -7793,27 +7929,29 @@ var __publicField = (obj, key, value) => {
   exports2.selectGeoImageMapping = selectGeoImageMapping;
   exports2.selectGeoImages = selectGeoImages;
   exports2.selectGeoImagesOfProject = selectGeoImagesOfProject;
-  exports2.selectIsFetchingInitialData = selectIsFetchingInitialData;
   exports2.selectIsImportingProjectFile = selectIsImportingProjectFile;
   exports2.selectIsLoggedIn = selectIsLoggedIn;
-  exports2.selectIssue = selectIssue;
   exports2.selectIssueAssociationById = selectIssueAssociationById;
   exports2.selectIssueAssociationMapping = selectIssueAssociationMapping;
+  exports2.selectIssueAssociations = selectIssueAssociations;
   exports2.selectIssueAssociationsOfAsset = selectIssueAssociationsOfAsset;
   exports2.selectIssueAssociationsOfIssue = selectIssueAssociationsOfIssue;
   exports2.selectIssueAssociationsToIssue = selectIssueAssociationsToIssue;
   exports2.selectIssueAttachment = selectIssueAttachment;
   exports2.selectIssueAttachmentMapping = selectIssueAttachmentMapping;
   exports2.selectIssueAttachments = selectIssueAttachments;
+  exports2.selectIssueById = selectIssueById;
   exports2.selectIssueCommentMapping = selectIssueCommentMapping;
   exports2.selectIssueCountOfCategory = selectIssueCountOfCategory;
   exports2.selectIssueMapping = selectIssueMapping;
-  exports2.selectIssueType = selectIssueType;
+  exports2.selectIssueTypeById = selectIssueTypeById;
   exports2.selectIssueTypeMapping = selectIssueTypeMapping;
   exports2.selectIssueTypes = selectIssueTypes;
+  exports2.selectIssueTypesByIds = selectIssueTypesByIds;
   exports2.selectIssueTypesOfOrganization = selectIssueTypesOfOrganization;
   exports2.selectIssueUpdateMapping = selectIssueUpdateMapping;
   exports2.selectIssueUpdatesOfIssue = selectIssueUpdatesOfIssue;
+  exports2.selectIssuesByIds = selectIssuesByIds;
   exports2.selectIssuesOfIssueType = selectIssuesOfIssueType;
   exports2.selectIssuesOfIssueTypeCount = selectIssuesOfIssueTypeCount;
   exports2.selectLatestFormRevisionByForm = selectLatestFormRevisionByForm;
@@ -7826,10 +7964,9 @@ var __publicField = (obj, key, value) => {
   exports2.selectLicensesForProjectsMapping = selectLicensesForProjectsMapping;
   exports2.selectLicensesOfOrganization = selectLicensesOfOrganization;
   exports2.selectMainWorkspace = selectMainWorkspace;
-  exports2.selectNumberOfAssetTypesMatchingCaseInsensitiveName = selectNumberOfAssetTypesMatchingCaseInsensitiveName;
   exports2.selectNumberOfAssetsOfAssetType = selectNumberOfAssetsOfAssetType;
   exports2.selectOrganization = selectOrganization;
-  exports2.selectOrganizationAccess = selectOrganizationAccess;
+  exports2.selectOrganizationAccessById = selectOrganizationAccessById;
   exports2.selectOrganizationAccessForUser = selectOrganizationAccessForUser;
   exports2.selectOrganizationAccessUserMapping = selectOrganizationAccessUserMapping;
   exports2.selectOrganizationAccesses = selectOrganizationAccesses;
@@ -7840,20 +7977,20 @@ var __publicField = (obj, key, value) => {
   exports2.selectOrganizationsMapping = selectOrganizationsMapping;
   exports2.selectOrganizationsWithAccess = selectOrganizationsWithAccess;
   exports2.selectPermittedWorkspaceIds = selectPermittedWorkspaceIds;
-  exports2.selectProject = selectProject;
-  exports2.selectProjectAccess = selectProjectAccess;
+  exports2.selectProjectAccessById = selectProjectAccessById;
   exports2.selectProjectAccessForUser = selectProjectAccessForUser;
   exports2.selectProjectAccessMapping = selectProjectAccessMapping;
   exports2.selectProjectAccessUserMapping = selectProjectAccessUserMapping;
   exports2.selectProjectAccesses = selectProjectAccesses;
   exports2.selectProjectAttachment = selectProjectAttachment;
   exports2.selectProjectAttachmentMapping = selectProjectAttachmentMapping;
+  exports2.selectProjectById = selectProjectById;
   exports2.selectProjectFileById = selectProjectFileById;
   exports2.selectProjectFileMapping = selectProjectFileMapping;
   exports2.selectProjectFiles = selectProjectFiles;
+  exports2.selectProjectMapping = selectProjectMapping;
   exports2.selectProjectUsersAsMapping = selectProjectUsersAsMapping;
   exports2.selectProjectUsersIds = selectProjectUsersIds;
-  exports2.selectProjects = selectProjects;
   exports2.selectProjectsOfOrganization = selectProjectsOfOrganization;
   exports2.selectProjectsWithAccess = selectProjectsWithAccess;
   exports2.selectRecentIssueIds = selectRecentIssueIds;
@@ -7863,21 +8000,20 @@ var __publicField = (obj, key, value) => {
   exports2.selectSortedFormSubmissionsOfForm = selectSortedFormSubmissionsOfForm;
   exports2.selectSortedOrganizationUsers = selectSortedOrganizationUsers;
   exports2.selectSortedProjectUsers = selectSortedProjectUsers;
-  exports2.selectStage = selectStage;
   exports2.selectStageFormIdsFromStageIds = selectStageFormIdsFromStageIds;
   exports2.selectStageMapping = selectStageMapping;
-  exports2.selectStages = selectStages;
   exports2.selectStagesFromAssetTypeIds = selectStagesFromAssetTypeIds;
-  exports2.selectStagesFromStageIds = selectStagesFromStageIds;
   exports2.selectStagesOfAssetType = selectStagesOfAssetType;
-  exports2.selectTeam = selectTeam;
+  exports2.selectTeamById = selectTeamById;
   exports2.selectTeams = selectTeams;
   exports2.selectTeamsMapping = selectTeamsMapping;
   exports2.selectTeamsOfOrganization = selectTeamsOfOrganization;
   exports2.selectTeamsOfUser = selectTeamsOfUser;
   exports2.selectUploadUrl = selectUploadUrl;
   exports2.selectUser = selectUser;
-  exports2.selectUsersAsMapping = selectUsersAsMapping;
+  exports2.selectUserById = selectUserById;
+  exports2.selectUsersByIds = selectUsersByIds;
+  exports2.selectUsersMapping = selectUsersMapping;
   exports2.selectWorkspaceById = selectWorkspaceById;
   exports2.selectWorkspaceMapping = selectWorkspaceMapping;
   exports2.selectWorkspaces = selectWorkspaces;
@@ -7904,7 +8040,6 @@ var __publicField = (obj, key, value) => {
   exports2.setFormSubmissions = setFormSubmissions;
   exports2.setGeoImage = setGeoImage;
   exports2.setGeoImages = setGeoImages;
-  exports2.setIsFetchingInitialData = setIsFetchingInitialData;
   exports2.setIsImportingProjectFile = setIsImportingProjectFile;
   exports2.setIssueAssociation = setIssueAssociation;
   exports2.setIssueAssociations = setIssueAssociations;
@@ -7929,8 +8064,6 @@ var __publicField = (obj, key, value) => {
   exports2.setUploadUrl = setUploadUrl;
   exports2.setUsers = setUsers;
   exports2.setWorkspaces = setWorkspaces;
-  exports2.settingReducer = settingReducer;
-  exports2.settingSlice = settingSlice;
   exports2.shallowEqual = shallowEqual;
   exports2.slugify = slugify;
   exports2.spacesToDashesLower = spacesToDashesLower;