@overmap-ai/core 1.0.59 → 1.0.60-model-adapter.1

package/dist/overmap-core.umd.cjs

@@ -734,15 +734,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$s = {
+  const initialState$B = {
     accessToken: "",
     refreshToken: "",
     isLoggedIn: false
   };
   const authSlice = toolkit.createSlice({
     name: "auth",
-    initialState: initialState$s,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$s)),
+    initialState: initialState$B,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
     reducers: {
       setTokens: (state, action) => {
         state.accessToken = action.payload.accessToken;
@@ -1386,77 +1386,92 @@ var __publicField = (obj, key, value) => {
       return getLocalDateString(date);
     return relative.format(days, "days");
   });
-  const initialState$r = {
-    categories: {},
-    usedCategoryColors: [],
+  function createModelAdapter(computeModelId) {
+    const addOne = (state, action) => {
+      const id = computeModelId(action.payload);
+      state.instances[id] = action.payload;
+    };
+    const addMany = (state, action) => {
+      for (const model of action.payload) {
+        const id = computeModelId(model);
+        state.instances[id] = model;
+      }
+    };
+    const setOne = (state, action) => {
+      const id = computeModelId(action.payload);
+      state.instances[id] = action.payload;
+    };
+    const setMany = (state, action) => {
+      for (const model of action.payload) {
+        const id = computeModelId(model);
+        state.instances[id] = model;
+      }
+    };
+    const updateOne = (state, action) => {
+      const id = computeModelId(action.payload);
+      state.instances[id] = action.payload;
+    };
+    const updateMany = (state, action) => {
+      for (const model of action.payload) {
+        const id = computeModelId(model);
+        state.instances[id] = model;
+      }
+    };
+    const deleteOne = (state, action) => {
+      delete state.instances[action.payload];
+    };
+    const deleteMany = (state, action) => {
+      for (const id of action.payload) {
+        delete state.instances[id];
+      }
+    };
+    const initialize = (state, action) => {
+      state.instances = {};
+      for (const model of action.payload) {
+        const id = computeModelId(model);
+        state.instances[id] = model;
+      }
+    };
+    const getInitialState = (state) => {
+      return {
+        ...state,
+        instances: {}
+      };
+    };
+    return {
+      addOne,
+      addMany,
+      setOne,
+      setMany,
+      updateOne,
+      updateMany,
+      deleteOne,
+      deleteMany,
+      initialize,
+      getInitialState
+    };
+  }
+  const categoryAdapter = createModelAdapter((category) => category.offline_id);
+  const initialState$A = categoryAdapter.getInitialState({
     categoryVisibility: {
       hiddenCategoryIds: [],
       isNullCategoryHidden: false
     }
-  };
+  });
   const categorySlice = toolkit.createSlice({
     name: "categories",
-    initialState: initialState$r,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
+    initialState: initialState$A,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$A)),
     reducers: {
-      setCategories: (state, action) => {
-        if (!Array.isArray(action.payload))
-          throw new Error("Expected an array of Categories");
-        if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
-          throw new Error("Tried to use setCategories reducer with duplicate ID's");
-        }
-        action.payload.forEach((category) => {
-          state.categories[category.offline_id] = category;
-        });
+      initializeCategories: (state, action) => {
+        categoryAdapter.initialize(state, action);
         state.categoryVisibility.hiddenCategoryIds = state.categoryVisibility.hiddenCategoryIds.filter(
           (categoryId) => action.payload.some((category) => category.offline_id === categoryId)
         );
       },
-      addOrReplaceCategories: (state, action) => {
-        action.payload.forEach((category) => {
-          state.categories[category.offline_id] = category;
-        });
-      },
-      addCategory: (state, action) => {
-        if (action.payload.offline_id in state.categories) {
-          throw new Error(`Tried to add duplicate category with ID: ${action.payload.offline_id}`);
-        }
-        state.categories[action.payload.offline_id] = action.payload;
-        state.usedCategoryColors.push(action.payload.color);
-      },
-      patchCategory: (state, action) => {
-        const existingData = state.categories[action.payload.offline_id];
-        if (existingData) {
-          state.categories[action.payload.offline_id] = { ...existingData, ...action.payload };
-        } else {
-          console.error(`Tried to patch category with ID that doesn't exist: ${action.payload.offline_id}`);
-        }
-        if (action.payload.color && !(action.payload.color in state.usedCategoryColors)) {
-          state.usedCategoryColors.push(action.payload.color);
-        }
-      },
-      replaceCategory: (state, action) => {
-        if (action.payload.offline_id in state.categories) {
-          state.categories[action.payload.offline_id] = action.payload;
-        } else {
-          console.error(`Tried to replace category with ID that doesn't exist: ${action.payload.offline_id}`);
-        }
-        if (!(action.payload.color in state.usedCategoryColors)) {
-          state.usedCategoryColors.push(action.payload.color);
-        }
-      },
-      removeCategory: (state, action) => {
-        if (!action.payload) {
-          throw new Error("Category is undefined");
-        }
-        const category = state.categories[action.payload];
-        if (category) {
-          categorySlice.caseReducers.removeColor(state, { payload: category.color });
-          delete state.categories[action.payload];
-        } else {
-          throw new Error(`Tried to remove category with ID that doesn't exist: ${action.payload}`);
-        }
-      },
+      addCategory: categoryAdapter.addOne,
+      updateCategory: categoryAdapter.updateOne,
+      deleteCategory: categoryAdapter.deleteOne,
       // Pass in a null value to hide the "No category" category
       hideCategory: (state, action) => {
         const categoryId = action.payload;
@@ -1467,7 +1482,7 @@ var __publicField = (obj, key, value) => {
         }
       },
       hideAllCategories: (state) => {
-        state.categoryVisibility.hiddenCategoryIds = Object.keys(state.categories);
+        state.categoryVisibility.hiddenCategoryIds = Object.keys(state.instances);
         state.categoryVisibility.isNullCategoryHidden = true;
       },
       // Pass in a null value to unhide the "No category" category
@@ -1484,26 +1499,20 @@ var __publicField = (obj, key, value) => {
       unhideAllCategories: (state) => {
         state.categoryVisibility.hiddenCategoryIds = [];
         state.categoryVisibility.isNullCategoryHidden = false;
-      },
-      removeColor: (state, action) => {
-        state.usedCategoryColors = state.usedCategoryColors.filter((color) => color !== action.payload);
       }
     }
   });
   const {
-    setCategories,
+    initializeCategories,
     addCategory,
-    replaceCategory,
-    patchCategory,
-    removeCategory,
+    updateCategory,
+    deleteCategory,
     hideCategory,
     hideAllCategories,
     unhideCategory,
-    unhideAllCategories,
-    removeColor,
-    addOrReplaceCategories
+    unhideAllCategories
   } = categorySlice.actions;
-  const selectCategoryMapping = (state) => state.categoryReducer.categories;
+  const selectCategoryMapping = (state) => state.categoryReducer.instances;
   const _selectActiveWorkspaceId = (state) => state.workspaceReducer.activeWorkspaceId;
   const selectCategories = toolkit.createSelector(
     [selectCategoryMapping, _selectActiveWorkspaceId],
@@ -1515,12 +1524,12 @@ var __publicField = (obj, key, value) => {
       (categories, workspaceId) => categories.filter((category) => category.workspace === workspaceId)
     )
   );
-  const selectCategory = (offline_id) => (state) => {
-    if (!offline_id)
-      return void 0;
-    return state.categoryReducer.categories[offline_id];
-  };
-  const selectUsedColors = (state) => state.categoryReducer.usedCategoryColors;
+  const selectCategoryById = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectCategoryMapping, (_state, categoryId) => categoryId],
+      (mapping, categoryId) => mapping[categoryId]
+    )
+  );
   const selectCategoryVisibility = (state) => state.categoryReducer.categoryVisibility;
   const selectHiddenCategoryCount = (state) => {
     const { hiddenCategoryIds, isNullCategoryHidden } = state.categoryReducer.categoryVisibility;
@@ -1530,106 +1539,28 @@ var __publicField = (obj, key, value) => {
     return hiddenCategoryCount;
   };
   const selectIssueCountOfCategory = (categoryId) => (state) => {
-    return Object.values(state.issueReducer.issues).filter((issue) => issue.category === categoryId).length;
+    return Object.values(state.issueReducer.instances).filter((issue) => issue.category === categoryId).length;
   };
   const categoryReducer = categorySlice.reducer;
-  function setAttachment(state, action) {
-    state.attachments[action.payload.offline_id] = action.payload;
-  }
-  function setAttachments(state, action) {
-    state.attachments = {};
-    for (const attachment of action.payload) {
-      state.attachments[attachment.offline_id] = attachment;
-    }
-  }
-  function addAttachment(state, action) {
-    if (action.payload.offline_id in state.attachments) {
-      throw new Error(`Attachment ${action.payload.offline_id} already exists.`);
-    }
-    state.attachments[action.payload.offline_id] = action.payload;
-  }
-  function addAttachments(state, action) {
-    for (const attachment of action.payload) {
-      state.attachments[attachment.offline_id] = attachment;
-    }
-  }
-  function updateAttachment(state, action) {
-    if (action.payload.offline_id in state.attachments) {
-      state.attachments[action.payload.offline_id] = action.payload;
-    } else {
-      throw new Error(`Attachment ${action.payload.offline_id} does not exist.`);
-    }
-  }
-  function updateAttachments(state, action) {
-    for (const attachment of action.payload) {
-      if (attachment.offline_id in state.attachments) {
-        state.attachments[attachment.offline_id] = attachment;
-      } else {
-        throw new Error(`Attachment ${attachment.offline_id} does not exist.`);
-      }
-    }
-  }
-  function removeAttachment(state, action) {
-    if (action.payload in state.attachments) {
-      delete state.attachments[action.payload];
-    } else {
-      throw new Error(`Attachment ${action.payload} does not exist.`);
-    }
-  }
-  function removeAttachments(state, action) {
-    for (const attachmentId of action.payload) {
-      delete state.attachments[attachmentId];
-    }
-  }
-  const initialState$q = {
-    assetTypes: {},
-    hiddenAssetTypeIds: {},
-    attachments: {}
-  };
+  const assetTypeAdapter = createModelAdapter((assetType) => assetType.offline_id);
+  const initialState$z = assetTypeAdapter.getInitialState({
+    hiddenAssetTypeIds: {}
+  });
   const assetTypeSlice = toolkit.createSlice({
     name: "assetTypes",
-    initialState: initialState$q,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
+    initialState: initialState$z,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
     reducers: {
-      addAssetType: (state, action) => {
-        state.assetTypes[action.payload.offline_id] = action.payload;
-      },
-      setAssetTypes: (state, action) => {
-        state.assetTypes = toOfflineIdRecord(action.payload);
-      },
+      initializeAssetTypes: assetTypeAdapter.initialize,
+      addAssetType: assetTypeAdapter.addOne,
+      deleteAssetType: assetTypeAdapter.deleteOne,
       toggleAssetTypeVisibility: (state, action) => {
         state.hiddenAssetTypeIds[action.payload] = !state.hiddenAssetTypeIds[action.payload];
-      },
-      deleteAssetType: (state, action) => {
-        delete state.assetTypes[action.payload];
-      },
-      // Attachments
-      setAssetTypeAttachment: setAttachment,
-      setAssetTypeAttachments: setAttachments,
-      addAssetTypeAttachment: addAttachment,
-      addAssetTypeAttachments: addAttachments,
-      updateAssetTypeAttachment: updateAttachment,
-      updateAssetTypeAttachments: updateAttachments,
-      removeAssetTypeAttachment: removeAttachment,
-      removeAssetTypeAttachments: removeAttachments
+      }
     }
   });
-  const {
-    addAssetType,
-    setAssetTypes,
-    toggleAssetTypeVisibility,
-    deleteAssetType,
-    // Attachmet
-    setAssetTypeAttachment,
-    setAssetTypeAttachments,
-    addAssetTypeAttachment,
-    addAssetTypeAttachments,
-    updateAssetTypeAttachment,
-    updateAssetTypeAttachments,
-    removeAssetTypeAttachment,
-    removeAssetTypeAttachments
-  } = assetTypeSlice.actions;
-  const selectAssetTypesMapping = (state) => state.assetTypeReducer.assetTypes;
+  const { addAssetType, initializeAssetTypes, deleteAssetType, toggleAssetTypeVisibility } = assetTypeSlice.actions;
+  const selectAssetTypesMapping = (state) => state.assetTypeReducer.instances;
   const selectAssetTypes = toolkit.createSelector(
     [selectAssetTypesMapping],
     (mapping) => Object.values(mapping)
@@ -1665,151 +1596,78 @@ var __publicField = (obj, key, value) => {
     })
   );
   const selectHiddenAssetTypeIds = (state) => state.assetTypeReducer.hiddenAssetTypeIds;
-  const selectAssetTypeAttachmentMapping = (state) => state.assetTypeReducer.attachments;
-  const selectAssetTypeAttachments = toolkit.createSelector(
-    [selectAssetTypeAttachmentMapping],
-    (mapping) => Object.values(mapping)
-  );
-  const selectAssetTypeAttachment = (attachmentId) => (state) => {
-    return state.assetTypeReducer.attachments[attachmentId];
-  };
-  const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
-      (attachments, assetTypeId) => {
-        return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
-      }
-    )
-  );
-  const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
-      (attachments, assetTypeId) => {
-        const attachmentsOfAssetType = attachments.filter(({ asset_type }) => asset_type === assetTypeId);
-        const fileAttachments = attachmentsOfAssetType.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => !file_type || !file_type.startsWith("image/")
-        );
-        const imageAttachments = attachmentsOfAssetType.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => file_type && file_type.startsWith("image/")
-        );
-        return { fileAttachments, imageAttachments };
-      }
-    )
-  );
   const assetTypeReducer = assetTypeSlice.reducer;
-  const initialState$p = {
-    assets: {},
-    attachments: {}
-  };
+  const assetAdapter = createModelAdapter((asset) => asset.offline_id);
+  const initialState$y = assetAdapter.getInitialState({});
   const assetSlice = toolkit.createSlice({
     name: "assets",
-    initialState: initialState$p,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
+    initialState: initialState$y,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
     reducers: {
+      initializeAssets: (state, action) => {
+        assetAdapter.initialize(state, action);
+        prevAssets = null;
+      },
       addAsset: (state, action) => {
-        state.assets[action.payload.offline_id] = action.payload;
+        assetAdapter.addOne(state, action);
+        prevAssets = null;
+      },
+      addAssets: (state, action) => {
+        assetAdapter.addMany(state, action);
         prevAssets = null;
       },
-      addAssetsInBatches: (state, action) => {
-        Object.assign(state.assets, toOfflineIdRecord(action.payload));
+      setAsset: (state, action) => {
+        assetAdapter.setOne(state, action);
         prevAssets = null;
       },
       setAssets: (state, action) => {
-        state.assets = toOfflineIdRecord(action.payload);
+        assetAdapter.setMany(state, action);
         prevAssets = null;
       },
       updateAsset: (state, action) => {
-        if (action.payload.offline_id in state.assets) {
-          state.assets[action.payload.offline_id] = action.payload;
-        } else {
-          throw new Error(`Tried to update asset with ID that doesn't exist: ${action.payload.offline_id}`);
-        }
+        assetAdapter.updateOne(state, action);
         prevAssets = null;
       },
       updateAssets: (state, action) => {
-        for (const asset of action.payload) {
-          if (asset.offline_id in state.assets) {
-            state.assets[asset.offline_id] = asset;
-          } else {
-            throw new Error(`Tried to update asset with ID that doesn't exist: ${asset.offline_id}`);
-          }
-        }
-        prevAssets = null;
-      },
-      removeAsset: (state, action) => {
-        if (action.payload in state.assets) {
-          delete state.assets[action.payload];
-        } else {
-          throw new Error(`Failed to remove asset because ID doesn't exist: ${action.payload}`);
-        }
+        assetAdapter.updateMany(state, action);
         prevAssets = null;
       },
-      removeAssets: (state, action) => {
-        for (const assetId of action.payload) {
-          if (assetId in state.assets) {
-            delete state.assets[assetId];
-          } else {
-            throw new Error(`Failed to remove asset because ID doesn't exist: ${assetId}`);
-          }
-        }
+      deleteAsset: (state, action) => {
+        assetAdapter.deleteOne(state, action);
         prevAssets = null;
       },
-      removeAllAssetsOfType: (state, action) => {
-        var _a2;
-        for (const componentId in state.assets) {
-          if (((_a2 = state.assets[componentId]) == null ? void 0 : _a2.asset_type) === action.payload) {
-            delete state.assets[componentId];
-          }
-        }
+      deleteAssets: (state, action) => {
+        assetAdapter.deleteMany(state, action);
         prevAssets = null;
-      },
-      // Attachments
-      setAssetAttachment: setAttachment,
-      setAssetAttachments: setAttachments,
-      addAssetAttachment: addAttachment,
-      addAssetAttachments: addAttachments,
-      updateAssetAttachment: updateAttachment,
-      updateAssetAttachments: updateAttachments,
-      removeAssetAttachment: removeAttachment,
-      removeAssetAttachments: removeAttachments
+      }
     }
   });
   const {
+    initializeAssets,
     addAsset,
+    addAssets,
     updateAsset,
     updateAssets,
-    removeAsset,
-    removeAssets,
-    addAssetsInBatches,
-    setAssets,
-    removeAllAssetsOfType,
-    // Attachments
-    setAssetAttachment,
-    setAssetAttachments,
-    addAssetAttachment,
-    addAssetAttachments,
-    updateAssetAttachment,
-    updateAssetAttachments,
-    removeAssetAttachment,
-    removeAssetAttachments
+    deleteAsset,
+    deleteAssets,
+    setAsset,
+    setAssets
   } = assetSlice.actions;
   let prevAssets = null;
   const selectAssets = (state) => {
     if (!prevAssets) {
-      prevAssets = Object.values(state.assetReducer.assets);
+      prevAssets = Object.values(state.assetReducer.instances);
     }
     return prevAssets;
   };
-  const selectAssetsMapping = (state) => state.assetReducer.assets;
+  const selectAssetsMapping = (state) => state.assetReducer.instances;
   const selectAssetsOfAssetType = restructureCreateSelectorWithArgs(
     toolkit.createSelector([selectAssets, (_state, assetTypeId) => assetTypeId], (components, assetTypeId) => {
       return components.filter((asset) => asset.asset_type === assetTypeId);
     })
   );
   const selectAsset = (assetId) => (state) => {
-    return state.assetReducer.assets[assetId];
+    return state.assetReducer.instances[assetId];
   };
   const selectAssetToAssetTypeMapping = toolkit.createSelector(
     [selectAssets, selectAssetTypesMapping],
@@ -1838,20 +1696,50 @@ var __publicField = (obj, key, value) => {
   };
   const selectAssetTypesFromIds = (assetTypeIds) => (state) => {
     return assetTypeIds.reduce((acc, assetTypeId) => {
-      const assetType = state.assetTypeReducer.assetTypes[assetTypeId];
+      const assetType = state.assetTypeReducer.instances[assetTypeId];
       if (assetType) {
         acc.push(assetType);
       }
       return acc;
     }, []);
   };
-  const selectAssetAttachmentMapping = (state) => state.assetReducer.attachments;
+  const assetReducer = assetSlice.reducer;
+  const assetAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
+  const initialState$x = assetAttachmentAdapter.getInitialState({});
+  const assetAttachmentSlice = toolkit.createSlice({
+    name: "assetAttachments",
+    initialState: initialState$x,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
+    reducers: {
+      initializeAssetAttachments: assetAttachmentAdapter.initialize,
+      addAssetAttachment: assetAttachmentAdapter.addOne,
+      addAssetAttachments: assetAttachmentAdapter.addMany,
+      setAssetAttachment: assetAttachmentAdapter.setOne,
+      setAssetAttachments: assetAttachmentAdapter.setMany,
+      updateAssetAttachment: assetAttachmentAdapter.updateOne,
+      updateAssetAttachments: assetAttachmentAdapter.updateMany,
+      deleteAssetAttachment: assetAttachmentAdapter.deleteOne,
+      deleteAssetAttachments: assetAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeAssetAttachments,
+    addAssetAttachment,
+    addAssetAttachments,
+    setAssetAttachment,
+    setAssetAttachments,
+    updateAssetAttachment,
+    updateAssetAttachments,
+    deleteAssetAttachment,
+    deleteAssetAttachments
+  } = assetAttachmentSlice.actions;
+  const selectAssetAttachmentMapping = (state) => state.assetAttachmentReducer.instances;
   const selectAssetAttachments = toolkit.createSelector(
     [selectAssetAttachmentMapping],
     (mapping) => Object.values(mapping)
   );
   const selectAssetAttachment = (attachmentId) => (state) => {
-    return state.assetReducer.attachments[attachmentId];
+    return state.assetAttachmentReducer.instances[attachmentId];
   };
   const selectAttachmentsOfAsset = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
@@ -1878,14 +1766,14 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const assetReducer = assetSlice.reducer;
-  const initialState$o = {
+  const assetAttachmentReducer = assetAttachmentSlice.reducer;
+  const initialState$w = {
     completionsByAssetId: {}
   };
   const assetStageCompletionSlice = toolkit.createSlice({
     name: "assetStageCompletions",
-    initialState: initialState$o,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
+    initialState: initialState$w,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
     reducers: {
       addStageCompletion: (state, action) => {
         let stageToCompletionDateMapping = state.completionsByAssetId[action.payload.asset];
@@ -1934,46 +1822,22 @@ var __publicField = (obj, key, value) => {
     return Object.keys(state.assetStageCompletionReducer.completionsByAssetId[asset.offline_id] ?? {});
   };
   const assetStageCompletionReducer = assetStageCompletionSlice.reducer;
-  const initialState$n = {
-    stages: {}
-  };
+  const assetStageAdapter = createModelAdapter((assetStage) => assetStage.offline_id);
+  const initialState$v = assetStageAdapter.getInitialState({});
   const assetStageSlice = toolkit.createSlice({
     name: "assetStages",
-    initialState: initialState$n,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
+    initialState: initialState$v,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
     reducers: {
-      addStages: (state, action) => {
-        Object.assign(state.stages, toOfflineIdRecord(action.payload));
-      },
-      updateStages: (state, action) => {
-        for (const stage of action.payload) {
-          state.stages[stage.offline_id] = stage;
-        }
-      },
-      removeStages: (state, action) => {
-        action.payload.forEach((id) => {
-          delete state.stages[id];
-        });
-      },
-      linkStageToForm: (state, action) => {
-        const { stageId, formId: formId2 } = action.payload;
-        const stage = state.stages[stageId];
-        if (!stage) {
-          throw new Error("No stage exists with the id " + stageId);
-        }
-        stage.user_form = formId2;
-      },
-      unlinkStageToForm: (state, action) => {
-        const { stageId } = action.payload;
-        const stage = state.stages[stageId];
-        if (!stage) {
-          throw new Error("No stage exists with the id " + stageId);
-        }
-        delete stage.user_form;
-      }
+      initializeStages: assetStageAdapter.initialize,
+      setStage: assetStageAdapter.setOne,
+      addStages: assetStageAdapter.addMany,
+      updateStage: assetStageAdapter.updateOne,
+      updateStages: assetStageAdapter.updateMany,
+      removeStages: assetStageAdapter.deleteMany
     }
   });
-  const selectStageMapping = (state) => state.assetStageReducer.stages;
+  const selectStageMapping = (state) => state.assetStageReducer.instances;
   const selectStage = restructureCreateSelectorWithArgs(
     toolkit.createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
       return stageMapping[stageId];
@@ -2036,43 +1900,100 @@ var __publicField = (obj, key, value) => {
       return ret;
     })
   );
-  const { addStages, updateStages, removeStages, linkStageToForm, unlinkStageToForm } = assetStageSlice.actions;
+  const { initializeStages, setStage, addStages, updateStages, removeStages, updateStage } = assetStageSlice.actions;
   const assetStageReducer = assetStageSlice.reducer;
-  const initialState$m = {
-    workspaces: {},
-    activeWorkspaceId: null
+  const assetTypeAttachmentAdapter = createModelAdapter(
+    (attachment) => attachment.offline_id
+  );
+  const initialState$u = assetTypeAttachmentAdapter.getInitialState({});
+  const assetTypeAttachmentSlice = toolkit.createSlice({
+    name: "assetTypeAttachments",
+    initialState: initialState$u,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$u)),
+    reducers: {
+      initializeAssetTypeAttachments: assetTypeAttachmentAdapter.initialize,
+      addAssetTypeAttachment: assetTypeAttachmentAdapter.addOne,
+      addAssetTypeAttachments: assetTypeAttachmentAdapter.addMany,
+      setAssetTypeAttachment: assetTypeAttachmentAdapter.setOne,
+      setAssetTypeAttachments: assetTypeAttachmentAdapter.setMany,
+      updateAssetTypeAttachment: assetTypeAttachmentAdapter.updateOne,
+      updateAssetTypeAttachments: assetTypeAttachmentAdapter.updateMany,
+      deleteAssetTypeAttachment: assetTypeAttachmentAdapter.deleteOne,
+      deleteAssetTypeAttachments: assetTypeAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeAssetTypeAttachments,
+    addAssetTypeAttachment,
+    addAssetTypeAttachments,
+    setAssetTypeAttachment,
+    setAssetTypeAttachments,
+    updateAssetTypeAttachment,
+    updateAssetTypeAttachments,
+    deleteAssetTypeAttachment,
+    deleteAssetTypeAttachments
+  } = assetTypeAttachmentSlice.actions;
+  const selectAssetTypeAttachmentMapping = (state) => state.assetTypeAttachmentReducer.instances;
+  const selectAssetTypeAttachments = toolkit.createSelector(
+    [selectAssetTypeAttachmentMapping],
+    (mapping) => Object.values(mapping)
+  );
+  const selectAssetTypeAttachment = (attachmentId) => (state) => {
+    return state.assetTypeAttachmentReducer.instances[attachmentId];
   };
+  const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+      (attachments, assetTypeId) => {
+        return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
+      }
+    )
+  );
+  const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+      (attachments, assetTypeId) => {
+        const attachmentsOfAssetType = attachments.filter(({ asset_type }) => asset_type === assetTypeId);
+        const fileAttachments = attachmentsOfAssetType.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => !file_type || !file_type.startsWith("image/")
+        );
+        const imageAttachments = attachmentsOfAssetType.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => file_type && file_type.startsWith("image/")
+        );
+        return { fileAttachments, imageAttachments };
+      }
+    )
+  );
+  const assetTypeAttachmentReducer = assetTypeAttachmentSlice.reducer;
+  const workspaceAdapter = createModelAdapter((workspace) => workspace.offline_id);
+  const initialState$t = workspaceAdapter.getInitialState({
+    activeWorkspaceId: null
+  });
   const workspaceSlice = toolkit.createSlice({
     name: "workspace",
-    initialState: initialState$m,
-    // The `reducers` field lets us define reducers and generate associated actions
+    initialState: initialState$t,
     reducers: {
-      setWorkspaces: (state, action) => {
-        state.workspaces = action.payload;
-      },
-      // Takes a list of Workspaces and updates existing ones to match the payload, or adds them
-      // to the store if they are not already present
-      addOrReplaceWorkspaces: (state, action) => {
-        Object.values(action.payload).forEach((workspace) => {
-          state.workspaces[workspace.offline_id] = workspace;
-        });
-      },
-      addWorkspace: (state, action) => {
-        if (action.payload.offline_id in state.workspaces) {
-          throw new Error(`Tried to add duplicate workspace with name: ${action.payload.offline_id}`);
-        }
-        state.workspaces[action.payload.offline_id] = action.payload;
-      },
-      removeWorkspace: (state, action) => {
-        delete state.workspaces[action.payload];
-      },
+      initializeWorkspaces: workspaceAdapter.initialize,
+      setWorkspaces: workspaceAdapter.setMany,
+      addWorkspace: workspaceAdapter.addOne,
+      updateWorkspace: workspaceAdapter.updateOne,
+      deleteWorkspace: workspaceAdapter.deleteOne,
       setActiveWorkspaceId: (state, action) => {
         state.activeWorkspaceId = action.payload;
       }
     }
   });
-  const { setWorkspaces, addOrReplaceWorkspaces, addWorkspace, setActiveWorkspaceId, removeWorkspace } = workspaceSlice.actions;
-  const selectWorkspaceMapping = (state) => state.workspaceReducer.workspaces;
+  const {
+    initializeWorkspaces,
+    setWorkspaces,
+    addWorkspace,
+    updateWorkspace,
+    setActiveWorkspaceId,
+    deleteWorkspace
+  } = workspaceSlice.actions;
+  const selectWorkspaceMapping = (state) => state.workspaceReducer.instances;
   const selectWorkspaces = toolkit.createSelector([selectWorkspaceMapping], (mapping) => Object.values(mapping));
   const selectMainWorkspace = toolkit.createSelector([selectWorkspaces], (workspaces) => {
     return workspaces.find((workspace) => workspace.name.toLowerCase() === "main");
@@ -2101,169 +2022,33 @@ var __publicField = (obj, key, value) => {
   );
   const workspaceReducer = workspaceSlice.reducer;
   const maxRecentIssues = 10;
-  const initialState$l = {
-    issues: {},
-    attachments: {},
-    comments: {},
-    updates: {},
+  const issueAdapter = createModelAdapter((issue) => issue.offline_id);
+  const initialState$s = issueAdapter.getInitialState({
     visibleStatuses: [IssueStatus.BACKLOG, IssueStatus.SELECTED],
     visibleUserIds: null,
-    recentIssueIds: [],
-    activeIssueId: null
-  };
+    recentIssueIds: []
+  });
   const issueSlice = toolkit.createSlice({
     name: "issues",
-    initialState: initialState$l,
+    initialState: initialState$s,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$l);
+      Object.assign(state, initialState$s);
     }),
     reducers: {
-      setIssues: (state, action) => {
-        if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
-          throw new Error("Tried to use setIssues reducer with duplicate ID's");
-        }
-        action.payload.forEach((issue) => {
-          state.issues[issue.offline_id] = issue;
-        });
-      },
-      setIssueUpdates: (state, action) => {
-        if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
-          throw new Error("Tried to use setIssues reducer with duplicate ID's");
-        }
-        const newUpdates = {};
-        for (const update of action.payload) {
-          newUpdates[update.offline_id] = update;
-        }
-        state.updates = newUpdates;
-      },
-      setActiveIssueId: (state, action) => {
-        state.activeIssueId = action.payload;
+      initializeIssues: issueAdapter.initialize,
+      addIssue: issueAdapter.addOne,
+      addIssues: issueAdapter.addMany,
+      updateIssue: issueAdapter.updateOne,
+      deleteIssue: issueAdapter.deleteOne,
+      deleteIssues: issueAdapter.deleteMany,
+      setVisibleStatuses: (state, action) => {
+        state.visibleStatuses = action.payload;
       },
-      addIssue: (state, action) => {
-        if (action.payload.offline_id in state.issues) {
-          throw new Error(`Tried to add duplicate issue with ID: ${action.payload.offline_id}`);
-        }
-        state.issues[action.payload.offline_id] = action.payload;
+      setVisibleUserIds: (state, action) => {
+        state.visibleUserIds = [...new Set(action.payload)];
       },
-      addIssues: (state, action) => {
-        for (const issue of action.payload) {
-          if (issue.offline_id in state.issues) {
-            throw new Error(`Tried to add duplicate issue with ID: ${issue.offline_id}`);
-          }
-        }
-        for (const issue of action.payload) {
-          state.issues[issue.offline_id] = issue;
-        }
-      },
-      addIssueUpdate: (state, action) => {
-        if (action.payload.offline_id in state.updates) {
-          throw new Error(`Tried to add duplicate issue update with offline_id: ${action.payload.offline_id}`);
-        }
-        state.updates[action.payload.offline_id] = action.payload;
-      },
-      addIssueUpdates: (state, action) => {
-        for (const update of action.payload) {
-          state.updates[update.offline_id] = update;
-        }
-      },
-      updateIssue: (state, action) => {
-        if (action.payload.offline_id in state.issues) {
-          state.issues[action.payload.offline_id] = {
-            ...state.issues[action.payload.offline_id],
-            ...action.payload
-          };
-        } else {
-          throw new Error(`Tried to update issue with ID that doesn't exist: ${action.payload.offline_id}`);
-        }
-      },
-      removeIssue: (state, action) => {
-        if (action.payload in state.issues) {
-          delete state.issues[action.payload];
-        } else {
-          throw new Error(`Failed to remove issue because ID doesn't exist: ${action.payload}`);
-        }
-      },
-      removeIssues: (state, action) => {
-        for (const issueId of action.payload) {
-          delete state.issues[issueId];
-        }
-      },
-      removeIssueUpdate: (state, action) => {
-        if (action.payload in state.updates) {
-          delete state.updates[action.payload];
-        } else {
-          throw new Error(`Failed to remove issue update because offline_id doesn't exist: ${action.payload}`);
-        }
-      },
-      removeIssueUpdates: (state, action) => {
-        for (const updateId of action.payload) {
-          delete state.updates[updateId];
-        }
-      },
-      removeAttachmentsOfIssue: (state, action) => {
-        const attachments = Object.values(state.attachments).filter((a) => a.issue === action.payload);
-        for (const attachment of attachments) {
-          delete state.attachments[attachment.offline_id];
-        }
-      },
-      setVisibleStatuses: (state, action) => {
-        state.visibleStatuses = action.payload;
-      },
-      setVisibleUserIds: (state, action) => {
-        state.visibleUserIds = [...new Set(action.payload)];
-      },
-      // Comments
-      addIssueComment: (state, action) => {
-        if (action.payload.offline_id in state.comments) {
-          throw new Error(
-            `Tried to add issue comment with offline_id: ${action.payload.offline_id} that already exists`
-          );
-        }
-        state.comments[action.payload.offline_id] = action.payload;
-      },
-      addIssueComments: (state, action) => {
-        for (const comment of action.payload) {
-          if (comment.offline_id in state.comments) {
-            throw new Error(
-              `Tried to add issue comment with offline_id: ${comment.offline_id} that already exists`
-            );
-          }
-        }
-        for (const comment of action.payload) {
-          state.comments[comment.offline_id] = comment;
-        }
-      },
-      setIssueComment: (state, action) => {
-        state.comments[action.payload.offline_id] = action.payload;
-      },
-      setIssueComments: (state, action) => {
-        const newComments = {};
-        for (const comment of action.payload) {
-          newComments[comment.offline_id] = comment;
-        }
-        state.comments = newComments;
-      },
-      addOrReplaceIssueComment: (state, action) => {
-        state.comments[action.payload.offline_id] = action.payload;
-      },
-      removeIssueComment: (state, action) => {
-        if (!(action.payload in state.comments)) {
-          throw new Error(`Failed to remove issue comment because ID doesn't exist: ${action.payload}`);
-        }
-        delete state.comments[action.payload];
-      },
-      removeIssueComments: (state, action) => {
-        for (const commentId of action.payload) {
-          if (!(commentId in state.comments)) {
-            throw new Error(`Failed to remove issue comment because ID doesn't exist: ${commentId}`);
-          }
-        }
-        for (const commentId of action.payload) {
-          delete state.comments[commentId];
-        }
-      },
-      cleanRecentIssues: (state) => {
-        state.recentIssueIds = state.recentIssueIds.filter((recentIssue) => state.issues[recentIssue.offlineId]);
+      cleanRecentIssues: (state) => {
+        state.recentIssueIds = state.recentIssueIds.filter((recentIssue) => state.instances[recentIssue.offlineId]);
       },
       addToRecentIssues: (state, action) => {
         state.recentIssueIds = state.recentIssueIds.filter(
@@ -2284,57 +2069,24 @@ var __publicField = (obj, key, value) => {
         if (indexToRemove !== -1) {
           state.recentIssueIds.splice(indexToRemove, 1);
         }
-      },
-      // Attachments
-      setIssueAttachment: setAttachment,
-      setIssueAttachments: setAttachments,
-      addIssueAttachment: addAttachment,
-      addIssueAttachments: addAttachments,
-      updateIssueAttachment: updateAttachment,
-      updateIssueAttachments: updateAttachments,
-      removeIssueAttachment: removeAttachment,
-      removeIssueAttachments: removeAttachments
+      }
     }
   });
   const {
+    initializeIssues,
     addIssue,
     addIssues,
-    addIssueUpdate,
-    addIssueUpdates,
-    addOrReplaceIssueComment,
+    updateIssue,
+    deleteIssue,
+    deleteIssues,
+    setVisibleStatuses,
+    setVisibleUserIds,
     addToRecentIssues,
     cleanRecentIssues,
-    removeAttachmentsOfIssue,
-    removeIssue,
-    removeIssues,
-    removeIssueUpdate,
-    removeIssueUpdates,
     removeRecentIssue,
-    resetRecentIssues,
-    setActiveIssueId,
-    setIssueUpdates,
-    setIssues,
-    setVisibleStatuses,
-    setVisibleUserIds,
-    updateIssue,
-    // Attachments
-    setIssueAttachment,
-    setIssueAttachments,
-    addIssueAttachment,
-    addIssueAttachments,
-    updateIssueAttachment,
-    updateIssueAttachments,
-    removeIssueAttachment,
-    removeIssueAttachments,
-    // Commments
-    addIssueComment,
-    addIssueComments,
-    setIssueComment,
-    setIssueComments,
-    removeIssueComment,
-    removeIssueComments
+    resetRecentIssues
   } = issueSlice.actions;
-  const selectIssueMapping = (state) => state.issueReducer.issues;
+  const selectIssueMapping = (state) => state.issueReducer.instances;
   const selectRecentIssueIds = (state) => state.issueReducer.recentIssueIds;
   const selectVisibleUserIds = (state) => state.issueReducer.visibleUserIds;
   const selectVisibleStatuses = (state) => state.issueReducer.visibleStatuses;
@@ -2381,83 +2133,11 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const selectActiveIssueId = (state) => state.issueReducer.activeIssueId;
-  const selectIssueAttachmentMapping = (state) => state.issueReducer.attachments;
-  const selectIssueAttachments = toolkit.createSelector(
-    [selectIssueAttachmentMapping],
-    (mapping) => Object.values(mapping)
-  );
-  const selectPhotoAttachmentsOfIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueAttachmentMapping, (_state, issueId) => issueId],
-      (attachmentMapping, issueId) => {
-        return Object.values(attachmentMapping).filter(
-          (attachment) => attachment.issue === issueId && attachment.file_type && attachment.file_type.startsWith("image/")
-        );
-      }
-    )
-  );
-  const selectCommentMapping = (state) => state.issueReducer.comments;
-  const selectCommentsOfIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectCommentMapping, (_state, issueId) => issueId], (commentMapping, issueId) => {
-      return Object.values(commentMapping).filter((comment) => comment.issue === issueId);
-    })
-  );
-  const selectIssueUpdateMapping = (state) => state.issueReducer.updates;
-  const selectIssueUpdatesOfIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectIssueUpdateMapping, (_state, issueId) => issueId], (updates, issueId) => {
-      return Object.values(updates).filter((update) => update.issue === issueId);
-    })
-  );
-  const selectAttachmentsOfIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueAttachments, (_state, issueId) => issueId],
-      (attachments, issueId) => {
-        return attachments.filter(({ issue }) => issueId === issue);
-      }
-    )
-  );
-  const selectIssueAttachment = (attachmentId) => (root) => {
-    return root.issueReducer.attachments[attachmentId];
-  };
-  const selectAttachmentsOfIssueByType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueAttachments, (_state, issueId) => issueId],
-      (attachments, issueId) => {
-        const attachmentsOfIssue = attachments.filter(({ issue }) => issue === issueId);
-        const fileAttachments = attachmentsOfIssue.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => !file_type || !file_type.startsWith("image/")
-        );
-        const imageAttachments = attachmentsOfIssue.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => file_type && file_type.startsWith("image/")
-        );
-        return { fileAttachments, imageAttachments };
-      }
-    )
-  );
-  const selectFileAttachmentsOfIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueAttachmentMapping, (_state, issueId) => issueId],
-      (attachmentMapping, issueId) => {
-        if (!issueId)
-          return void 0;
-        return Object.values(attachmentMapping).filter(
-          (attachment) => (
-            // Files with file_type that is null or not an image file
-            attachment.issue === issueId && (!attachment.file_type || !attachment.file_type.startsWith("image/"))
-          )
-        );
-      }
-    )
-  );
   const selectIssue = restructureCreateSelectorWithArgs(
     toolkit.createSelector([selectIssueMapping, (_state, id) => id], (mapping, id) => {
       return mapping[id];
     })
   );
-  const selectAllAttachments = toolkit.createSelector([selectIssueAttachmentMapping], (mapping) => Object.values(mapping));
   const searchIssues = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [selectIssueMapping, selectWorkspaceMapping, (_state, searchArgs) => searchArgs],
@@ -2548,47 +2228,25 @@ var __publicField = (obj, key, value) => {
     }
   );
   const issueReducer = issueSlice.reducer;
-  const initialState$k = {
-    issueTypes: {}
-  };
+  const issueTypeAdapter = createModelAdapter((issueType) => issueType.offline_id);
+  const initialState$r = issueTypeAdapter.getInitialState({});
   const issueTypeSlice = toolkit.createSlice({
     name: "issueTypes",
-    initialState: initialState$k,
+    initialState: initialState$r,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$k);
+      Object.assign(state, initialState$r);
     }),
     reducers: {
-      setIssueTypes: (state, action) => {
-        for (const issueType of action.payload) {
-          state.issueTypes[issueType.offline_id] = issueType;
-        }
-      },
-      setIssueType: (state, action) => {
-        state.issueTypes[action.payload.offline_id] = action.payload;
-      },
-      addIssueType: (state, action) => {
-        if (action.payload.offline_id in state.issueTypes) {
-          throw new Error(`IssueType with offline_id ${action.payload.offline_id} already exists in the store.`);
-        }
-        state.issueTypes[action.payload.offline_id] = action.payload;
-      },
-      updateIssueType: (state, action) => {
-        if (!(action.payload.offline_id in state.issueTypes)) {
-          throw new Error(`IssueType with offline_id ${action.payload.offline_id} does not exist in the store.`);
-        }
-        state.issueTypes[action.payload.offline_id] = action.payload;
-      },
-      removeIssueType: (state, action) => {
-        if (!(action.payload in state.issueTypes)) {
-          throw new Error(`IssueType with offline_id ${action.payload} does not exist in the store.`);
-        }
-        delete state.issueTypes[action.payload];
-      }
+      initializeIssueTypes: issueTypeAdapter.initialize,
+      setIssueType: issueTypeAdapter.setOne,
+      addIssueType: issueTypeAdapter.addOne,
+      updateIssueType: issueTypeAdapter.updateOne,
+      removeIssueType: issueTypeAdapter.deleteOne
     }
   });
-  const { setIssueTypes, setIssueType, addIssueType, updateIssueType, removeIssueType } = issueTypeSlice.actions;
+  const { initializeIssueTypes, setIssueType, addIssueType, updateIssueType, removeIssueType } = issueTypeSlice.actions;
   const selectIssueTypeMapping = (state) => {
-    return state.issueTypeReducer.issueTypes;
+    return state.issueTypeReducer.instances;
   };
   const selectIssueTypes = toolkit.createSelector(selectIssueTypeMapping, (issueTypes) => {
     return Object.values(issueTypes);
@@ -2611,7 +2269,7 @@ var __publicField = (obj, key, value) => {
   );
   const selectIssuesOfIssueType = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
-      [(state) => state.issueReducer.issues, (_, issueTypeId) => issueTypeId],
+      [(state) => state.issueReducer.instances, (_, issueTypeId) => issueTypeId],
       (issuesMapping, issueTypeId) => {
         return Object.values(issuesMapping).filter((issue) => issue.issue_type === issueTypeId);
       }
@@ -2622,15 +2280,15 @@ var __publicField = (obj, key, value) => {
     return ((_a2 = selectIssuesOfIssueType(issueTypeId)(state)) == null ? void 0 : _a2.length) ?? 0;
   };
   const issueTypeReducer = issueTypeSlice.reducer;
-  const initialState$j = {
+  const initialState$q = {
     s3Urls: {}
   };
   const msPerHour = 1e3 * 60 * 60;
   const msPerWeek = msPerHour * 24 * 7;
   const fileSlice = toolkit.createSlice({
     name: "file",
-    initialState: initialState$j,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
+    initialState: initialState$q,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
     reducers: {
       setUploadUrl: (state, action) => {
         const { url, fields, sha1 } = action.payload;
@@ -2657,7 +2315,7 @@ var __publicField = (obj, key, value) => {
     return url;
   };
   const fileReducer = fileSlice.reducer;
-  const initialState$i = {
+  const initialState$p = {
     // TODO: Change first MapStyle.SATELLITE to MaptStyle.None when project creation map is fixed
     mapStyle: MapStyle.SATELLITE,
     showTooltips: false,
@@ -2665,8 +2323,8 @@ var __publicField = (obj, key, value) => {
   };
   const mapSlice = toolkit.createSlice({
     name: "map",
-    initialState: initialState$i,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
+    initialState: initialState$p,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
     reducers: {
       setMapStyle: (state, action) => {
         state.mapStyle = action.payload;
@@ -2738,7 +2396,7 @@ var __publicField = (obj, key, value) => {
     LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
     return LicenseStatus2;
   })(LicenseStatus || {});
-  const initialState$h = {
+  const initialState$o = {
     users: {},
     currentUser: {
       id: 0,
@@ -2749,8 +2407,8 @@ var __publicField = (obj, key, value) => {
   };
   const userSlice = toolkit.createSlice({
     name: "users",
-    initialState: initialState$h,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$h)),
+    initialState: initialState$o,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
     reducers: {
       setUsers: (state, action) => {
         const usersMapping = {};
@@ -2812,52 +2470,26 @@ var __publicField = (obj, key, value) => {
   const selectUsersAsMapping = (state) => state.userReducer.users;
   const selectFavouriteProjects = (state) => state.userReducer.currentUser.profile.favourite_project_ids;
   const userReducer = userSlice.reducer;
-  const initialState$g = {
-    organizationAccesses: {}
-  };
+  const organizationAccessAdapter = createModelAdapter(
+    (organizationAccess) => organizationAccess.offline_id
+  );
+  const initialState$n = organizationAccessAdapter.getInitialState({});
   const organizationAccessSlice = toolkit.createSlice({
     name: "organizationAccess",
-    initialState: initialState$g,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
+    initialState: initialState$n,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
     reducers: {
-      setOrganizationAccesses: (state, action) => {
-        if (!Array.isArray(action.payload))
-          throw new Error("Expected an array of OrganizationAccess");
-        if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
-          throw new Error("Tried to use setOrganizationAccesses reducer with duplicate ID's");
-        }
-        const organizationAccesses = {};
-        for (const organizationAccess of action.payload) {
-          organizationAccesses[organizationAccess.offline_id] = organizationAccess;
-        }
-        state.organizationAccesses = organizationAccesses;
-      },
-      updateOrganizationAccess: (state, action) => {
-        if (action.payload.offline_id in state.organizationAccesses) {
-          state.organizationAccesses[action.payload.offline_id] = action.payload;
-        } else {
-          throw new Error(
-            `Tried to update organization access with ID that doesn't exist: ${action.payload.offline_id}`
-          );
-        }
-      },
-      removeOrganizationAccess: (state, action) => {
-        if (action.payload.offline_id in state.organizationAccesses) {
-          delete state.organizationAccesses[action.payload.offline_id];
-        } else {
-          throw new Error(
-            `Tried to remove organization access with ID that doesn't exist: ${action.payload.offline_id}`
-          );
-        }
-      }
+      initializeOrganizationAccesses: organizationAccessAdapter.initialize,
+      updateOrganizationAccess: organizationAccessAdapter.updateOne,
+      deleteOrganizationAccess: organizationAccessAdapter.deleteOne
     }
   });
-  const { setOrganizationAccesses, updateOrganizationAccess, removeOrganizationAccess } = organizationAccessSlice.actions;
+  const { initializeOrganizationAccesses, updateOrganizationAccess, deleteOrganizationAccess } = organizationAccessSlice.actions;
   const selectOrganizationAccesses = (state) => {
-    return state.organizationAccessReducer.organizationAccesses;
+    return state.organizationAccessReducer.instances;
   };
   const selectOrganizationAccess = (organizationAccessId) => (state) => {
-    return state.organizationAccessReducer.organizationAccesses[organizationAccessId];
+    return state.organizationAccessReducer.instances[organizationAccessId];
   };
   const selectActiveOrganizationAccess = toolkit.createSelector(
     [selectCurrentUser, selectOrganizationAccesses],
@@ -2869,60 +2501,39 @@ var __publicField = (obj, key, value) => {
     }
   );
   const selectOrganizationAccessForUser = (user) => (state) => {
-    return Object.values(state.organizationAccessReducer.organizationAccesses).find(
+    return Object.values(state.organizationAccessReducer.instances).find(
       (organizationAccess) => organizationAccess.user === user.id
     );
   };
   const selectOrganizationAccessUserMapping = (state) => {
     const organizationAccesses = {};
-    for (const organizationAccess of Object.values(state.organizationAccessReducer.organizationAccesses)) {
+    for (const organizationAccess of Object.values(state.organizationAccessReducer.instances)) {
       organizationAccesses[organizationAccess.user] = organizationAccess;
     }
     return organizationAccesses;
   };
   const organizationAccessReducer = organizationAccessSlice.reducer;
-  const initialState$f = {
-    licenses: {}
-  };
+  const licenseAdapter = createModelAdapter((license) => license.offline_id);
+  const initialState$m = licenseAdapter.getInitialState({});
   const licenseSlice = toolkit.createSlice({
     name: "license",
-    initialState: initialState$f,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
+    initialState: initialState$m,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
     reducers: {
-      setLicenses: (state, action) => {
-        if (!Array.isArray(action.payload))
-          throw new Error("Expected an array of Licenses");
-        if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
-          throw new Error("Tried to use setLicenses reducer with duplicate ID's");
-        }
-        const licenses = {};
-        for (const license of action.payload) {
-          licenses[license.offline_id] = license;
-        }
-        state.licenses = licenses;
-      },
-      addLicenses: (state, action) => {
-        for (const license of action.payload) {
-          state.licenses[license.offline_id] = license;
-        }
-      },
-      updateLicense: (state, action) => {
-        if (!(action.payload.offline_id in state.licenses)) {
-          throw new Error("Tried to update license that does not exist.");
-        }
-        state.licenses[action.payload.offline_id] = action.payload;
-      }
+      setLicenses: licenseAdapter.initialize,
+      addLicenses: licenseAdapter.addMany,
+      updateLicense: licenseAdapter.updateOne
     }
   });
   const { setLicenses, addLicenses, updateLicense } = licenseSlice.actions;
   const selectLicenses = (state) => {
-    return state.licenseReducer.licenses;
+    return state.licenseReducer.instances;
   };
-  const selectLicense = (licenseId) => (state) => state.licenseReducer.licenses[licenseId];
-  const selectActiveLicense = (state) => Object.values(state.licenseReducer.licenses).find(
+  const selectLicense = (licenseId) => (state) => state.licenseReducer.instances[licenseId];
+  const selectActiveLicense = (state) => Object.values(state.licenseReducer.instances).find(
     (license) => license.project === state.projectReducer.activeProjectId
   ) ?? null;
-  const selectLicenseForProject = (projectId) => (state) => Object.values(state.licenseReducer.licenses).find((license) => license.project === projectId);
+  const selectLicenseForProject = (projectId) => (state) => Object.values(state.licenseReducer.instances).find((license) => license.project === projectId);
   const selectActiveStatusLicenses = toolkit.createSelector(
     [selectLicenses],
     (licenses) => Object.values(licenses).filter((license) => license.is_active)
@@ -2932,90 +2543,58 @@ var __publicField = (obj, key, value) => {
     (licenses) => Object.values(licenses).filter((license) => license.project).reduce((accum, license) => ({ ...accum, [license.project]: license }), {})
   );
   const licenseReducer = licenseSlice.reducer;
-  const initialState$e = {
-    projectAccesses: {}
-  };
+  const projectAccessAdapter = createModelAdapter((projectAccess) => projectAccess.offline_id);
+  const initialState$l = projectAccessAdapter.getInitialState({});
   const projectAccessSlice = toolkit.createSlice({
     name: "projectAccess",
-    initialState: initialState$e,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
+    initialState: initialState$l,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
     reducers: {
-      setProjectAccesses: (state, action) => {
-        if (!Array.isArray(action.payload))
-          throw new Error("Expected an array of ProjectAccess");
-        if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
-          throw new Error("Tried to use setProjectAccesses reducer with duplicate ID's");
-        }
-        const projectAccesses = {};
-        for (const projectAccess of action.payload) {
-          projectAccesses[projectAccess.offline_id] = projectAccess;
-        }
-        state.projectAccesses = projectAccesses;
-      },
-      updateProjectAccess: (state, action) => {
-        if (action.payload.offline_id in state.projectAccesses) {
-          state.projectAccesses[action.payload.offline_id] = action.payload;
-        } else {
-          throw new Error(
-            `Tried to update project access with ID that doesn't exist: ${action.payload.offline_id}`
-          );
-        }
-      },
-      removeProjectAccess: (state, action) => {
-        if (action.payload.offline_id in state.projectAccesses) {
-          delete state.projectAccesses[action.payload.offline_id];
-        } else {
-          throw new Error(
-            `Tried to remove project access with ID that doesn't exist: ${action.payload.offline_id}`
-          );
-        }
-      },
-      removeProjectAccessesOfProject: (state, action) => {
-        for (const projectAccess of Object.values(state.projectAccesses)) {
-          if (projectAccess.project === action.payload) {
-            delete state.projectAccesses[projectAccess.offline_id];
-          }
-        }
-      }
+      setProjectAccesses: projectAccessAdapter.initialize,
+      updateProjectAccess: projectAccessAdapter.updateOne,
+      deleteProjectAccess: projectAccessAdapter.deleteOne,
+      deleteProjectAccesses: projectAccessAdapter.deleteMany
     }
   });
-  const { setProjectAccesses, updateProjectAccess, removeProjectAccess, removeProjectAccessesOfProject } = projectAccessSlice.actions;
+  const { setProjectAccesses, updateProjectAccess, deleteProjectAccess, deleteProjectAccesses } = projectAccessSlice.actions;
+  const selectProjectAccessMapping = (state) => {
+    return state.projectAccessReducer.instances;
+  };
   const selectProjectAccesses = (state) => {
-    return state.projectAccessReducer.projectAccesses;
+    return Object.values(state.projectAccessReducer.instances);
   };
   const selectProjectAccess = (projectAccessId) => (state) => {
-    return state.projectAccessReducer.projectAccesses[projectAccessId];
+    return state.projectAccessReducer.instances[projectAccessId];
   };
   const selectActiveProjectAccess = (state) => {
     const currentUser = state.userReducer.currentUser;
     const activeProjectId = state.projectReducer.activeProjectId;
-    return Object.values(state.projectAccessReducer.projectAccesses).find((projectAccess) => {
+    return Object.values(state.projectAccessReducer.instances).find((projectAccess) => {
       return projectAccess.user === currentUser.id && projectAccess.project === activeProjectId;
     }) ?? null;
   };
   const selectProjectAccessForUser = (user) => (state) => {
-    return Object.values(state.projectAccessReducer.projectAccesses).find(
+    return Object.values(state.projectAccessReducer.instances).find(
       (projectAccess) => projectAccess.user === user.id
     );
   };
   const selectProjectAccessUserMapping = (state) => {
     const projectAccesses = {};
-    for (const projectAccess of Object.values(state.projectAccessReducer.projectAccesses)) {
+    for (const projectAccess of Object.values(state.projectAccessReducer.instances)) {
       projectAccesses[projectAccess.user] = projectAccess;
     }
     return projectAccesses;
   };
   const projectAccessReducer = projectAccessSlice.reducer;
-  const initialState$d = {
+  const initialState$k = {
     projects: {},
     activeProjectId: null,
     recentProjectIds: [],
-    recentSearchableQueries: [],
-    attachments: {}
+    recentSearchableQueries: []
   };
   const projectSlice = toolkit.createSlice({
     name: "projects",
-    initialState: initialState$d,
+    initialState: initialState$k,
     reducers: {
       setProjects: (state, action) => {
         const projectsMap = {};
@@ -3079,16 +2658,7 @@ var __publicField = (obj, key, value) => {
         } else {
           throw new Error("Update form submissions count: no active project");
         }
-      },
-      // Attachments
-      setProjectAttachment: setAttachment,
-      setProjectAttachments: setAttachments,
-      addProjectAttachment: addAttachment,
-      addProjectAttachments: addAttachments,
-      updateProjectAttachment: updateAttachment,
-      updateProjectAttachments: updateAttachments,
-      removeProjectAttachment: removeAttachment,
-      removeProjectAttachments: removeAttachments
+      }
     }
   });
   const {
@@ -3099,16 +2669,7 @@ var __publicField = (obj, key, value) => {
     deleteProject,
     acceptProjectInvite,
     addActiveProjectIssuesCount,
-    addActiveProjectFormSubmissionsCount,
-    // Attachments
-    setProjectAttachment,
-    setProjectAttachments,
-    addProjectAttachment,
-    addProjectAttachments,
-    updateProjectAttachment,
-    updateProjectAttachments,
-    removeProjectAttachment,
-    removeProjectAttachments
+    addActiveProjectFormSubmissionsCount
   } = projectSlice.actions;
   const selectProjects = (state) => state.projectReducer.projects;
   const selectActiveProjectId = (state) => state.projectReducer.activeProjectId;
@@ -3139,7 +2700,7 @@ var __publicField = (obj, key, value) => {
   );
   const projectReducer = projectSlice.reducer;
   const selectProjectUsersIds = toolkit.createSelector(
-    [selectProjectAccesses],
+    [selectProjectAccessMapping],
     (projectAccesses) => Object.values(projectAccesses).map((projectAccess) => projectAccess.user)
   );
   const selectProjectUsersAsMapping = toolkit.createSelector(
@@ -3171,47 +2732,14 @@ var __publicField = (obj, key, value) => {
       });
     }
   );
-  const selectProjectAttachmentMapping = (state) => state.projectReducer.attachments;
-  const selectAllProjectAttachments = toolkit.createSelector(
-    [selectProjectAttachmentMapping],
-    (mapping) => Object.values(mapping)
-  );
-  const selectProjectAttachment = (attachmentId) => (state) => {
-    return state.projectReducer.attachments[attachmentId];
-  };
-  const selectAttachmentsOfProject = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAllProjectAttachments, (_state, projectId) => projectId],
-      (attachments, projectId) => {
-        return attachments.filter(({ project }) => projectId === project);
-      }
-    )
-  );
-  const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAllProjectAttachments, (_state, projectId) => projectId],
-      (attachments, projectId) => {
-        const attachmentsOfProject = attachments.filter(({ project }) => projectId === project);
-        const fileAttachments = attachmentsOfProject.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => !file_type || !file_type.startsWith("image/")
-        );
-        const imageAttachments = attachmentsOfProject.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => file_type && file_type.startsWith("image/")
-        );
-        return { fileAttachments, imageAttachments };
-      }
-    )
-  );
-  const initialState$c = {
+  const initialState$j = {
     organizations: {},
     activeOrganizationId: null
   };
   const organizationSlice = toolkit.createSlice({
     name: "organizations",
-    initialState: initialState$c,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
+    initialState: initialState$j,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
     reducers: {
       setOrganizations: (state, action) => {
         for (const org of action.payload) {
@@ -3330,14 +2858,14 @@ var __publicField = (obj, key, value) => {
       }
     };
   };
-  const initialState$b = {
+  const initialState$i = {
     deletedRequests: [],
     latestRetryTime: 0
   };
   const outboxSlice = toolkit.createSlice({
     name: "outbox",
-    initialState: initialState$b,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
+    initialState: initialState$i,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
     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
@@ -3369,7 +2897,7 @@ var __publicField = (obj, key, value) => {
   const selectLatestRetryTime = (state) => state.outboxReducer.latestRetryTime;
   const { enqueueRequest, markForDeletion, markAsDeleted, _setLatestRetryTime } = outboxSlice.actions;
   const outboxReducer = outboxSlice.reducer;
-  const initialState$a = {
+  const initialState$h = {
     projectFiles: {},
     activeProjectFileId: null,
     isImportingProjectFile: false,
@@ -3377,8 +2905,8 @@ var __publicField = (obj, key, value) => {
   };
   const projectFileSlice = toolkit.createSlice({
     name: "projectFiles",
-    initialState: initialState$a,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$a)),
+    initialState: initialState$h,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$h)),
     reducers: {
       addOrReplaceProjectFiles: (state, action) => {
         for (let fileObj of action.payload) {
@@ -3479,12 +3007,75 @@ var __publicField = (obj, key, value) => {
   const selectActiveProjectFileId = (state) => state.projectFileReducer.activeProjectFileId;
   const selectIsImportingProjectFile = (state) => state.projectFileReducer.isImportingProjectFile;
   const projectFileReducer = projectFileSlice.reducer;
-  const initialState$9 = {
+  const projectAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
+  const initialState$g = projectAttachmentAdapter.getInitialState({});
+  const projectAttachmentSlice = toolkit.createSlice({
+    name: "projectAttachments",
+    initialState: initialState$g,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
+    reducers: {
+      initializeProjectAttachments: projectAttachmentAdapter.initialize,
+      addProjectAttachment: projectAttachmentAdapter.addOne,
+      addProjectAttachments: projectAttachmentAdapter.addMany,
+      setProjectAttachment: projectAttachmentAdapter.setOne,
+      setProjectAttachments: projectAttachmentAdapter.setMany,
+      updateProjectAttachment: projectAttachmentAdapter.updateOne,
+      updateProjectAttachments: projectAttachmentAdapter.updateMany,
+      deleteProjectAttachment: projectAttachmentAdapter.deleteOne,
+      deleteProjectAttachments: projectAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeProjectAttachments,
+    addProjectAttachment,
+    addProjectAttachments,
+    setProjectAttachment,
+    setProjectAttachments,
+    updateProjectAttachment,
+    updateProjectAttachments,
+    deleteProjectAttachment,
+    deleteProjectAttachments
+  } = projectAttachmentSlice.actions;
+  const selectProjectAttachmentMapping = (state) => state.projectAttachmentReducer.instances;
+  const selectAllProjectAttachments = toolkit.createSelector(
+    [selectProjectAttachmentMapping],
+    (mapping) => Object.values(mapping)
+  );
+  const selectProjectAttachment = (attachmentId) => (state) => {
+    return state.projectAttachmentReducer.instances[attachmentId];
+  };
+  const selectAttachmentsOfProject = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAllProjectAttachments, (_state, projectId) => projectId],
+      (attachments, projectId) => {
+        return attachments.filter(({ project }) => projectId === project);
+      }
+    )
+  );
+  const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAllProjectAttachments, (_state, projectId) => projectId],
+      (attachments, projectId) => {
+        const attachmentsOfProject = attachments.filter(({ project }) => projectId === project);
+        const fileAttachments = attachmentsOfProject.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => !file_type || !file_type.startsWith("image/")
+        );
+        const imageAttachments = attachmentsOfProject.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => file_type && file_type.startsWith("image/")
+        );
+        return { fileAttachments, imageAttachments };
+      }
+    )
+  );
+  const projectAttachmentReducer = projectAttachmentSlice.reducer;
+  const initialState$f = {
     isRehydrated: false
   };
   const rehydratedSlice = toolkit.createSlice({
     name: "rehydrated",
-    initialState: initialState$9,
+    initialState: initialState$f,
     // The `reducers` field lets us define reducers and generate associated actions
     reducers: {
       setRehydrated: (state, action) => {
@@ -3494,7 +3085,7 @@ var __publicField = (obj, key, value) => {
   });
   const selectRehydrated = (state) => state.rehydratedReducer.isRehydrated;
   const rehydratedReducer = rehydratedSlice.reducer;
-  const initialState$8 = {
+  const initialState$e = {
     useIssueTemplate: false,
     placementMode: false,
     enableClustering: false,
@@ -3512,8 +3103,8 @@ var __publicField = (obj, key, value) => {
   };
   const settingSlice = toolkit.createSlice({
     name: "settings",
-    initialState: initialState$8,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
+    initialState: initialState$e,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
     reducers: {
       setEnableDuplicateIssues: (state, action) => {
         state.useIssueTemplate = action.payload;
@@ -3572,119 +3163,36 @@ var __publicField = (obj, key, value) => {
       return revisionA < revisionB ? -1 : 1;
     }
   };
-  const initialState$7 = {
-    formRevisions: {},
-    attachments: {}
-  };
+  const formRevisionAdapter = createModelAdapter((revision) => revision.offline_id);
+  const initialState$d = formRevisionAdapter.getInitialState({});
   const formRevisionsSlice = toolkit.createSlice({
     name: "formRevisions",
-    initialState: initialState$7,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
+    initialState: initialState$d,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
     reducers: {
-      // revision related actions
-      setFormRevision: (state, action) => {
-        state.formRevisions[action.payload.offline_id] = action.payload;
-      },
-      setFormRevisions: (state, action) => {
-        state.formRevisions = {};
-        for (const revision of action.payload) {
-          state.formRevisions[revision.offline_id] = revision;
-        }
-      },
-      addFormRevision: (state, action) => {
-        if (state.formRevisions[action.payload.offline_id] !== void 0) {
-          throw new Error(`Revision with offline_id ${action.payload.offline_id} already exists`);
-        }
-        state.formRevisions[action.payload.offline_id] = action.payload;
-      },
-      addFormRevisions: (state, action) => {
-        for (const userFormRevision of action.payload) {
-          if (state.formRevisions[userFormRevision.offline_id] !== void 0) {
-            throw new Error(`Revision with offline_id ${userFormRevision.offline_id} already exists`);
-          }
-        }
-        for (const userFormRevision of action.payload) {
-          state.formRevisions[userFormRevision.offline_id] = userFormRevision;
-        }
-      },
-      // UserFormRevisions do not get updated
-      deleteFormRevision: (state, action) => {
-        if (state.formRevisions[action.payload] === void 0) {
-          throw new Error(`Revision with offline_id ${action.payload} does not exist`);
-        }
-        delete state.formRevisions[action.payload];
-      },
-      deleteFormRevisions: (state, action) => {
-        for (const offlineId of action.payload) {
-          if (state.formRevisions[offlineId] === void 0) {
-            throw new Error(`Revision with offline_id ${offlineId} does not exist`);
-          }
-        }
-        for (const offlineId of action.payload) {
-          delete state.formRevisions[offlineId];
-        }
-      },
-      // attachment related actions
-      setFormRevisionAttachments: (state, action) => {
-        state.attachments = {};
-        for (const attachment of action.payload) {
-          state.attachments[attachment.offline_id] = attachment;
-        }
-      },
-      addFormRevisionAttachment: (state, action) => {
-        if (state.attachments[action.payload.offline_id] !== void 0) {
-          throw new Error(`Attachment with offline_id ${action.payload.offline_id} already exists`);
-        }
-        state.attachments[action.payload.offline_id] = action.payload;
-      },
-      addFormRevisionAttachments: (state, action) => {
-        for (const attachment of action.payload) {
-          if (state.attachments[attachment.offline_id] !== void 0) {
-            throw new Error(`Attachment with offline_id ${attachment.offline_id} already exists`);
-          }
-        }
-        for (const attachment of action.payload) {
-          state.attachments[attachment.offline_id] = attachment;
-        }
-      },
-      deleteFormRevisionAttachment: (state, action) => {
-        if (state.attachments[action.payload] === void 0) {
-          throw new Error(`Attachment with offline_id ${action.payload} does not exist`);
-        }
-        delete state.attachments[action.payload];
-      },
-      deleteFormRevisionAttachments: (state, action) => {
-        for (const offlineId of action.payload) {
-          if (state.attachments[offlineId] === void 0) {
-            throw new Error(`Attachment with offline_id ${offlineId} does not exist`);
-          }
-        }
-        for (const offlineId of action.payload) {
-          delete state.attachments[offlineId];
-        }
-      }
+      initializeFormRevisions: formRevisionAdapter.initialize,
+      setFormRevision: formRevisionAdapter.setOne,
+      addFormRevision: formRevisionAdapter.addOne,
+      addFormRevisions: formRevisionAdapter.addMany,
+      deleteFormRevision: formRevisionAdapter.deleteOne,
+      deleteFormRevisions: formRevisionAdapter.deleteMany
     }
   });
   const {
     setFormRevision,
-    setFormRevisions,
+    initializeFormRevisions,
     addFormRevision,
     addFormRevisions,
     deleteFormRevision,
-    deleteFormRevisions,
-    setFormRevisionAttachments,
-    addFormRevisionAttachment,
-    addFormRevisionAttachments,
-    deleteFormRevisionAttachment,
-    deleteFormRevisionAttachments
+    deleteFormRevisions
   } = formRevisionsSlice.actions;
-  const selectFormRevisionMapping = (state) => state.formRevisionReducer.formRevisions;
+  const selectFormRevisionMapping = (state) => state.formRevisionReducer.instances;
   const selectFormRevisions = toolkit.createSelector(
     [selectFormRevisionMapping],
     (formRevisions) => Object.values(formRevisions)
   );
   const selectFormRevision = (formRevisionId) => (state) => {
-    return state.formRevisionReducer.formRevisions[formRevisionId];
+    return state.formRevisionReducer.instances[formRevisionId];
   };
   const _selectLatestFormRevision = (formRevisions, formId2) => {
     let ret = null;
@@ -3713,7 +3221,7 @@ var __publicField = (obj, key, value) => {
   const selectLatestFormRevisionsOfAssetTypes = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [
-        (state) => state.formReducer.forms,
+        (state) => state.formReducer.instances,
         selectFormRevisionMapping,
         (_state, assetTypeIds) => assetTypeIds
       ],
@@ -3747,67 +3255,28 @@ var __publicField = (obj, key, value) => {
     }
     return latestRevisions;
   });
-  const selectUserFormRevisionAttachmentsMapping = (state) => {
-    return state.formRevisionReducer.attachments;
-  };
-  const selectAttachmentsOfFormRevision = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectUserFormRevisionAttachmentsMapping, (_state, revisionId) => revisionId],
-      (attachments, revisionId) => {
-        return Object.values(attachments).filter((attachment) => attachment.revision === revisionId);
-      }
-    )
-  );
   const formRevisionReducer = formRevisionsSlice.reducer;
-  const initialState$6 = {
-    forms: {}
-  };
+  const formAdapter = createModelAdapter((form) => form.offline_id);
+  const initialState$c = formAdapter.getInitialState({});
   const formSlice = toolkit.createSlice({
     name: "forms",
-    initialState: initialState$6,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
+    initialState: initialState$c,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
     reducers: {
-      setForms: (state, action) => {
-        state.forms = {};
-        action.payload.forEach((userForm) => {
-          state.forms[userForm.offline_id] = userForm;
-        });
-      },
-      addForm: (state, action) => {
-        state.forms[action.payload.offline_id] = action.payload;
-      },
-      addForms: (state, action) => {
-        for (const userForm of action.payload) {
-          state.forms[userForm.offline_id] = userForm;
-        }
-      },
-      favoriteForm: (state, action) => {
-        const { formId: formId2 } = action.payload;
-        const form = state.forms[formId2];
-        if (!form) {
-          throw new Error("No form exists with the id " + formId2);
-        }
-        form.favorite = true;
-      },
-      unfavoriteForm: (state, action) => {
-        const { formId: formId2 } = action.payload;
-        const form = state.forms[formId2];
-        if (!form) {
-          throw new Error("No form exists with the id " + formId2);
-        }
-        form.favorite = false;
-      },
-      deleteForm: (state, action) => {
-        delete state.forms[action.payload];
-      }
+      setForms: formAdapter.initialize,
+      setForm: formAdapter.setOne,
+      addForm: formAdapter.addOne,
+      addForms: formAdapter.addMany,
+      updateForm: formAdapter.updateOne,
+      deleteForm: formAdapter.deleteOne
     }
   });
-  const { setForms, addForm, addForms, favoriteForm, unfavoriteForm, deleteForm } = formSlice.actions;
+  const { setForms, setForm, addForm, addForms, updateForm, deleteForm } = formSlice.actions;
   const selectFilteredForms = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [
-        (state) => state.formReducer.forms,
-        (state) => state.formRevisionReducer.formRevisions,
+        (state) => state.formReducer.instances,
+        (state) => state.formRevisionReducer.instances,
         (_state, search) => search
       ],
       (userForms, revisions, search) => {
@@ -3840,10 +3309,10 @@ var __publicField = (obj, key, value) => {
     )
   );
   const selectForm = (formId2) => (state) => {
-    return state.formReducer.forms[formId2];
+    return state.formReducer.instances[formId2];
   };
   const selectFormMapping = (state) => {
-    return state.formReducer.forms;
+    return state.formReducer.instances;
   };
   const selectFormOfAssetType = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
@@ -3868,123 +3337,21 @@ var __publicField = (obj, key, value) => {
     return Object.values(userForms).filter((form) => !form.asset_type).length;
   });
   const formReducer = formSlice.reducer;
-  const initialState$5 = {
-    formSubmissions: {},
-    attachments: {}
-  };
+  const submissionAdapter = createModelAdapter((submission) => submission.offline_id);
+  const initialState$b = submissionAdapter.getInitialState({});
   const formSubmissionSlice = toolkit.createSlice({
     name: "formSubmissions",
-    initialState: initialState$5,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
+    initialState: initialState$b,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
     reducers: {
-      setFormSubmission: (state, action) => {
-        state.formSubmissions[action.payload.offline_id] = action.payload;
-      },
-      setFormSubmissions: (state, action) => {
-        state.formSubmissions = {};
-        for (const submission of action.payload) {
-          state.formSubmissions[submission.offline_id] = submission;
-        }
-      },
-      addFormSubmission: (state, action) => {
-        if (action.payload.offline_id in state.formSubmissions) {
-          throw new Error(`Submission with offline_id ${action.payload.offline_id} already exists`);
-        }
-        state.formSubmissions[action.payload.offline_id] = action.payload;
-      },
-      addFormSubmissions: (state, action) => {
-        for (const submission of action.payload) {
-          if (state.formSubmissions[submission.offline_id] !== void 0) {
-            throw new Error(`Submission with offline_id ${submission.offline_id} already exists`);
-          }
-        }
-        for (const submission of action.payload) {
-          state.formSubmissions[submission.offline_id] = submission;
-        }
-      },
-      updateFormSubmission: (state, action) => {
-        if (state.formSubmissions[action.payload.offline_id] === void 0) {
-          throw new Error(`Submission with offline_id ${action.payload.offline_id} does not exist`);
-        }
-        state.formSubmissions[action.payload.offline_id] = action.payload;
-      },
-      updateFormSubmissions: (state, action) => {
-        for (const submission of action.payload) {
-          if (state.formSubmissions[submission.offline_id] === void 0) {
-            throw new Error(`Submission with offline_id ${submission.offline_id} does not exist`);
-          }
-        }
-        for (const submission of action.payload) {
-          state.formSubmissions[submission.offline_id] = submission;
-        }
-      },
-      deleteFormSubmission: (state, action) => {
-        if (state.formSubmissions[action.payload] === void 0) {
-          throw new Error(`Submission with offline_id ${action.payload} does not exist`);
-        }
-        delete state.formSubmissions[action.payload];
-      },
-      deleteFormSubmissions: (state, action) => {
-        for (const offlineId of action.payload) {
-          if (state.formSubmissions[offlineId] === void 0) {
-            throw new Error(`Submission with offline_id ${offlineId} does not exist`);
-          }
-          delete state.formSubmissions[offlineId];
-        }
-        for (const offlineId of action.payload) {
-          delete state.formSubmissions[offlineId];
-        }
-      },
-      // Attachments
-      addFormSubmissionAttachment: (state, action) => {
-        if (state.attachments[action.payload.offline_id] !== void 0) {
-          throw new Error(`Attachment with offline_id ${action.payload.offline_id} already exists`);
-        }
-        state.attachments[action.payload.offline_id] = action.payload;
-      },
-      addFormSubmissionAttachments: (state, action) => {
-        for (const attachment of action.payload) {
-          if (state.attachments[attachment.offline_id] !== void 0) {
-            throw new Error(`Attachment with offline_id ${attachment.offline_id} already exists`);
-          }
-        }
-        for (const attachment of action.payload) {
-          state.attachments[attachment.offline_id] = attachment;
-        }
-      },
-      // We only need a multi set for attachments because they are not updated, only added and deleted
-      setFormSubmissionAttachments: (state, action) => {
-        state.attachments = {};
-        for (const attachment of action.payload) {
-          state.attachments[attachment.offline_id] = attachment;
-        }
-      },
-      updateFormSubmissionAttachments: (state, action) => {
-        for (const attachment of action.payload) {
-          if (state.attachments[attachment.offline_id] === void 0) {
-            throw new Error(`Attachment with offline_id ${attachment.offline_id} does not exist`);
-          }
-        }
-        for (const attachment of action.payload) {
-          state.attachments[attachment.offline_id] = attachment;
-        }
-      },
-      // The delete actions for UserFormSubmissionAttachments are not used in the app, but are included for completeness
-      // Could be used if editing a submission is ever supported, will be applicable for supporting tip tap content in submissions
-      deleteFormSubmissionAttachment: (state, action) => {
-        if (state.attachments[action.payload] === void 0) {
-          throw new Error(`Attachment with offline_id ${action.payload} does not exist`);
-        }
-        delete state.attachments[action.payload];
-      },
-      deleteFormSubmissionAttachments: (state, action) => {
-        for (const offlineId of action.payload) {
-          if (state.attachments[offlineId] === void 0) {
-            throw new Error(`Attachment with offline_id ${offlineId} does not exist`);
-          }
-          delete state.attachments[offlineId];
-        }
-      }
+      setFormSubmission: submissionAdapter.setOne,
+      setFormSubmissions: submissionAdapter.setMany,
+      addFormSubmission: submissionAdapter.addOne,
+      addFormSubmissions: submissionAdapter.addMany,
+      updateFormSubmission: submissionAdapter.updateOne,
+      updateFormSubmissions: submissionAdapter.updateMany,
+      deleteFormSubmission: submissionAdapter.deleteOne,
+      deleteFormSubmissions: submissionAdapter.deleteMany
     }
   });
   const {
@@ -3995,16 +3362,10 @@ var __publicField = (obj, key, value) => {
     updateFormSubmission,
     updateFormSubmissions,
     deleteFormSubmission,
-    deleteFormSubmissions,
-    addFormSubmissionAttachment,
-    addFormSubmissionAttachments,
-    setFormSubmissionAttachments,
-    updateFormSubmissionAttachments,
-    deleteFormSubmissionAttachment,
-    deleteFormSubmissionAttachments
+    deleteFormSubmissions
   } = formSubmissionSlice.actions;
   const selectFormSubmissionsMapping = (state) => {
-    return state.formSubmissionReducer.formSubmissions;
+    return state.formSubmissionReducer.instances;
   };
   const selectFormSubmissions = toolkit.createSelector(
     [selectFormSubmissionsMapping],
@@ -4013,7 +3374,7 @@ var __publicField = (obj, key, value) => {
     }
   );
   const selectFormSubmission = (submissionId) => (state) => {
-    return state.formSubmissionReducer.formSubmissions[submissionId];
+    return state.formSubmissionReducer.instances[submissionId];
   };
   const selectFormSubmissionsOfForm = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
@@ -4118,8 +3479,40 @@ var __publicField = (obj, key, value) => {
       return assetSubmissionMapping;
     }
   );
+  const formSubmissionReducer = formSubmissionSlice.reducer;
+  const formSubmissionAttachmentAdapter = createModelAdapter(
+    (attachment) => attachment.offline_id
+  );
+  const initialState$a = formSubmissionAttachmentAdapter.getInitialState({});
+  const formSubmissionAttachmentSlice = toolkit.createSlice({
+    name: "formSubmissionAttachments",
+    initialState: initialState$a,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$a)),
+    reducers: {
+      initializeFormSubmissionAttachments: formSubmissionAttachmentAdapter.initialize,
+      addFormSubmissionAttachment: formSubmissionAttachmentAdapter.addOne,
+      addFormSubmissionAttachments: formSubmissionAttachmentAdapter.addMany,
+      setFormSubmissionAttachment: formSubmissionAttachmentAdapter.setOne,
+      setFormSubmissionAttachments: formSubmissionAttachmentAdapter.setMany,
+      updateFormSubmissionAttachment: formSubmissionAttachmentAdapter.updateOne,
+      updateFormSubmissionAttachments: formSubmissionAttachmentAdapter.updateMany,
+      deleteFormSubmissionAttachment: formSubmissionAttachmentAdapter.deleteOne,
+      deleteFormSubmissionAttachments: formSubmissionAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeFormSubmissionAttachments,
+    addFormSubmissionAttachment,
+    addFormSubmissionAttachments,
+    setFormSubmissionAttachment,
+    setFormSubmissionAttachments,
+    updateFormSubmissionAttachment,
+    updateFormSubmissionAttachments,
+    deleteFormSubmissionAttachment,
+    deleteFormSubmissionAttachments
+  } = formSubmissionAttachmentSlice.actions;
   const selectFormSubmissionAttachmentsMapping = (state) => {
-    return state.formSubmissionReducer.attachments;
+    return state.formSubmissionAttachmentReducer.instances;
   };
   const selectAttachmentsOfFormSubmission = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
@@ -4129,48 +3522,81 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const formSubmissionReducer = formSubmissionSlice.reducer;
-  const initialState$4 = {
-    emailDomains: {}
+  const formSubmissionAttachmentReducer = formSubmissionAttachmentSlice.reducer;
+  const formRevisionAttachmentAdapter = createModelAdapter(
+    (attachment) => attachment.offline_id
+  );
+  const initialState$9 = formRevisionAttachmentAdapter.getInitialState({});
+  const formRevisionAttachmentSlice = toolkit.createSlice({
+    name: "formRevisionAttachments",
+    initialState: initialState$9,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$9)),
+    reducers: {
+      initializeFormRevisionAttachments: formRevisionAttachmentAdapter.initialize,
+      addFormRevisionAttachment: formRevisionAttachmentAdapter.addOne,
+      addFormRevisionAttachments: formRevisionAttachmentAdapter.addMany,
+      setFormRevisionAttachment: formRevisionAttachmentAdapter.setOne,
+      setFormRevisionAttachments: formRevisionAttachmentAdapter.setMany,
+      updateFormRevisionAttachment: formRevisionAttachmentAdapter.updateOne,
+      updateFormRevisionAttachments: formRevisionAttachmentAdapter.updateMany,
+      deleteFormRevisionAttachment: formRevisionAttachmentAdapter.deleteOne,
+      deleteFormRevisionAttachments: formRevisionAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeFormRevisionAttachments,
+    addFormRevisionAttachment,
+    addFormRevisionAttachments,
+    setFormRevisionAttachment,
+    setFormRevisionAttachments,
+    updateFormRevisionAttachment,
+    updateFormRevisionAttachments,
+    deleteFormRevisionAttachment,
+    deleteFormRevisionAttachments
+  } = formRevisionAttachmentSlice.actions;
+  const selectUserFormRevisionAttachmentsMapping = (state) => {
+    return state.formRevisionAttachmentReducer.instances;
   };
+  const selectAttachmentsOfFormRevision = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectUserFormRevisionAttachmentsMapping, (_state, revisionId) => revisionId],
+      (attachments, revisionId) => {
+        return Object.values(attachments).filter((attachment) => attachment.revision === revisionId);
+      }
+    )
+  );
+  const formRevisionAttachmentReducer = formRevisionAttachmentSlice.reducer;
+  const emailDomainAdapter = createModelAdapter((emailDomain) => emailDomain.offline_id);
+  const initialState$8 = emailDomainAdapter.getInitialState({});
   const emailDomainsSlice = toolkit.createSlice({
     name: "emailDomains",
-    initialState: initialState$4,
+    initialState: initialState$8,
     reducers: {
-      setEmailDomains: (state, action) => {
-        const emailDomains = {};
-        action.payload.forEach((emailDomain) => {
-          emailDomains[emailDomain.offline_id] = emailDomain;
-        });
-        state.emailDomains = emailDomains;
-      },
-      addEmailDomain: (state, action) => {
-        state.emailDomains[action.payload.offline_id] = action.payload;
-      },
-      removeEmailDomain: (state, action) => {
-        if (action.payload.offline_id in state.emailDomains) {
-          delete state.emailDomains[action.payload.offline_id];
-        } else {
-          throw new Error(`Tried to remove email domain with ID that doesn't exist: ${action.payload.offline_id}`);
-        }
-      }
+      initializeEmailDomains: emailDomainAdapter.initialize,
+      addEmailDomain: emailDomainAdapter.addOne,
+      deleteEmailDomain: emailDomainAdapter.deleteOne
     }
   });
-  const { setEmailDomains, addEmailDomain, removeEmailDomain } = emailDomainsSlice.actions;
-  const selectEmailDomainsAsMapping = (state) => state.emailDomainsReducer.emailDomains;
-  const selectSortedEmailDomains = (state) => Object.values(state.emailDomainsReducer.emailDomains).sort(
-    (ed1, ed2) => ed1.domain.localeCompare(ed2.domain)
+  const { initializeEmailDomains, addEmailDomain, deleteEmailDomain } = emailDomainsSlice.actions;
+  const selectEmailDomainsAsMapping = (state) => state.emailDomainsReducer.instances;
+  const selectEmailDomains = (state) => Object.values(state.emailDomainsReducer.instances);
+  const selectEmailDomainsOfOrganization = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectEmailDomains, (_, organizationId) => organizationId],
+      (emailDomains, organizationId) => {
+        return emailDomains.filter((emailDomain) => emailDomain.organization === organizationId);
+      }
+    )
   );
   const emailDomainsReducer = emailDomainsSlice.reducer;
-  const initialState$3 = {
-    documents: {},
-    attachments: {}
+  const initialState$7 = {
+    documents: {}
   };
   const documentSlice = toolkit.createSlice({
     name: "documents",
-    initialState: initialState$3,
+    initialState: initialState$7,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$3);
+      Object.assign(state, initialState$7);
     }),
     reducers: {
       setDocuments: (state, action) => {
@@ -4310,34 +3736,10 @@ var __publicField = (obj, key, value) => {
           }
           delete state.documents[documentId];
         }
-      },
-      // Attachments
-      setDocumentAttachment: setAttachment,
-      setDocumentAttachments: setAttachments,
-      addDocumentAttachment: addAttachment,
-      addDocumentAttachments: addAttachments,
-      updateDocumentAttachment: updateAttachment,
-      updateDocumentAttachments: updateAttachments,
-      removeDocumentAttachment: removeAttachment,
-      removeDocumentAttachments: removeAttachments
+      }
     }
   });
-  const {
-    setDocuments,
-    addDocuments,
-    updateDocuments,
-    moveDocument,
-    removeDocuments,
-    // Attachments
-    setDocumentAttachment,
-    setDocumentAttachments,
-    addDocumentAttachment,
-    addDocumentAttachments,
-    updateDocumentAttachment,
-    updateDocumentAttachments,
-    removeDocumentAttachment,
-    removeDocumentAttachments
-  } = documentSlice.actions;
+  const { setDocuments, addDocuments, updateDocuments, moveDocument, removeDocuments } = documentSlice.actions;
   const selectDocumentsMapping = (state) => state.documentsReducer.documents;
   const selectDocuments = toolkit.createSelector(
     [selectDocumentsMapping],
@@ -4367,13 +3769,43 @@ var __publicField = (obj, key, value) => {
     [selectDocuments],
     (documents) => documents.filter((document2) => !document2.parent_document)
   );
-  const selectDocumentAttachmentMapping = (state) => state.documentsReducer.attachments;
+  const documentsReducer = documentSlice.reducer;
+  const documentAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
+  const initialState$6 = documentAttachmentAdapter.getInitialState({});
+  const documentAttachmentSlice = toolkit.createSlice({
+    name: "documentAttachments",
+    initialState: initialState$6,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
+    reducers: {
+      initializeDocumentAttachments: documentAttachmentAdapter.initialize,
+      addDocumentAttachment: documentAttachmentAdapter.addOne,
+      addDocumentAttachments: documentAttachmentAdapter.addMany,
+      setDocumentAttachment: documentAttachmentAdapter.setOne,
+      setDocumentAttachments: documentAttachmentAdapter.setMany,
+      updateDocumentAttachment: documentAttachmentAdapter.updateOne,
+      updateDocumentAttachments: documentAttachmentAdapter.updateMany,
+      deleteDocumentAttachment: documentAttachmentAdapter.deleteOne,
+      deleteDocumentAttachments: documentAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeDocumentAttachments,
+    addDocumentAttachment,
+    addDocumentAttachments,
+    setDocumentAttachment,
+    setDocumentAttachments,
+    updateDocumentAttachment,
+    updateDocumentAttachments,
+    deleteDocumentAttachment,
+    deleteDocumentAttachments
+  } = documentAttachmentSlice.actions;
+  const selectDocumentAttachmentMapping = (state) => state.documentAttachmentReducer.instances;
   const selectAllDocumentAttachments = toolkit.createSelector(
     [selectDocumentAttachmentMapping],
     (mapping) => Object.values(mapping)
   );
   const selectDocumentAttachment = (attachmentId) => (state) => {
-    return state.documentsReducer.attachments[attachmentId];
+    return state.documentAttachmentReducer.instances[attachmentId];
   };
   const selectAttachmentsOfDocument = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
@@ -4400,48 +3832,28 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const documentsReducer = documentSlice.reducer;
-  const initialState$2 = {
-    teams: {}
-  };
+  const documentAttachmentReducer = documentAttachmentSlice.reducer;
+  const teamAdapter = createModelAdapter((team) => team.offline_id);
+  const initialState$5 = teamAdapter.getInitialState({});
   const teamSlice = toolkit.createSlice({
     name: "teams",
-    initialState: initialState$2,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$2)),
+    initialState: initialState$5,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
     reducers: {
-      setTeam: (state, action) => {
-        state.teams[action.payload.offline_id] = action.payload;
-      },
-      setTeams: (state, action) => {
-        state.teams = {};
-        for (const team of action.payload) {
-          state.teams[team.offline_id] = team;
-        }
-      },
-      addTeam: (state, action) => {
-        if (state.teams[action.payload.offline_id]) {
-          throw new Error(`Team with offline_id ${action.payload.offline_id} already exists`);
-        }
-        state.teams[action.payload.offline_id] = action.payload;
-      },
-      updateTeam: (state, action) => {
-        if (!state.teams[action.payload.offline_id]) {
-          throw new Error(`Team with offline_id ${action.payload.offline_id} does not exist`);
-        }
-        state.teams[action.payload.offline_id] = action.payload;
-      },
-      deleteTeam: (state, action) => {
-        delete state.teams[action.payload];
-      }
+      setTeam: teamAdapter.setOne,
+      setTeams: teamAdapter.initialize,
+      addTeam: teamAdapter.addOne,
+      updateTeam: teamAdapter.updateOne,
+      deleteTeam: teamAdapter.deleteOne
     }
   });
   const { setTeam, setTeams, addTeam, updateTeam, deleteTeam } = teamSlice.actions;
-  const selectTeamsMapping = (state) => state.teamReducer.teams;
+  const selectTeamsMapping = (state) => state.teamReducer.instances;
   const selectTeams = toolkit.createSelector([selectTeamsMapping], (teams) => {
     return Object.values(teams);
   });
   const selectTeam = (teamId) => (state) => {
-    return state.teamReducer.teams[teamId];
+    return state.teamReducer.instances[teamId];
   };
   const selectTeamsOfOrganization = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
@@ -4457,43 +3869,23 @@ var __publicField = (obj, key, value) => {
     })
   );
   const teamReducer = teamSlice.reducer;
-  const initialState$1 = {
-    conversations: {}
-  };
+  const agentUserConversationAdapter = createModelAdapter(
+    (conversation) => conversation.offline_id
+  );
+  const initialState$4 = agentUserConversationAdapter.getInitialState({});
   const agentsSlice = toolkit.createSlice({
     name: "agents",
-    initialState: initialState$1,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$1)),
+    initialState: initialState$4,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
     reducers: {
-      setConversations: (state, action) => {
-        state.conversations = {};
-        for (const conversation of action.payload) {
-          state.conversations[conversation.offline_id] = conversation;
-        }
-      },
-      addConversation: (state, action) => {
-        if (action.payload.offline_id in state.conversations) {
-          throw new Error("Conversation already exists in history");
-        }
-        state.conversations[action.payload.offline_id] = action.payload;
-      },
-      setConversation: (state, action) => {
-        if (!(action.payload.offline_id in state.conversations)) {
-          throw new Error("Conversation does not exist in history");
-        }
-        state.conversations[action.payload.offline_id] = action.payload;
-      },
-      updateConversation: (state, action) => {
-        const existing = state.conversations[action.payload.offline_id];
-        if (!existing) {
-          throw new Error("Conversation does not exist in history");
-        }
-        state.conversations[action.payload.offline_id] = { ...existing, ...action.payload };
-      }
+      initializeConversations: agentUserConversationAdapter.initialize,
+      addConversation: agentUserConversationAdapter.addOne,
+      setConversation: agentUserConversationAdapter.setOne,
+      updateConversation: agentUserConversationAdapter.updateOne
     }
   });
-  const { setConversations, addConversation, setConversation, updateConversation } = agentsSlice.actions;
-  const selectConversationMapping = (state) => state.agentsReducer.conversations;
+  const { initializeConversations, addConversation, setConversation, updateConversation } = agentsSlice.actions;
+  const selectConversationMapping = (state) => state.agentsReducer.instances;
   const selectConversations = toolkit.createSelector(
     [selectConversationMapping],
     (conversationMapping) => Object.values(conversationMapping)
@@ -4505,6 +3897,132 @@ var __publicField = (obj, key, value) => {
     )
   );
   const agentsReducer = agentsSlice.reducer;
+  const issueCommentAdapter = createModelAdapter((comment) => comment.offline_id);
+  const initialState$3 = issueCommentAdapter.getInitialState({});
+  const issueCommentSlice = toolkit.createSlice({
+    name: "issueComments",
+    initialState: initialState$3,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$3)),
+    reducers: {
+      addIssueComment: issueCommentAdapter.addOne,
+      addIssueComments: issueCommentAdapter.addMany,
+      setIssueComment: issueCommentAdapter.setOne,
+      setIssueComments: issueCommentAdapter.setMany,
+      deleteIssueComment: issueCommentAdapter.deleteOne,
+      deleteIssueComments: issueCommentAdapter.deleteMany
+    }
+  });
+  const {
+    setIssueComments,
+    setIssueComment,
+    addIssueComment,
+    addIssueComments,
+    deleteIssueComment,
+    deleteIssueComments
+  } = issueCommentSlice.actions;
+  const selectIssueCommentMapping = (state) => state.issueCommentReducer.instances;
+  const selectCommentsOfIssue = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectIssueCommentMapping, (_state, issueId) => issueId],
+      (commentMapping, issueId) => {
+        return Object.values(commentMapping).filter((comment) => comment.issue === issueId);
+      }
+    )
+  );
+  const issueCommentReducer = issueCommentSlice.reducer;
+  const issueUpdateAdapter = createModelAdapter((issueUpdate) => issueUpdate.offline_id);
+  const initialState$2 = issueUpdateAdapter.getInitialState({});
+  const issueUpdateSlice = toolkit.createSlice({
+    name: "issueUpdates",
+    initialState: initialState$2,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$2)),
+    reducers: {
+      initializeIssueUpdates: issueUpdateAdapter.setMany,
+      setIssueUpdate: issueUpdateAdapter.setOne,
+      addIssueUpdate: issueUpdateAdapter.addOne,
+      addIssueUpdates: issueUpdateAdapter.addMany,
+      deleteIssueUpdate: issueUpdateAdapter.deleteOne,
+      deleteIssueUpdates: issueUpdateAdapter.deleteMany
+    }
+  });
+  const {
+    initializeIssueUpdates,
+    setIssueUpdate,
+    addIssueUpdate,
+    addIssueUpdates,
+    deleteIssueUpdate,
+    deleteIssueUpdates
+  } = issueUpdateSlice.actions;
+  const selectIssueUpdateMapping = (state) => state.issueUpdateReducer.instances;
+  const selectIssueUpdatesOfIssue = restructureCreateSelectorWithArgs(
+    toolkit.createSelector([selectIssueUpdateMapping, (_state, issueId) => issueId], (updates, issueId) => {
+      return Object.values(updates).filter((update) => update.issue === issueId);
+    })
+  );
+  const issueUpdateReducer = issueUpdateSlice.reducer;
+  const issueAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
+  const initialState$1 = issueAttachmentAdapter.getInitialState({});
+  const issueAttachmentSlice = toolkit.createSlice({
+    name: "issueAttachments",
+    initialState: initialState$1,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$1)),
+    reducers: {
+      initializeIssueAttachments: issueAttachmentAdapter.initialize,
+      addIssueAttachment: issueAttachmentAdapter.addOne,
+      addIssueAttachments: issueAttachmentAdapter.addMany,
+      setIssueAttachment: issueAttachmentAdapter.setOne,
+      setIssueAttachments: issueAttachmentAdapter.setMany,
+      updateIssueAttachment: issueAttachmentAdapter.updateOne,
+      updateIssueAttachments: issueAttachmentAdapter.updateMany,
+      deleteIssueAttachment: issueAttachmentAdapter.deleteOne,
+      deleteIssueAttachments: issueAttachmentAdapter.deleteMany
+    }
+  });
+  const {
+    initializeIssueAttachments,
+    addIssueAttachment,
+    addIssueAttachments,
+    setIssueAttachment,
+    setIssueAttachments,
+    updateIssueAttachment,
+    updateIssueAttachments,
+    deleteIssueAttachment,
+    deleteIssueAttachments
+  } = issueAttachmentSlice.actions;
+  const selectIssueAttachmentMapping = (state) => state.issueAttachmentReducer.instances;
+  const selectIssueAttachments = toolkit.createSelector(
+    [selectIssueAttachmentMapping],
+    (mapping) => Object.values(mapping)
+  );
+  const selectAttachmentsOfIssue = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectIssueAttachments, (_state, issueId) => issueId],
+      (attachments, issueId) => {
+        return attachments.filter(({ issue }) => issueId === issue);
+      }
+    )
+  );
+  const selectIssueAttachment = (attachmentId) => (root) => {
+    return root.issueAttachmentReducer.instances[attachmentId];
+  };
+  const selectAttachmentsOfIssueByType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectIssueAttachments, (_state, issueId) => issueId],
+      (attachments, issueId) => {
+        const attachmentsOfIssue = attachments.filter(({ issue }) => issue === issueId);
+        const fileAttachments = attachmentsOfIssue.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => !file_type || !file_type.startsWith("image/")
+        );
+        const imageAttachments = attachmentsOfIssue.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => file_type && file_type.startsWith("image/")
+        );
+        return { fileAttachments, imageAttachments };
+      }
+    )
+  );
+  const issueAttachmentReducer = issueAttachmentSlice.reducer;
   const initialState = {
     version: 0
   };
@@ -4533,15 +4051,19 @@ var __publicField = (obj, key, value) => {
     authReducer,
     categoryReducer,
     assetReducer,
+    assetAttachmentReducer,
     assetStageCompletionReducer,
     assetStageReducer,
     assetTypeReducer,
+    assetTypeAttachmentReducer,
     issueReducer,
+    issueAttachmentReducer,
     issueTypeReducer,
     mapReducer,
     organizationReducer,
     outboxReducer,
     projectReducer,
+    projectAttachmentReducer,
     projectAccessReducer,
     organizationAccessReducer,
     projectFileReducer,
@@ -4549,20 +4071,25 @@ var __publicField = (obj, key, value) => {
     settingReducer,
     formReducer,
     formRevisionReducer,
+    formRevisionAttachmentReducer,
+    formSubmissionAttachmentReducer,
     formSubmissionReducer,
     userReducer,
     workspaceReducer,
     emailDomainsReducer,
     licenseReducer,
     documentsReducer,
+    documentAttachmentReducer,
     teamReducer,
-    agentsReducer
+    agentsReducer,
+    issueCommentReducer,
+    issueUpdateReducer
   };
   const overmapReducer = toolkit.combineReducers(overmapReducers);
   const resetStore = "RESET";
   function handleWorkspaceRemoval(draft, action) {
     const workspaceId = action.payload;
-    const issuesVisibleInWorkspace = Object.values(draft.issueReducer.issues).filter(
+    const issuesVisibleInWorkspace = Object.values(draft.issueReducer.instances).filter(
       (issue) => issue.visible_in_workspaces.includes(workspaceId)
     );
     const mainWorkspace = selectMainWorkspace(draft);
@@ -5288,24 +4815,14 @@ var __publicField = (obj, key, value) => {
       });
       return [categoryWithWorkspace, promise];
     }
-    fetchAll(projectId) {
-      const promise = this.client.enqueueRequest({
-        description: "Get categories",
-        method: HttpMethod.GET,
-        url: `/projects/${projectId}/categories/`,
-        blocks: [],
-        blockers: []
-      });
-      const offlineCategories = Object.values(this.client.store.getState().categoryReducer.categories);
-      return [offlineCategories, promise];
-    }
     update(category, workspaceId) {
-      const existingCategory = this.client.store.getState().categoryReducer.categories[category.offline_id];
+      const state = this.client.store.getState();
+      const existingCategory = selectCategoryById(category.offline_id)(state);
       if (!existingCategory) {
         throw new Error(`Expected an existing category with offline_id ${category.offline_id}`);
       }
-      this.client.store.dispatch(patchCategory(category));
       const optimisticCategory = { ...existingCategory, ...category };
+      this.client.store.dispatch(updateCategory(optimisticCategory));
       const promise = this.client.enqueueRequest({
         description: "Edit Category",
         method: HttpMethod.PATCH,
@@ -5320,7 +4837,7 @@ var __publicField = (obj, key, value) => {
       return [optimisticCategory, promise];
     }
     remove(category, workspaceId) {
-      this.client.store.dispatch(removeCategory(category.offline_id));
+      this.client.store.dispatch(deleteCategory(category.offline_id));
       return this.client.enqueueRequest({
         description: "Delete Category",
         method: HttpMethod.DELETE,
@@ -5333,33 +4850,20 @@ var __publicField = (obj, key, value) => {
         blocks: []
       });
     }
-    /**
-     * Overwrites the store with whatever categories are on the server.
-     * @returns A promise that resolves to an empty result.
-     * @throws An APIError if the request fails.
-     * @throws An Error if there is no active project, or for any other unexpected error.
-     * @example
-     * ```typescript
-     * try {
-     * 	 await sdk.category.refreshStore()
-     * } catch (e) {
-     * 	 if (e instanceof APIError) {
-     * 	   // handle error
-     * 	   return
-     * 	 }
-     * 	 throw e
-     * }
-     * ```
-     */
     async refreshStore() {
       const { store } = this.client;
       const projectId = store.getState().projectReducer.activeProjectId;
       if (!projectId) {
         throw new Error("No active project");
       }
-      const [_offlineCategories, promise] = this.fetchAll(projectId);
-      const result = await promise;
-      store.dispatch(setCategories(result));
+      const result = await this.client.enqueueRequest({
+        description: "Get categories",
+        method: HttpMethod.GET,
+        url: `/projects/${projectId}/categories/`,
+        blocks: [],
+        blockers: []
+      });
+      store.dispatch(initializeCategories(result));
     }
   }
   function chunkArray(arr, chunkSize) {
@@ -5410,10 +4914,10 @@ var __publicField = (obj, key, value) => {
       if (!assetToBeDeleted)
         throw new Error(`No asset with id ${assetId} found in the store`);
       const attachmentsOfAssets = selectAttachmentsOfAsset(assetId)(store.getState());
-      store.dispatch(removeAsset(assetId));
+      store.dispatch(deleteAsset(assetId));
       if (attachmentsOfAssets.length > 0) {
         const attachmentsOfAssetIds = attachmentsOfAssets.map(({ offline_id }) => offline_id);
-        store.dispatch(removeAssetAttachments(attachmentsOfAssetIds));
+        store.dispatch(deleteAssetAttachments(attachmentsOfAssetIds));
       }
       return this.client.enqueueRequest({
         description: "Delete asset",
@@ -5430,10 +4934,10 @@ var __publicField = (obj, key, value) => {
     async deleteAllAssetsOfAssetType(assetTypeId) {
       const { store } = this.client;
       const state = store.getState();
-      const allAssetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state);
-      const allAssetsOfAssetTypeIds = (allAssetsOfAssetType || []).map((c) => c.offline_id);
+      const allAssetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state) ?? [];
+      const allAssetsOfAssetTypeIds = allAssetsOfAssetType.map((c) => c.offline_id);
       const affectedOfflineIds = [assetTypeId, ...allAssetsOfAssetTypeIds];
-      store.dispatch(removeAllAssetsOfType(assetTypeId));
+      store.dispatch(deleteAssets(allAssetsOfAssetTypeIds));
       return this.client.enqueueRequest({
         description: "Delete all assets of asset type",
         method: HttpMethod.DELETE,
@@ -5441,9 +4945,7 @@ var __publicField = (obj, key, value) => {
         blockers: affectedOfflineIds,
         blocks: affectedOfflineIds
       }).catch((err) => {
-        if (allAssetsOfAssetType) {
-          store.dispatch(addAssetsInBatches(allAssetsOfAssetType));
-        }
+        store.dispatch(addAssets(allAssetsOfAssetType));
         throw err;
       });
     }
@@ -5493,7 +4995,7 @@ var __publicField = (obj, key, value) => {
       }
       void Promise.all(batchPromises).then((result) => {
         const allCreatedAssets = result.flat();
-        store.dispatch(addAssetsInBatches(allCreatedAssets));
+        store.dispatch(addAssets(allCreatedAssets));
       });
       return batchPromises;
     }
@@ -5506,14 +5008,14 @@ var __publicField = (obj, key, value) => {
         blockers: [],
         blocks: []
       });
-      store.dispatch(setAssets(result));
+      store.dispatch(initializeAssets(result));
     }
   }
   class AssetStageCompletionService extends BaseApiService {
     add(assetId, stageId) {
       var _a2;
       const { store } = this.client;
-      const assetTypeId = (_a2 = store.getState().assetReducer.assets[assetId]) == null ? void 0 : _a2.asset_type;
+      const assetTypeId = (_a2 = selectAsset(assetId)(store.getState())) == null ? void 0 : _a2.asset_type;
       if (!assetTypeId) {
         throw new Error(`Asset with offline_id ${assetId} not found`);
       }
@@ -5667,7 +5169,11 @@ var __publicField = (obj, key, value) => {
     }
     async linkForm(stageId, formId2) {
       const { store } = this.client;
-      store.dispatch(linkStageToForm({ stageId, formId: formId2 }));
+      const stage = store.getState().assetStageReducer.instances[stageId];
+      if (!stage) {
+        throw new Error(`No asset stage with id ${stageId} found in the store`);
+      }
+      store.dispatch(updateStage({ ...stage, user_form: formId2 }));
       try {
         await this.client.enqueueRequest({
           description: "Link asset stage to form",
@@ -5678,13 +5184,17 @@ var __publicField = (obj, key, value) => {
           blocks: [stageId]
         });
       } catch (e) {
-        store.dispatch(unlinkStageToForm({ stageId }));
+        store.dispatch(setStage(stage));
         throw e;
       }
     }
     async unlinkForm(stageId, formId2) {
       const { store } = this.client;
-      store.dispatch(unlinkStageToForm({ stageId }));
+      const stage = store.getState().assetStageReducer.instances[stageId];
+      if (!stage) {
+        throw new Error(`No asset stage with id ${stageId} found in the store`);
+      }
+      store.dispatch(updateStage({ ...stage, user_form: void 0 }));
       try {
         await this.client.enqueueRequest({
           description: "Unlink asset stage from form",
@@ -5694,7 +5204,7 @@ var __publicField = (obj, key, value) => {
           blocks: [stageId]
         });
       } catch (e) {
-        store.dispatch(linkStageToForm({ stageId, formId: formId2 }));
+        store.dispatch(setStage(stage));
         throw e;
       }
     }
@@ -5707,7 +5217,7 @@ var __publicField = (obj, key, value) => {
         blockers: [],
         blocks: []
       });
-      store.dispatch(addStages(result));
+      store.dispatch(initializeStages(result));
     }
   }
   const AttachmentModelMeta = {
@@ -5745,22 +5255,22 @@ var __publicField = (obj, key, value) => {
   class BaseAttachmentService extends BaseApiService {
     getNumberOfAttachmentsWithSha1(sha1) {
       const {
-        issueReducer: issueReducer2,
-        assetReducer: assetReducer2,
-        assetTypeReducer: assetTypeReducer2,
-        documentsReducer: documentsReducer2,
-        projectReducer: projectReducer2,
-        formSubmissionReducer: formSubmissionReducer2,
-        formRevisionReducer: formRevisionReducer2
+        issueAttachmentReducer: issueAttachmentReducer2,
+        assetAttachmentReducer: assetAttachmentReducer2,
+        assetTypeAttachmentReducer: assetTypeAttachmentReducer2,
+        documentAttachmentReducer: documentAttachmentReducer2,
+        projectAttachmentReducer: projectAttachmentReducer2,
+        formSubmissionAttachmentReducer: formSubmissionAttachmentReducer2,
+        formRevisionAttachmentReducer: formRevisionAttachmentReducer2
       } = this.client.store.getState();
       const objectsWithSha1 = [].concat(
-        Object.values(issueReducer2.attachments),
-        Object.values(assetReducer2.attachments),
-        Object.values(assetTypeReducer2.attachments),
-        Object.values(documentsReducer2.attachments),
-        Object.values(projectReducer2.attachments),
-        Object.values(formRevisionReducer2.attachments),
-        Object.values(formSubmissionReducer2.attachments)
+        Object.values(issueAttachmentReducer2.instances),
+        Object.values(assetAttachmentReducer2.instances),
+        Object.values(assetTypeAttachmentReducer2.instances),
+        Object.values(documentAttachmentReducer2.instances),
+        Object.values(projectAttachmentReducer2.instances),
+        Object.values(formRevisionAttachmentReducer2.instances),
+        Object.values(formSubmissionAttachmentReducer2.instances)
       );
       return objectsWithSha1.filter((object) => object.file_sha1 === sha1).length;
     }
@@ -5780,22 +5290,7 @@ var __publicField = (obj, key, value) => {
         });
       }
     }
-    // Note that currently the fetching of attachments for all models dependds on the active projectId. This may change in the future. And
-    //  so for some attachment model services, this method will have to be overridden.
-    async getAttachments(actions) {
-      const { store } = this.client;
-      const activeProjectId = store.getState().projectReducer.activeProjectId;
-      const meta = AttachmentModelMeta[this.attachmentModel];
-      const result = await this.client.enqueueRequest({
-        description: `Get ${meta.name} attachments`,
-        method: HttpMethod.GET,
-        url: `/projects/${activeProjectId}${meta.fetchUrlPostfix}/`,
-        blocks: [],
-        blockers: []
-      });
-      store.dispatch(actions.setAttachments(result));
-    }
-    async attachFiles(files, modelId, buildOfflineAttachment, actions) {
+    async attachFiles(files, modelId, buildOfflineAttachment) {
       const { store } = this.client;
       const currentUser = store.getState().userReducer.currentUser;
       const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -5829,7 +5324,7 @@ var __publicField = (obj, key, value) => {
           description: offlineAttachment.description
         });
       }
-      store.dispatch(actions.addAttachments(offlineAttachments));
+      store.dispatch(this.addAttachments(offlineAttachments));
       const meta = AttachmentModelMeta[this.attachmentModel];
       const promise = this.client.enqueueRequest({
         description: `Attach files to ${meta.name}`,
@@ -5844,22 +5339,22 @@ var __publicField = (obj, key, value) => {
         blockers: offlineAttachments.map((attachment) => attachment.file_sha1)
       });
       promise.then(({ attachments, presigned_urls }) => {
-        store.dispatch(actions.updateAttachments(attachments));
+        store.dispatch(this.updateAttachments(attachments));
         this.processPresignedUrls(presigned_urls);
       }).catch(() => {
-        store.dispatch(actions.removeAttachments(offlineAttachments.map((attachment) => attachment.offline_id)));
+        store.dispatch(this.removeAttachments(offlineAttachments.map((attachment) => attachment.offline_id)));
       });
       return [offlineAttachments, promise.then(({ attachments }) => attachments)];
     }
-    async deleteAttachment(attachmendId, actions, selectors) {
+    async deleteAttachment(attachmendId) {
       const { store } = this.client;
-      const attachment = selectors.selectAttachment(attachmendId)(store.getState());
+      const attachment = this.selectAttachment(attachmendId)(store.getState());
       if (!attachment) {
         throw new Error(
           `Attempting to delete attachment with offline_id ${attachmendId} that does not exist in the store`
         );
       }
-      store.dispatch(actions.removeAttachment(attachment.offline_id));
+      store.dispatch(this.removeAttachment(attachment.offline_id));
       const meta = AttachmentModelMeta[this.attachmentModel];
       const promise = this.client.enqueueRequest({
         description: "Delete attachment",
@@ -5873,15 +5368,37 @@ var __publicField = (obj, key, value) => {
           void this.client.files.removeCache(attachment.file_sha1);
         }
       }).catch(() => {
-        store.dispatch(actions.setAttachment(attachment));
+        store.dispatch(this.setAttachment(attachment));
       });
       return promise;
     }
+    // Note that currently the fetching of attachments for all models dependds on the active projectId. This may change in the future. And
+    //  so for some attachment model services, this method will have to be overridden.
+    async refreshStore() {
+      const { store } = this.client;
+      const activeProjectId = store.getState().projectReducer.activeProjectId;
+      const meta = AttachmentModelMeta[this.attachmentModel];
+      const result = await this.client.enqueueRequest({
+        description: `Get ${meta.name} attachments`,
+        method: HttpMethod.GET,
+        url: `/projects/${activeProjectId}${meta.fetchUrlPostfix}/`,
+        blocks: [],
+        blockers: []
+      });
+      store.dispatch(this.initializeAttachments(result));
+    }
   }
   class AssetAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
       __publicField(this, "attachmentModel", AttachmentModel.Asset);
+      __publicField(this, "initializeAttachments", initializeAssetAttachments);
+      __publicField(this, "addAttachments", addAssetAttachments);
+      __publicField(this, "updateAttachments", updateAssetAttachments);
+      __publicField(this, "removeAttachments", deleteAssetAttachments);
+      __publicField(this, "removeAttachment", deleteAssetAttachment);
+      __publicField(this, "setAttachment", setAssetAttachment);
+      __publicField(this, "selectAttachment", selectAssetAttachment);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -5896,28 +5413,10 @@ var __publicField = (obj, key, value) => {
       });
     }
     async attachFilesToAsset(files, assetId) {
-      return this.attachFiles(files, assetId, this.buildOfflineAttachment.bind(this), {
-        addAttachments: addAssetAttachments,
-        updateAttachments: updateAssetAttachments,
-        removeAttachments: removeAssetAttachments
-      });
-    }
-    deleteAssetAttachment(attachmentId) {
-      return this.deleteAttachment(
-        attachmentId,
-        {
-          setAttachment: setAssetAttachment,
-          removeAttachment: removeAssetAttachment
-        },
-        {
-          selectAttachment: selectAssetAttachment
-        }
-      );
+      return this.attachFiles(files, assetId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore() {
-      return this.getAttachments({
-        setAttachments: setAssetAttachments
-      });
+    async deleteAssetAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class AssetTypeService extends BaseApiService {
@@ -5963,7 +5462,7 @@ var __publicField = (obj, key, value) => {
       }
       if (attachmentsOfAssetType.length > 0) {
         const attachmentsOfAssetTypeIds = attachmentsOfAssetType.map(({ offline_id }) => offline_id);
-        store.dispatch(removeAssetTypeAttachments(attachmentsOfAssetTypeIds));
+        store.dispatch(deleteAssetTypeAttachments(attachmentsOfAssetTypeIds));
       }
       return this.client.enqueueRequest({
         description: "Delete asset type",
@@ -5987,13 +5486,20 @@ var __publicField = (obj, key, value) => {
         blockers: [],
         blocks: []
       });
-      store.dispatch(setAssetTypes(result));
+      store.dispatch(initializeAssetTypes(result));
     }
   }
   class AssetTypeAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
       __publicField(this, "attachmentModel", AttachmentModel.AssetType);
+      __publicField(this, "initializeAttachments", initializeAssetTypeAttachments);
+      __publicField(this, "addAttachments", addAssetTypeAttachments);
+      __publicField(this, "updateAttachments", updateAssetTypeAttachments);
+      __publicField(this, "removeAttachments", deleteAssetTypeAttachments);
+      __publicField(this, "removeAttachment", deleteAssetTypeAttachment);
+      __publicField(this, "setAttachment", setAssetTypeAttachment);
+      __publicField(this, "selectAttachment", selectAssetTypeAttachment);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -6008,33 +5514,10 @@ var __publicField = (obj, key, value) => {
       });
     }
     async attachFilesToAssetType(files, assetTypeId) {
-      return this.attachFiles(
-        files,
-        assetTypeId,
-        this.buildOfflineAttachment.bind(this),
-        {
-          addAttachments: addAssetTypeAttachments,
-          updateAttachments: updateAssetTypeAttachments,
-          removeAttachments: removeAssetTypeAttachments
-        }
-      );
-    }
-    deleteAssetTypeAttachment(attachmentId) {
-      return this.deleteAttachment(
-        attachmentId,
-        {
-          setAttachment: setAssetTypeAttachment,
-          removeAttachment: removeAssetTypeAttachment
-        },
-        {
-          selectAttachment: selectAssetTypeAttachment
-        }
-      );
+      return this.attachFiles(files, assetTypeId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore() {
-      return this.getAttachments({
-        setAttachments: setAssetTypeAttachments
-      });
+    async deleteAssetTypeAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class IssueCommentService extends BaseApiService {
@@ -6056,13 +5539,13 @@ var __publicField = (obj, key, value) => {
         blocks: [offlineComment.offline_id]
       });
       promise.catch(() => {
-        store.dispatch(removeIssueComment(offlineComment.offline_id));
+        store.dispatch(deleteIssueComment(offlineComment.offline_id));
       });
       return [offlineComment, promise];
     }
     update(comment) {
       const { store } = this.client;
-      const commentToUpdate = store.getState().issueReducer.comments[comment.offline_id];
+      const commentToUpdate = store.getState().issueCommentReducer.instances[comment.offline_id];
       if (!commentToUpdate) {
         throw new Error(`Comment with offline_id ${comment.offline_id} not found in store`);
       }
@@ -6081,11 +5564,11 @@ var __publicField = (obj, key, value) => {
       return [comment, promise];
     }
     remove(offline_id) {
-      const commentToRemove = this.client.store.getState().issueReducer.comments[offline_id];
+      const commentToRemove = this.client.store.getState().issueCommentReducer.instances[offline_id];
       if (!commentToRemove) {
         throw new Error(`Comment with offline_id ${offline_id} not found in store`);
       }
-      this.client.store.dispatch(removeIssueComment(offline_id));
+      this.client.store.dispatch(deleteIssueComment(offline_id));
       const promise = this.client.enqueueRequest({
         description: "Delete comment",
         method: HttpMethod.DELETE,
@@ -6130,13 +5613,20 @@ var __publicField = (obj, key, value) => {
           `Received duplicate comments from the API (new length ${filteredResult.length}); filtered in browser.`
         );
       }
-      store.dispatch(setIssueUpdates(filteredResult));
+      store.dispatch(initializeIssueUpdates(filteredResult));
     }
   }
   class IssueAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
       __publicField(this, "attachmentModel", AttachmentModel.Issue);
+      __publicField(this, "initializeAttachments", initializeIssueAttachments);
+      __publicField(this, "addAttachments", addIssueAttachments);
+      __publicField(this, "updateAttachments", updateIssueAttachments);
+      __publicField(this, "removeAttachments", deleteIssueAttachments);
+      __publicField(this, "removeAttachment", deleteIssueAttachment);
+      __publicField(this, "setAttachment", setIssueAttachment);
+      __publicField(this, "selectAttachment", selectIssueAttachment);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -6151,28 +5641,10 @@ var __publicField = (obj, key, value) => {
       });
     }
     async attachFilesToIssue(files, issueId) {
-      return this.attachFiles(files, issueId, this.buildOfflineAttachment.bind(this), {
-        addAttachments: addIssueAttachments,
-        updateAttachments: updateIssueAttachments,
-        removeAttachments: removeIssueAttachments
-      });
-    }
-    deleteIssueAttachment(attachmentId) {
-      return this.deleteAttachment(
-        attachmentId,
-        {
-          setAttachment: setIssueAttachment,
-          removeAttachment: removeIssueAttachment
-        },
-        {
-          selectAttachment: selectIssueAttachment
-        }
-      );
+      return this.attachFiles(files, issueId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore() {
-      return this.getAttachments({
-        setAttachments: setIssueAttachments
-      });
+    async deleteIssueAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class IssueService extends BaseApiService {
@@ -6228,41 +5700,22 @@ var __publicField = (obj, key, value) => {
             severity: "danger"
           });
         }
-        store.dispatch(removeIssue(issuePayload.offline_id));
+        store.dispatch(deleteIssue(issuePayload.offline_id));
         store.dispatch(addActiveProjectIssuesCount(-1));
         throw error2;
       });
       return [issuePayload, promise];
     }
-    fetchAll(projectId) {
-      const promise = this.client.enqueueRequest({
-        description: "Get issues",
-        method: HttpMethod.GET,
-        url: `/projects/${projectId}/issues/`,
-        blockers: [],
-        blocks: []
-      }).then((result) => {
-        const filteredResult = result.filter(onlyUniqueOfflineIds);
-        if (result.length !== filteredResult.length) {
-          console.error(
-            `Received duplicate issues from the API (new length ${filteredResult.length});
-						 filtered in browser.`
-          );
-        }
-        return filteredResult;
-      });
-      const offlineIssues = Object.values(this.client.store.getState().issueReducer.issues);
-      return [offlineIssues, promise];
-    }
     update(issue) {
       const state = this.client.store.getState();
-      const issueToBeUpdated = state.issueReducer.issues[issue.offline_id];
+      const issueToBeUpdated = selectIssue(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`
         );
       }
-      this.client.store.dispatch(updateIssue(issue));
+      const updatedIssue = { ...issueToBeUpdated, ...issue };
+      this.client.store.dispatch(updateIssue(updatedIssue));
       const changes = {};
       for (const issueUpdateChange of [
         IssueUpdateChange.TITLE,
@@ -6279,7 +5732,7 @@ var __publicField = (obj, key, value) => {
               let categoryOrNull = null;
               const categoryIdOrNull = issue[issueUpdateChange];
               if (categoryIdOrNull) {
-                categoryOrNull = state.categoryReducer.categories[categoryIdOrNull] ?? null;
+                categoryOrNull = state.categoryReducer.instances[categoryIdOrNull] ?? null;
                 if (!categoryOrNull)
                   throw new Error(
                     `Trying to update issue category to ${categoryIdOrNull} which does not exist in store`
@@ -6342,28 +5795,26 @@ var __publicField = (obj, key, value) => {
       });
       promise.catch(() => {
         this.client.store.dispatch(updateIssue(issueToBeUpdated));
-        this.client.store.dispatch(removeIssueUpdate(offlineIssueUpdate.offline_id));
+        this.client.store.dispatch(deleteIssueUpdate(offlineIssueUpdate.offline_id));
       });
-      const fullIssue = state.issueReducer.issues[issue.offline_id];
-      return [fullIssue, promise];
+      return [updatedIssue, promise];
     }
     async remove(id) {
       const { store } = this.client;
       const state = store.getState();
       const dispatch = store.dispatch;
-      const backup = state.issueReducer.issues[id];
+      const backup = selectIssue(id)(state);
       if (!backup) {
         throw new Error(`No issue with id ${id} found in the store`);
       }
-      const attachments = Object.values(state.issueReducer.attachments).filter((a) => a.issue === id);
       const attachmentsOfIssue = selectAttachmentsOfIssue(id)(state);
       const updatesOfIssue = selectIssueUpdatesOfIssue(id)(state);
-      dispatch(removeIssue(id));
+      dispatch(deleteIssue(id));
       dispatch(addActiveProjectIssuesCount(-1));
       if (attachmentsOfIssue.length > 0)
-        dispatch(removeAttachmentsOfIssue(id));
+        dispatch(deleteIssueAttachments(attachmentsOfIssue.map(({ offline_id }) => offline_id)));
       if (updatesOfIssue.length > 0)
-        dispatch(removeIssueUpdates(updatesOfIssue.map(({ offline_id }) => offline_id)));
+        dispatch(deleteIssueUpdates(updatesOfIssue.map(({ offline_id }) => offline_id)));
       try {
         return await this.client.enqueueRequest({
           description: "Delete issue",
@@ -6374,7 +5825,7 @@ var __publicField = (obj, key, value) => {
         });
       } catch (e) {
         dispatch(addIssue(backup));
-        dispatch(addIssueAttachments(attachments));
+        dispatch(addIssueAttachments(attachmentsOfIssue));
         dispatch(addIssueUpdates(updatesOfIssue));
         dispatch(addActiveProjectIssuesCount(1));
         throw e;
@@ -6387,9 +5838,23 @@ var __publicField = (obj, key, value) => {
       if (!projectId) {
         throw new Error("No active project");
       }
-      const [_offlineIssues, promise] = this.fetchAll(projectId);
-      const result = await promise;
-      store.dispatch(setIssues(result));
+      const result = await this.client.enqueueRequest({
+        description: "Get issues",
+        method: HttpMethod.GET,
+        url: `/projects/${projectId}/issues/`,
+        blockers: [],
+        blocks: []
+      }).then((result2) => {
+        const filteredResult = result2.filter(onlyUniqueOfflineIds);
+        if (result2.length !== filteredResult.length) {
+          console.error(
+            `Received duplicate issues from the API (new length ${filteredResult.length});
+						 filtered in browser.`
+          );
+        }
+        return filteredResult;
+      });
+      store.dispatch(initializeIssues(result));
     }
   }
   class IssueTypeService extends BaseApiService {
@@ -6431,7 +5896,8 @@ var __publicField = (obj, key, value) => {
     }
     update(issueTypeFields) {
       const { store } = this.client;
-      const issueTypeToBeUpdated = store.getState().issueTypeReducer.issueTypes[issueTypeFields.offline_id];
+      const state = store.getState();
+      const issueTypeToBeUpdated = selectIssueType(issueTypeFields.offline_id)(state);
       if (!issueTypeToBeUpdated) {
         throw new Error(`IssueType with offline_id ${issueTypeFields.offline_id} does not exist in the store.`);
       }
@@ -6457,13 +5923,13 @@ var __publicField = (obj, key, value) => {
     delete(issueTypeId) {
       const { store } = this.client;
       const state = store.getState();
-      const issueTypeToDelete = state.issueTypeReducer.issueTypes[issueTypeId];
+      const issueTypeToDelete = selectIssueType(issueTypeId)(state);
       if (!issueTypeToDelete) {
         throw new Error(`IssueType with offline_id ${issueTypeId} does not exist in the store.`);
       }
       const issuesOfIssueType = selectIssuesOfIssueType(issueTypeId)(state) ?? [];
       store.dispatch(removeIssueType(issueTypeId));
-      store.dispatch(removeIssues(issuesOfIssueType.map((issue) => issue.offline_id)));
+      store.dispatch(deleteIssues(issuesOfIssueType.map((issue) => issue.offline_id)));
       const promise = this.client.enqueueRequest({
         method: HttpMethod.DELETE,
         url: `/issues/types/${issueTypeId}/`,
@@ -6488,7 +5954,7 @@ var __publicField = (obj, key, value) => {
         blockers: [],
         blocks: []
       });
-      store.dispatch(setIssueTypes(result));
+      store.dispatch(initializeIssueTypes(result));
     }
   }
   class MainService extends BaseApiService {
@@ -6622,12 +6088,12 @@ var __publicField = (obj, key, value) => {
       if (overwrite) {
         console.log("Overwriting data");
         store.dispatch(setProjects(projects));
-        store.dispatch(setWorkspaces(workspaces));
+        store.dispatch(initializeWorkspaces(Object.values(workspaces)));
         store.dispatch(resetRecentIssues());
       } else {
         console.log("Updating data (collisions will be replaced)");
         store.dispatch(addOrReplaceProjects(projects));
-        store.dispatch(addOrReplaceWorkspaces(workspaces));
+        store.dispatch(setWorkspaces(Object.values(workspaces)));
       }
       if (!currentProjectId) {
         store.dispatch(setIsFetchingInitialData(false));
@@ -6685,7 +6151,7 @@ var __publicField = (obj, key, value) => {
     // TODO: Re-add user to project if removal fails
     async remove(projectAccess) {
       const { store } = this.client;
-      store.dispatch(removeProjectAccess(projectAccess));
+      store.dispatch(deleteProjectAccess(projectAccess.offline_id));
       return this.client.enqueueRequest({
         description: "Delete project access",
         method: HttpMethod.DELETE,
@@ -6808,6 +6274,13 @@ var __publicField = (obj, key, value) => {
     constructor() {
       super(...arguments);
       __publicField(this, "attachmentModel", AttachmentModel.Project);
+      __publicField(this, "initializeAttachments", initializeProjectAttachments);
+      __publicField(this, "addAttachments", addProjectAttachments);
+      __publicField(this, "updateAttachments", updateProjectAttachments);
+      __publicField(this, "removeAttachments", deleteProjectAttachments);
+      __publicField(this, "removeAttachment", deleteProjectAttachment);
+      __publicField(this, "setAttachment", setProjectAttachment);
+      __publicField(this, "selectAttachment", selectProjectAttachment);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -6822,28 +6295,10 @@ var __publicField = (obj, key, value) => {
       });
     }
     async attachFilesToProject(files, projectId) {
-      return this.attachFiles(files, projectId, this.buildOfflineAttachment.bind(this), {
-        addAttachments: addProjectAttachments,
-        updateAttachments: updateProjectAttachments,
-        removeAttachments: removeProjectAttachments
-      });
-    }
-    deleteProjectAttachment(attachmentId) {
-      return this.deleteAttachment(
-        attachmentId,
-        {
-          setAttachment: setProjectAttachment,
-          removeAttachment: removeProjectAttachment
-        },
-        {
-          selectAttachment: selectProjectAttachment
-        }
-      );
+      return this.attachFiles(files, projectId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore() {
-      return this.getAttachments({
-        setAttachments: setProjectAttachments
-      });
+    async deleteProjectAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class ProjectService extends BaseApiService {
@@ -6921,9 +6376,9 @@ var __publicField = (obj, key, value) => {
       const filesToDelete = selectProjectFiles(state).filter((file) => file.project === projectId);
       store.dispatch(removeProjectFilesOfProject(project.id));
       const attachmentsOfProject = selectAttachmentsOfProject(project.id)(state);
-      store.dispatch(removeProjectAttachments(attachmentsOfProject.map(({ offline_id }) => offline_id)));
+      store.dispatch(deleteProjectAttachments(attachmentsOfProject.map(({ offline_id }) => offline_id)));
       const projectAccesses = selectProjectAccesses(state);
-      store.dispatch(removeProjectAccessesOfProject(project.id));
+      store.dispatch(deleteProjectAccesses(projectAccesses.map(({ offline_id }) => offline_id)));
       store.dispatch({ type: "rehydrated/setRehydrated", payload: false });
       store.dispatch(deleteProject(project));
       const license = selectLicenseForProject(project.id)(state);
@@ -7178,8 +6633,13 @@ var __publicField = (obj, key, value) => {
     }
     async favorite(formId2) {
       const { store } = this.client;
-      const activeProjectId = store.getState().projectReducer.activeProjectId;
-      store.dispatch(favoriteForm({ formId: formId2 }));
+      const state = store.getState();
+      const activeProjectId = state.projectReducer.activeProjectId;
+      const form = state.formReducer.instances[formId2];
+      if (!form) {
+        throw new Error(`Expected form to exist, got ${form}`);
+      }
+      store.dispatch(updateForm({ ...form, favorite: true }));
       try {
         await this.client.enqueueRequest({
           description: "Favorite form",
@@ -7189,14 +6649,19 @@ var __publicField = (obj, key, value) => {
           blocks: [`favorite-${formId2}`]
         });
       } catch (e) {
-        store.dispatch(unfavoriteForm({ formId: formId2 }));
+        store.dispatch(updateForm(form));
         throw e;
       }
     }
     async unfavorite(formId2) {
       const { store } = this.client;
-      const activeProjectId = store.getState().projectReducer.activeProjectId;
-      store.dispatch(unfavoriteForm({ formId: formId2 }));
+      const state = store.getState();
+      const activeProjectId = state.projectReducer.activeProjectId;
+      const form = state.formReducer.instances[formId2];
+      if (!form) {
+        throw new Error(`Expected form to exist, got ${form}`);
+      }
+      store.dispatch(updateForm({ ...form, favorite: false }));
       try {
         return await this.client.enqueueRequest({
           description: "Unfavorite form",
@@ -7206,7 +6671,7 @@ var __publicField = (obj, key, value) => {
           blocks: [`favorite-${formId2}`]
         });
       } catch (e) {
-        store.dispatch(favoriteForm({ formId: formId2 }));
+        store.dispatch(updateForm(form));
         throw e;
       }
     }
@@ -7307,7 +6772,7 @@ var __publicField = (obj, key, value) => {
       for (const attachment of issueTypeFormsResult.attachments)
         attachments.push(attachment);
       store.dispatch(setForms(forms));
-      store.dispatch(setFormRevisions(revisions));
+      store.dispatch(initializeFormRevisions(revisions));
       store.dispatch(setFormRevisionAttachments(attachments));
     }
   }
@@ -7534,7 +6999,10 @@ var __publicField = (obj, key, value) => {
         ...submission,
         values
       };
-      const submissionToBeUpdated = store.getState().formSubmissionReducer.formSubmissions[submission.offline_id];
+      const submissionToBeUpdated = selectFormSubmission(submission.offline_id)(store.getState());
+      if (!submissionToBeUpdated) {
+        throw new Error(`Expected submission with offline_id ${submission.offline_id} to exist`);
+      }
       store.dispatch(updateFormSubmission(offlineSubmission));
       const promise = this.client.enqueueRequest({
         description: "Patch form submission",
@@ -7556,7 +7024,10 @@ var __publicField = (obj, key, value) => {
     async delete(submissionId) {
       const { store } = this.client;
       const state = store.getState();
-      const submission = state.formSubmissionReducer.formSubmissions[submissionId];
+      const submissionToBeDeleted = selectFormSubmission(submissionId)(store.getState());
+      if (!submissionToBeDeleted) {
+        throw new Error(`Expected submission with offline_id ${submissionId} to exist`);
+      }
       const submissionAttachments = selectAttachmentsOfFormSubmission(submissionId)(state);
       store.dispatch(deleteFormSubmission(submissionId));
       store.dispatch(addActiveProjectFormSubmissionsCount(-1));
@@ -7571,7 +7042,7 @@ var __publicField = (obj, key, value) => {
         });
       } catch (e) {
         store.dispatch(addActiveProjectFormSubmissionsCount(1));
-        store.dispatch(addFormSubmission(submission));
+        store.dispatch(addFormSubmission(submissionToBeDeleted));
         store.dispatch(addFormSubmissionAttachments(submissionAttachments));
         throw e;
       }
@@ -7611,15 +7082,15 @@ var __publicField = (obj, key, value) => {
         blocks: [offlineWorkspace.offline_id]
       });
       void promise.then((result) => {
-        store.dispatch(addOrReplaceWorkspaces({ [offlineWorkspace.offline_id]: result }));
+        store.dispatch(updateWorkspace(result));
       }).catch(() => {
-        store.dispatch(removeWorkspace(offlineWorkspace.offline_id));
+        store.dispatch(deleteWorkspace(offlineWorkspace.offline_id));
       });
       return [offlineWorkspace, promise];
     }
     update(workspace) {
       const { store } = this.client;
-      store.dispatch(addOrReplaceWorkspaces({ [workspace.offline_id]: workspace }));
+      store.dispatch(addWorkspace(workspace));
       const promise = this.client.enqueueRequest({
         description: "Update Workspace",
         method: HttpMethod.PATCH,
@@ -7639,8 +7110,8 @@ var __publicField = (obj, key, value) => {
         blockers: [workspaceId],
         blocks: []
       });
-      const originalWorkspace = store.getState().workspaceReducer.workspaces[workspaceId];
-      store.dispatch(removeWorkspace(workspaceId));
+      const originalWorkspace = store.getState().workspaceReducer.instances[workspaceId];
+      store.dispatch(deleteWorkspace(workspaceId));
       void promise.then(() => {
         void this.client.main.fetchInitialData(true).then();
       }).catch((reason) => {
@@ -7668,7 +7139,7 @@ var __publicField = (obj, key, value) => {
       return promise;
     }
     async remove(organizationAccess) {
-      this.client.store.dispatch(removeOrganizationAccess(organizationAccess));
+      this.client.store.dispatch(deleteOrganizationAccess(organizationAccess.offline_id));
       this.client.store.dispatch(removeUser(organizationAccess.user));
       return this.client.enqueueRequest({
         description: "Remove organization access",
@@ -7692,7 +7163,7 @@ var __publicField = (obj, key, value) => {
         blockers: [],
         blocks: []
       });
-      store.dispatch(setOrganizationAccesses(result));
+      store.dispatch(initializeOrganizationAccesses(result));
     }
   }
   const cachedRequestPromises = {};
@@ -7927,15 +7398,6 @@ var __publicField = (obj, key, value) => {
     }
   }
   class EmailDomainsService extends BaseApiService {
-    async fetchAll(orgId) {
-      return this.client.enqueueRequest({
-        description: "Fetch email domains for organization",
-        method: HttpMethod.GET,
-        url: `/organizations/${orgId}/email-domains/`,
-        blockers: [orgId.toString()],
-        blocks: []
-      });
-    }
     async add(orgId, email) {
       return this.client.enqueueRequest({
         description: "Add email domain to organization",
@@ -7947,7 +7409,7 @@ var __publicField = (obj, key, value) => {
       });
     }
     async remove(emailDomain) {
-      this.client.store.dispatch(removeEmailDomain(emailDomain));
+      this.client.store.dispatch(deleteEmailDomain(emailDomain.offline_id));
       return this.client.enqueueRequest({
         description: "Remove email domain from organization",
         method: HttpMethod.DELETE,
@@ -7964,9 +7426,14 @@ var __publicField = (obj, key, value) => {
       if (!organizationId) {
         throw new Error("No active organization");
       }
-      const promise = this.fetchAll(organizationId);
-      const result = await promise;
-      this.client.store.dispatch(setEmailDomains(result));
+      const result = await this.client.enqueueRequest({
+        description: "Fetch email domains for organization",
+        method: HttpMethod.GET,
+        url: `/organizations/${organizationId}/email-domains/`,
+        blockers: [organizationId.toString()],
+        blocks: []
+      });
+      this.client.store.dispatch(initializeEmailDomains(result));
     }
   }
   class OrganizationService extends BaseApiService {
@@ -7995,8 +7462,8 @@ var __publicField = (obj, key, value) => {
       const users = data.users;
       store.dispatch(addUsers(users));
       store.dispatch(setActiveOrganizationId(activeOrganization.id));
-      store.dispatch(setOrganizationAccesses(organizationAccesses));
-      store.dispatch(setEmailDomains(emailDomains));
+      store.dispatch(initializeOrganizationAccesses(organizationAccesses));
+      store.dispatch(initializeEmailDomains(emailDomains));
       if (showLoading) {
         store.dispatch(setIsFetchingInitialData(false));
       }
@@ -8309,6 +7776,13 @@ var __publicField = (obj, key, value) => {
     constructor() {
       super(...arguments);
       __publicField(this, "attachmentModel", AttachmentModel.Document);
+      __publicField(this, "initializeAttachments", initializeDocumentAttachments);
+      __publicField(this, "addAttachments", addDocumentAttachments);
+      __publicField(this, "updateAttachments", updateDocumentAttachments);
+      __publicField(this, "removeAttachments", deleteDocumentAttachments);
+      __publicField(this, "removeAttachment", deleteDocumentAttachment);
+      __publicField(this, "setAttachment", setDocumentAttachment);
+      __publicField(this, "selectAttachment", selectDocumentAttachment);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -8323,28 +7797,10 @@ var __publicField = (obj, key, value) => {
       });
     }
     async attachFilesToDocument(files, documentId) {
-      return this.attachFiles(files, documentId, this.buildOfflineAttachment.bind(this), {
-        addAttachments: addDocumentAttachments,
-        updateAttachments: updateDocumentAttachments,
-        removeAttachments: removeDocumentAttachments
-      });
-    }
-    deleteDocumentAttachment(attachmentId) {
-      return this.deleteAttachment(
-        attachmentId,
-        {
-          setAttachment: setDocumentAttachment,
-          removeAttachment: removeDocumentAttachment
-        },
-        {
-          selectAttachment: selectDocumentAttachment
-        }
-      );
+      return this.attachFiles(files, documentId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore() {
-      return this.getAttachments({
-        setAttachments: setDocumentAttachments
-      });
+    async deleteDocumentAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class AgentService extends BaseApiService {
@@ -8385,7 +7841,7 @@ var __publicField = (obj, key, value) => {
         blocks: ["prompt"],
         queryParams: { conversation_id: conversationId }
       }).then((response) => {
-        const conversation = store.getState().agentsReducer.conversations[conversationId];
+        const conversation = store.getState().agentsReducer.instances[conversationId];
         if (!(conversation == null ? void 0 : conversation.offline_id)) {
           throw new Error("Conversation not found");
         }
@@ -8431,7 +7887,7 @@ var __publicField = (obj, key, value) => {
         blockers: ["agent-conversations"],
         blocks: ["agent-conversations"]
       });
-      store.dispatch(setConversations(result));
+      store.dispatch(initializeConversations(result));
     }
   }
   class TeamService extends BaseApiService {
@@ -8469,7 +7925,10 @@ 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 = store.getState().teamReducer.teams[team.offline_id];
+      const teamToBeUpdated = selectTeam(team.offline_id)(store.getState());
+      if (!teamToBeUpdated) {
+        throw new Error(`Expected team with offline_id ${team.offline_id} to exist`);
+      }
       const offlineUpdatedTeam = {
         ...teamToBeUpdated,
         ...team
@@ -8493,7 +7952,7 @@ var __publicField = (obj, key, value) => {
     async delete(teamId) {
       const { store } = this.client;
       const state = store.getState();
-      const team = state.teamReducer.teams[teamId];
+      const team = selectTeam(teamId)(state);
       if (!team) {
         throw new Error(`Expected team with id ${teamId} to exist`);
       }
@@ -8513,7 +7972,7 @@ var __publicField = (obj, key, value) => {
     }
     async setMembers(teamId, members) {
       const { store } = this.client;
-      const team = store.getState().teamReducer.teams[teamId];
+      const team = selectTeam(teamId)(store.getState());
       if (!team) {
         throw new Error(`Expected team with id ${teamId} to exist`);
       }
@@ -8538,7 +7997,7 @@ var __publicField = (obj, key, value) => {
     }
     async addMembers(teamId, members) {
       const { store } = this.client;
-      const team = store.getState().teamReducer.teams[teamId];
+      const team = selectTeam(teamId)(store.getState());
       if (!team) {
         throw new Error(`Expected team with id ${teamId} to exist`);
       }
@@ -8547,7 +8006,7 @@ var __publicField = (obj, key, value) => {
     }
     async removeMembers(teamId, members) {
       const { store } = this.client;
-      const team = store.getState().teamReducer.teams[teamId];
+      const team = selectTeam(teamId)(store.getState());
       if (!team) {
         throw new Error(`Expected team with id ${teamId} to exist`);
       }
@@ -16903,7 +16362,7 @@ var __publicField = (obj, key, value) => {
   exports2.addAssetType = addAssetType;
   exports2.addAssetTypeAttachment = addAssetTypeAttachment;
   exports2.addAssetTypeAttachments = addAssetTypeAttachments;
-  exports2.addAssetsInBatches = addAssetsInBatches;
+  exports2.addAssets = addAssets;
   exports2.addCategory = addCategory;
   exports2.addConversation = addConversation;
   exports2.addDocumentAttachment = addDocumentAttachment;
@@ -16931,12 +16390,9 @@ var __publicField = (obj, key, value) => {
   exports2.addIssueUpdates = addIssueUpdates;
   exports2.addIssues = addIssues;
   exports2.addLicenses = addLicenses;
-  exports2.addOrReplaceCategories = addOrReplaceCategories;
-  exports2.addOrReplaceIssueComment = addOrReplaceIssueComment;
   exports2.addOrReplaceProjectFile = addOrReplaceProjectFile;
   exports2.addOrReplaceProjectFiles = addOrReplaceProjectFiles;
   exports2.addOrReplaceProjects = addOrReplaceProjects;
-  exports2.addOrReplaceWorkspaces = addOrReplaceWorkspaces;
   exports2.addProjectAttachment = addProjectAttachment;
   exports2.addProjectAttachments = addProjectAttachments;
   exports2.addStageCompletion = addStageCompletion;
@@ -16949,12 +16405,16 @@ var __publicField = (obj, key, value) => {
   exports2.agentsReducer = agentsReducer;
   exports2.agentsSlice = agentsSlice;
   exports2.areArraysEqual = areArraysEqual;
+  exports2.assetAttachmentReducer = assetAttachmentReducer;
+  exports2.assetAttachmentSlice = assetAttachmentSlice;
   exports2.assetReducer = assetReducer;
   exports2.assetSlice = assetSlice;
   exports2.assetStageCompletionReducer = assetStageCompletionReducer;
   exports2.assetStageCompletionSlice = assetStageCompletionSlice;
   exports2.assetStageReducer = assetStageReducer;
   exports2.assetStageSlice = assetStageSlice;
+  exports2.assetTypeAttachmentReducer = assetTypeAttachmentReducer;
+  exports2.assetTypeAttachmentSlice = assetTypeAttachmentSlice;
   exports2.assetTypeReducer = assetTypeReducer;
   exports2.assetTypeSlice = assetTypeSlice;
   exports2.authReducer = authReducer;
@@ -16977,7 +16437,17 @@ var __publicField = (obj, key, value) => {
   exports2.decodeFormValues = decodeFormValues;
   exports2.defaultBadgeColor = defaultBadgeColor;
   exports2.defaultStore = defaultStore;
+  exports2.deleteAsset = deleteAsset;
+  exports2.deleteAssetAttachment = deleteAssetAttachment;
+  exports2.deleteAssetAttachments = deleteAssetAttachments;
   exports2.deleteAssetType = deleteAssetType;
+  exports2.deleteAssetTypeAttachment = deleteAssetTypeAttachment;
+  exports2.deleteAssetTypeAttachments = deleteAssetTypeAttachments;
+  exports2.deleteAssets = deleteAssets;
+  exports2.deleteCategory = deleteCategory;
+  exports2.deleteDocumentAttachment = deleteDocumentAttachment;
+  exports2.deleteDocumentAttachments = deleteDocumentAttachments;
+  exports2.deleteEmailDomain = deleteEmailDomain;
   exports2.deleteForm = deleteForm;
   exports2.deleteFormRevision = deleteFormRevision;
   exports2.deleteFormRevisionAttachment = deleteFormRevisionAttachment;
@@ -16987,12 +16457,28 @@ var __publicField = (obj, key, value) => {
   exports2.deleteFormSubmissionAttachment = deleteFormSubmissionAttachment;
   exports2.deleteFormSubmissionAttachments = deleteFormSubmissionAttachments;
   exports2.deleteFormSubmissions = deleteFormSubmissions;
+  exports2.deleteIssue = deleteIssue;
+  exports2.deleteIssueAttachment = deleteIssueAttachment;
+  exports2.deleteIssueAttachments = deleteIssueAttachments;
+  exports2.deleteIssueComment = deleteIssueComment;
+  exports2.deleteIssueComments = deleteIssueComments;
+  exports2.deleteIssueUpdate = deleteIssueUpdate;
+  exports2.deleteIssueUpdates = deleteIssueUpdates;
+  exports2.deleteIssues = deleteIssues;
+  exports2.deleteOrganizationAccess = deleteOrganizationAccess;
   exports2.deleteProject = deleteProject;
+  exports2.deleteProjectAccess = deleteProjectAccess;
+  exports2.deleteProjectAccesses = deleteProjectAccesses;
+  exports2.deleteProjectAttachment = deleteProjectAttachment;
+  exports2.deleteProjectAttachments = deleteProjectAttachments;
   exports2.deleteTeam = deleteTeam;
+  exports2.deleteWorkspace = deleteWorkspace;
   exports2.dequeue = dequeue;
   exports2.deserialize = deserialize;
   exports2.deserializeField = deserializeField;
   exports2.discard = discard;
+  exports2.documentAttachmentReducer = documentAttachmentReducer;
+  exports2.documentAttachmentSlice = documentAttachmentSlice;
   exports2.documentSlice = documentSlice;
   exports2.documentsReducer = documentsReducer;
   exports2.downloadFile = downloadFile;
@@ -17014,17 +16500,20 @@ var __publicField = (obj, key, value) => {
   exports2.enqueue = enqueue;
   exports2.enqueueRequest = enqueueRequest;
   exports2.errorColor = errorColor;
-  exports2.favoriteForm = favoriteForm;
   exports2.fileReducer = fileReducer;
   exports2.fileSlice = fileSlice;
   exports2.fileToBlob = fileToBlob;
   exports2.flattenFields = flattenFields;
   exports2.flipCoordinates = flipCoordinates;
   exports2.formReducer = formReducer;
+  exports2.formRevisionAttachmentReducer = formRevisionAttachmentReducer;
+  exports2.formRevisionAttachmentSlice = formRevisionAttachmentSlice;
   exports2.formRevisionReducer = formRevisionReducer;
   exports2.formRevisionToSchema = formRevisionToSchema;
   exports2.formRevisionsSlice = formRevisionsSlice;
   exports2.formSlice = formSlice;
+  exports2.formSubmissionAttachmentReducer = formSubmissionAttachmentReducer;
+  exports2.formSubmissionAttachmentSlice = formSubmissionAttachmentSlice;
   exports2.formSubmissionReducer = formSubmissionReducer;
   exports2.formSubmissionSlice = formSubmissionSlice;
   exports2.forms = index;
@@ -17043,16 +16532,40 @@ var __publicField = (obj, key, value) => {
   exports2.hideAllCategories = hideAllCategories;
   exports2.hideCategory = hideCategory;
   exports2.initialFormValues = initialFormValues;
+  exports2.initializeAssetAttachments = initializeAssetAttachments;
+  exports2.initializeAssetTypeAttachments = initializeAssetTypeAttachments;
+  exports2.initializeAssetTypes = initializeAssetTypes;
+  exports2.initializeAssets = initializeAssets;
+  exports2.initializeCategories = initializeCategories;
+  exports2.initializeConversations = initializeConversations;
+  exports2.initializeDocumentAttachments = initializeDocumentAttachments;
+  exports2.initializeEmailDomains = initializeEmailDomains;
+  exports2.initializeFormRevisionAttachments = initializeFormRevisionAttachments;
+  exports2.initializeFormRevisions = initializeFormRevisions;
+  exports2.initializeFormSubmissionAttachments = initializeFormSubmissionAttachments;
+  exports2.initializeIssueAttachments = initializeIssueAttachments;
+  exports2.initializeIssueTypes = initializeIssueTypes;
+  exports2.initializeIssueUpdates = initializeIssueUpdates;
+  exports2.initializeIssues = initializeIssues;
+  exports2.initializeOrganizationAccesses = initializeOrganizationAccesses;
+  exports2.initializeProjectAttachments = initializeProjectAttachments;
+  exports2.initializeStages = initializeStages;
+  exports2.initializeWorkspaces = initializeWorkspaces;
   exports2.isConditionMet = isConditionMet;
   exports2.isToday = isToday;
+  exports2.issueAttachmentReducer = issueAttachmentReducer;
+  exports2.issueAttachmentSlice = issueAttachmentSlice;
+  exports2.issueCommentReducer = issueCommentReducer;
+  exports2.issueCommentSlice = issueCommentSlice;
   exports2.issueReducer = issueReducer;
   exports2.issueSlice = issueSlice;
   exports2.issueToSearchResult = issueToSearchResult;
   exports2.issueTypeReducer = issueTypeReducer;
   exports2.issueTypeSlice = issueTypeSlice;
+  exports2.issueUpdateReducer = issueUpdateReducer;
+  exports2.issueUpdateSlice = issueUpdateSlice;
   exports2.licenseReducer = licenseReducer;
   exports2.licenseSlice = licenseSlice;
-  exports2.linkStageToForm = linkStageToForm;
   exports2.literalToCoordinates = literalToCoordinates;
   exports2.logOnlyOnce = logOnlyOnce;
   exports2.makeClient = makeClient;
@@ -17079,54 +16592,27 @@ var __publicField = (obj, key, value) => {
   exports2.overmapEnhancer = overmapEnhancer;
   exports2.overmapReducer = overmapReducer;
   exports2.overmapReducers = overmapReducers;
-  exports2.patchCategory = patchCategory;
   exports2.performRequest = performRequest;
   exports2.primaryColor = primaryColor;
   exports2.projectAccessReducer = projectAccessReducer;
   exports2.projectAccessSlice = projectAccessSlice;
+  exports2.projectAttachmentReducer = projectAttachmentReducer;
+  exports2.projectAttachmentSlice = projectAttachmentSlice;
   exports2.projectFileReducer = projectFileReducer;
   exports2.projectFileSlice = projectFileSlice;
   exports2.projectReducer = projectReducer;
   exports2.projectSlice = projectSlice;
   exports2.rehydratedReducer = rehydratedReducer;
   exports2.rehydratedSlice = rehydratedSlice;
-  exports2.removeAllAssetsOfType = removeAllAssetsOfType;
-  exports2.removeAsset = removeAsset;
-  exports2.removeAssetAttachment = removeAssetAttachment;
-  exports2.removeAssetAttachments = removeAssetAttachments;
-  exports2.removeAssetTypeAttachment = removeAssetTypeAttachment;
-  exports2.removeAssetTypeAttachments = removeAssetTypeAttachments;
-  exports2.removeAssets = removeAssets;
-  exports2.removeAttachmentsOfIssue = removeAttachmentsOfIssue;
-  exports2.removeCategory = removeCategory;
-  exports2.removeColor = removeColor;
-  exports2.removeDocumentAttachment = removeDocumentAttachment;
-  exports2.removeDocumentAttachments = removeDocumentAttachments;
   exports2.removeDocuments = removeDocuments;
-  exports2.removeEmailDomain = removeEmailDomain;
   exports2.removeFavouriteProjectId = removeFavouriteProjectId;
-  exports2.removeIssue = removeIssue;
-  exports2.removeIssueAttachment = removeIssueAttachment;
-  exports2.removeIssueAttachments = removeIssueAttachments;
-  exports2.removeIssueComment = removeIssueComment;
-  exports2.removeIssueComments = removeIssueComments;
   exports2.removeIssueType = removeIssueType;
-  exports2.removeIssueUpdate = removeIssueUpdate;
-  exports2.removeIssueUpdates = removeIssueUpdates;
-  exports2.removeIssues = removeIssues;
-  exports2.removeOrganizationAccess = removeOrganizationAccess;
-  exports2.removeProjectAccess = removeProjectAccess;
-  exports2.removeProjectAccessesOfProject = removeProjectAccessesOfProject;
-  exports2.removeProjectAttachment = removeProjectAttachment;
-  exports2.removeProjectAttachments = removeProjectAttachments;
   exports2.removeProjectFile = removeProjectFile;
   exports2.removeProjectFilesOfProject = removeProjectFilesOfProject;
   exports2.removeRecentIssue = removeRecentIssue;
   exports2.removeStageCompletions = removeStageCompletions;
   exports2.removeStages = removeStages;
   exports2.removeUser = removeUser;
-  exports2.removeWorkspace = removeWorkspace;
-  exports2.replaceCategory = replaceCategory;
   exports2.resetProjectFileObjectUrls = resetProjectFileObjectUrls;
   exports2.resetRecentIssues = resetRecentIssues;
   exports2.resetStore = resetStore;
@@ -17135,7 +16621,6 @@ var __publicField = (obj, key, value) => {
   exports2.saveActiveProjectFileBounds = saveActiveProjectFileBounds;
   exports2.searchIssues = searchIssues;
   exports2.selectAccessToken = selectAccessToken;
-  exports2.selectActiveIssueId = selectActiveIssueId;
   exports2.selectActiveLicense = selectActiveLicense;
   exports2.selectActiveOrganization = selectActiveOrganization;
   exports2.selectActiveOrganizationAccess = selectActiveOrganizationAccess;
@@ -17149,7 +16634,6 @@ var __publicField = (obj, key, value) => {
   exports2.selectActiveStatusLicenses = selectActiveStatusLicenses;
   exports2.selectActiveWorkspace = selectActiveWorkspace;
   exports2.selectActiveWorkspaceId = selectActiveWorkspaceId;
-  exports2.selectAllAttachments = selectAllAttachments;
   exports2.selectAllDocumentAttachments = selectAllDocumentAttachments;
   exports2.selectAllProjectAttachments = selectAllProjectAttachments;
   exports2.selectAncestorIdsOfDocument = selectAncestorIdsOfDocument;
@@ -17185,11 +16669,10 @@ var __publicField = (obj, key, value) => {
   exports2.selectAttachmentsOfProjectByType = selectAttachmentsOfProjectByType;
   exports2.selectCategories = selectCategories;
   exports2.selectCategoriesOfWorkspace = selectCategoriesOfWorkspace;
-  exports2.selectCategory = selectCategory;
+  exports2.selectCategoryById = selectCategoryById;
   exports2.selectCategoryMapping = selectCategoryMapping;
   exports2.selectCategoryVisibility = selectCategoryVisibility;
   exports2.selectCenterMapToProject = selectCenterMapToProject;
-  exports2.selectCommentMapping = selectCommentMapping;
   exports2.selectCommentsOfIssue = selectCommentsOfIssue;
   exports2.selectCompletedStageIdsForAsset = selectCompletedStageIdsForAsset;
   exports2.selectCompletedStages = selectCompletedStages;
@@ -17203,7 +16686,9 @@ var __publicField = (obj, key, value) => {
   exports2.selectDocumentAttachmentMapping = selectDocumentAttachmentMapping;
   exports2.selectDocuments = selectDocuments;
   exports2.selectDocumentsMapping = selectDocumentsMapping;
+  exports2.selectEmailDomains = selectEmailDomains;
   exports2.selectEmailDomainsAsMapping = selectEmailDomainsAsMapping;
+  exports2.selectEmailDomainsOfOrganization = selectEmailDomainsOfOrganization;
   exports2.selectEnableClustering = selectEnableClustering;
   exports2.selectEnableDuplicateIssues = selectEnableDuplicateIssues;
   exports2.selectEnablePlacementMode = selectEnablePlacementMode;
@@ -17212,7 +16697,6 @@ var __publicField = (obj, key, value) => {
   exports2.selectEnabledProjectFiles = selectEnabledProjectFiles;
   exports2.selectExpandedSections = selectExpandedSections;
   exports2.selectFavouriteProjects = selectFavouriteProjects;
-  exports2.selectFileAttachmentsOfIssue = selectFileAttachmentsOfIssue;
   exports2.selectFilteredForms = selectFilteredForms;
   exports2.selectForm = selectForm;
   exports2.selectFormMapping = selectFormMapping;
@@ -17244,6 +16728,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectIssueAttachment = selectIssueAttachment;
   exports2.selectIssueAttachmentMapping = selectIssueAttachmentMapping;
   exports2.selectIssueAttachments = selectIssueAttachments;
+  exports2.selectIssueCommentMapping = selectIssueCommentMapping;
   exports2.selectIssueCountOfCategory = selectIssueCountOfCategory;
   exports2.selectIssueMapping = selectIssueMapping;
   exports2.selectIssueType = selectIssueType;
@@ -17278,9 +16763,9 @@ var __publicField = (obj, key, value) => {
   exports2.selectOrganizationsMapping = selectOrganizationsMapping;
   exports2.selectOrganizationsWithAccess = selectOrganizationsWithAccess;
   exports2.selectPermittedWorkspaceIds = selectPermittedWorkspaceIds;
-  exports2.selectPhotoAttachmentsOfIssue = selectPhotoAttachmentsOfIssue;
   exports2.selectProjectAccess = selectProjectAccess;
   exports2.selectProjectAccessForUser = selectProjectAccessForUser;
+  exports2.selectProjectAccessMapping = selectProjectAccessMapping;
   exports2.selectProjectAccessUserMapping = selectProjectAccessUserMapping;
   exports2.selectProjectAccesses = selectProjectAccesses;
   exports2.selectProjectAttachment = selectProjectAttachment;
@@ -17297,7 +16782,6 @@ var __publicField = (obj, key, value) => {
   exports2.selectRehydrated = selectRehydrated;
   exports2.selectRootDocuments = selectRootDocuments;
   exports2.selectShowTooltips = selectShowTooltips;
-  exports2.selectSortedEmailDomains = selectSortedEmailDomains;
   exports2.selectSortedFormSubmissionsOfForm = selectSortedFormSubmissionsOfForm;
   exports2.selectSortedOrganizationLicenses = selectSortedOrganizationLicenses;
   exports2.selectSortedOrganizationUsers = selectSortedOrganizationUsers;
@@ -17316,7 +16800,6 @@ var __publicField = (obj, key, value) => {
   exports2.selectTeamsOfOrganization = selectTeamsOfOrganization;
   exports2.selectTeamsOfUser = selectTeamsOfUser;
   exports2.selectUploadUrl = selectUploadUrl;
-  exports2.selectUsedColors = selectUsedColors;
   exports2.selectUser = selectUser;
   exports2.selectUserFormRevisionAttachmentsMapping = selectUserFormRevisionAttachmentsMapping;
   exports2.selectUsersAsMapping = selectUsersAsMapping;
@@ -17325,34 +16808,32 @@ var __publicField = (obj, key, value) => {
   exports2.selectWorkspace = selectWorkspace;
   exports2.selectWorkspaceMapping = selectWorkspaceMapping;
   exports2.selectWorkspaces = selectWorkspaces;
-  exports2.setActiveIssueId = setActiveIssueId;
   exports2.setActiveOrganizationId = setActiveOrganizationId;
   exports2.setActiveProjectFileId = setActiveProjectFileId;
   exports2.setActiveProjectId = setActiveProjectId;
   exports2.setActiveWorkspaceId = setActiveWorkspaceId;
   exports2.setAppearance = setAppearance;
+  exports2.setAsset = setAsset;
   exports2.setAssetAttachment = setAssetAttachment;
   exports2.setAssetAttachments = setAssetAttachments;
   exports2.setAssetTypeAttachment = setAssetTypeAttachment;
   exports2.setAssetTypeAttachments = setAssetTypeAttachments;
-  exports2.setAssetTypes = setAssetTypes;
   exports2.setAssets = setAssets;
-  exports2.setCategories = setCategories;
   exports2.setCenterMapToProject = setCenterMapToProject;
   exports2.setConversation = setConversation;
-  exports2.setConversations = setConversations;
   exports2.setCurrentUser = setCurrentUser;
   exports2.setDocumentAttachment = setDocumentAttachment;
   exports2.setDocumentAttachments = setDocumentAttachments;
   exports2.setDocuments = setDocuments;
-  exports2.setEmailDomains = setEmailDomains;
   exports2.setEnableClustering = setEnableClustering;
   exports2.setEnableDuplicateIssues = setEnableDuplicateIssues;
   exports2.setEnablePlacementMode = setEnablePlacementMode;
+  exports2.setForm = setForm;
   exports2.setFormRevision = setFormRevision;
+  exports2.setFormRevisionAttachment = setFormRevisionAttachment;
   exports2.setFormRevisionAttachments = setFormRevisionAttachments;
-  exports2.setFormRevisions = setFormRevisions;
   exports2.setFormSubmission = setFormSubmission;
+  exports2.setFormSubmissionAttachment = setFormSubmissionAttachment;
   exports2.setFormSubmissionAttachments = setFormSubmissionAttachments;
   exports2.setFormSubmissions = setFormSubmissions;
   exports2.setForms = setForms;
@@ -17364,13 +16845,10 @@ var __publicField = (obj, key, value) => {
   exports2.setIssueComment = setIssueComment;
   exports2.setIssueComments = setIssueComments;
   exports2.setIssueType = setIssueType;
-  exports2.setIssueTypes = setIssueTypes;
-  exports2.setIssueUpdates = setIssueUpdates;
-  exports2.setIssues = setIssues;
+  exports2.setIssueUpdate = setIssueUpdate;
   exports2.setLicenses = setLicenses;
   exports2.setLoggedIn = setLoggedIn;
   exports2.setMapStyle = setMapStyle;
-  exports2.setOrganizationAccesses = setOrganizationAccesses;
   exports2.setOrganizations = setOrganizations;
   exports2.setProfilePicture = setProfilePicture;
   exports2.setProjectAccesses = setProjectAccesses;
@@ -17380,6 +16858,7 @@ var __publicField = (obj, key, value) => {
   exports2.setProjects = setProjects;
   exports2.setSectionExpanded = setSectionExpanded;
   exports2.setShowTooltips = setShowTooltips;
+  exports2.setStage = setStage;
   exports2.setStageCompletions = setStageCompletions;
   exports2.setTeam = setTeam;
   exports2.setTeams = setTeams;
@@ -17402,10 +16881,8 @@ var __publicField = (obj, key, value) => {
   exports2.toOfflineIdRecord = toOfflineIdRecord;
   exports2.toggleAssetTypeVisibility = toggleAssetTypeVisibility;
   exports2.truncate = truncate;
-  exports2.unfavoriteForm = unfavoriteForm;
   exports2.unhideAllCategories = unhideAllCategories;
   exports2.unhideCategory = unhideCategory;
-  exports2.unlinkStageToForm = unlinkStageToForm;
   exports2.updateActiveOrganization = updateActiveOrganization;
   exports2.updateAsset = updateAsset;
   exports2.updateAssetAttachment = updateAssetAttachment;
@@ -17413,11 +16890,16 @@ var __publicField = (obj, key, value) => {
   exports2.updateAssetTypeAttachment = updateAssetTypeAttachment;
   exports2.updateAssetTypeAttachments = updateAssetTypeAttachments;
   exports2.updateAssets = updateAssets;
+  exports2.updateCategory = updateCategory;
   exports2.updateConversation = updateConversation;
   exports2.updateDocumentAttachment = updateDocumentAttachment;
   exports2.updateDocumentAttachments = updateDocumentAttachments;
   exports2.updateDocuments = updateDocuments;
+  exports2.updateForm = updateForm;
+  exports2.updateFormRevisionAttachment = updateFormRevisionAttachment;
+  exports2.updateFormRevisionAttachments = updateFormRevisionAttachments;
   exports2.updateFormSubmission = updateFormSubmission;
+  exports2.updateFormSubmissionAttachment = updateFormSubmissionAttachment;
   exports2.updateFormSubmissionAttachments = updateFormSubmissionAttachments;
   exports2.updateFormSubmissions = updateFormSubmissions;
   exports2.updateIssue = updateIssue;
@@ -17430,8 +16912,10 @@ var __publicField = (obj, key, value) => {
   exports2.updateProjectAccess = updateProjectAccess;
   exports2.updateProjectAttachment = updateProjectAttachment;
   exports2.updateProjectAttachments = updateProjectAttachments;
+  exports2.updateStage = updateStage;
   exports2.updateStages = updateStages;
   exports2.updateTeam = updateTeam;
+  exports2.updateWorkspace = updateWorkspace;
   exports2.useAppDispatch = useAppDispatch;
   exports2.useAppSelector = useAppSelector;
   exports2.useFieldInput = useFieldInput;