@overmap-ai/core 1.0.58-sign-up-hotfix.5 → 1.0.60-model-adapter.0

package/dist/overmap-core.js

@@ -744,15 +744,15 @@ const wrapMigration = (migrator) => (state) => {
 };
 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 = 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;
@@ -1396,77 +1396,92 @@ const getLocalRelativeDateString = memoize((date, min, max) => {
     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 = 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;
@@ -1477,7 +1492,7 @@ const categorySlice = createSlice({
       }
     },
     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
@@ -1494,26 +1509,20 @@ const categorySlice = createSlice({
     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 = createSelector(
   [selectCategoryMapping, _selectActiveWorkspaceId],
@@ -1525,12 +1534,12 @@ const selectCategoriesOfWorkspace = restructureCreateSelectorWithArgs(
     (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(
+  createSelector(
+    [selectCategoryMapping, (_state, categoryId) => categoryId],
+    (mapping, categoryId) => mapping[categoryId]
+  )
+);
 const selectCategoryVisibility = (state) => state.categoryReducer.categoryVisibility;
 const selectHiddenCategoryCount = (state) => {
   const { hiddenCategoryIds, isNullCategoryHidden } = state.categoryReducer.categoryVisibility;
@@ -1540,106 +1549,28 @@ const selectHiddenCategoryCount = (state) => {
   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 = 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 = createSelector(
   [selectAssetTypesMapping],
   (mapping) => Object.values(mapping)
@@ -1675,151 +1606,78 @@ const selectAssetTypesByName = restructureCreateSelectorWithArgs(
   })
 );
 const selectHiddenAssetTypeIds = (state) => state.assetTypeReducer.hiddenAssetTypeIds;
-const selectAssetTypeAttachmentMapping = (state) => state.assetTypeReducer.attachments;
-const selectAssetTypeAttachments = createSelector(
-  [selectAssetTypeAttachmentMapping],
-  (mapping) => Object.values(mapping)
-);
-const selectAssetTypeAttachment = (attachmentId) => (state) => {
-  return state.assetTypeReducer.attachments[attachmentId];
-};
-const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
-    (attachments, assetTypeId) => {
-      return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
-    }
-  )
-);
-const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
-  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 = 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(
   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 = createSelector(
   [selectAssets, selectAssetTypesMapping],
@@ -1848,20 +1706,50 @@ const selectNumberOfAssetsOfAssetType = (assetTypeId) => (state) => {
 };
 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 = 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 = createSelector(
   [selectAssetAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
 const selectAssetAttachment = (attachmentId) => (state) => {
-  return state.assetReducer.attachments[attachmentId];
+  return state.assetAttachmentReducer.instances[attachmentId];
 };
 const selectAttachmentsOfAsset = restructureCreateSelectorWithArgs(
   createSelector(
@@ -1888,14 +1776,14 @@ const selectAttachmentsOfAssetByType = restructureCreateSelectorWithArgs(
     }
   )
 );
-const assetReducer = assetSlice.reducer;
-const initialState$o = {
+const assetAttachmentReducer = assetAttachmentSlice.reducer;
+const initialState$w = {
   completionsByAssetId: {}
 };
 const assetStageCompletionSlice = 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];
@@ -1944,46 +1832,22 @@ const selectCompletedStageIdsForAsset = (asset) => (state) => {
   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 = 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(
   createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
     return stageMapping[stageId];
@@ -2046,43 +1910,100 @@ const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
     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 = 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 = createSelector(
+  [selectAssetTypeAttachmentMapping],
+  (mapping) => Object.values(mapping)
+);
+const selectAssetTypeAttachment = (attachmentId) => (state) => {
+  return state.assetTypeAttachmentReducer.instances[attachmentId];
 };
+const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+    (attachments, assetTypeId) => {
+      return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
+    }
+  )
+);
+const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
+  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 = 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 = createSelector([selectWorkspaceMapping], (mapping) => Object.values(mapping));
 const selectMainWorkspace = createSelector([selectWorkspaces], (workspaces) => {
   return workspaces.find((workspace) => workspace.name.toLowerCase() === "main");
@@ -2111,169 +2032,33 @@ const selectPermittedWorkspaceIds = createSelector(
 );
 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 = 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;
-    },
-    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;
-    },
-    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;
+    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;
     },
     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]);
+      state.recentIssueIds = state.recentIssueIds.filter((recentIssue) => state.instances[recentIssue.offlineId]);
     },
     addToRecentIssues: (state, action) => {
       state.recentIssueIds = state.recentIssueIds.filter(
@@ -2294,57 +2079,24 @@ const issueSlice = createSlice({
       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;
@@ -2391,83 +2143,11 @@ const selectIssues = restructureCreateSelectorWithArgs(
     }
   )
 );
-const selectActiveIssueId = (state) => state.issueReducer.activeIssueId;
-const selectIssueAttachmentMapping = (state) => state.issueReducer.attachments;
-const selectIssueAttachments = createSelector(
-  [selectIssueAttachmentMapping],
-  (mapping) => Object.values(mapping)
-);
-const selectPhotoAttachmentsOfIssue = restructureCreateSelectorWithArgs(
-  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(
-  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(
-  createSelector([selectIssueUpdateMapping, (_state, issueId) => issueId], (updates, issueId) => {
-    return Object.values(updates).filter((update) => update.issue === issueId);
-  })
-);
-const selectAttachmentsOfIssue = restructureCreateSelectorWithArgs(
-  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(
-  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(
-  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(
   createSelector([selectIssueMapping, (_state, id) => id], (mapping, id) => {
     return mapping[id];
   })
 );
-const selectAllAttachments = createSelector([selectIssueAttachmentMapping], (mapping) => Object.values(mapping));
 const searchIssues = restructureCreateSelectorWithArgs(
   createSelector(
     [selectIssueMapping, selectWorkspaceMapping, (_state, searchArgs) => searchArgs],
@@ -2558,47 +2238,25 @@ const selectRecentIssuesAsSearchResults = createSelector(
   }
 );
 const issueReducer = issueSlice.reducer;
-const initialState$k = {
-  issueTypes: {}
-};
+const issueTypeAdapter = createModelAdapter((issueType) => issueType.offline_id);
+const initialState$r = issueTypeAdapter.getInitialState({});
 const issueTypeSlice = 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 = createSelector(selectIssueTypeMapping, (issueTypes) => {
   return Object.values(issueTypes);
@@ -2621,7 +2279,7 @@ const selectIssueTypesOfOrganization = restructureCreateSelectorWithArgs(
 );
 const selectIssuesOfIssueType = restructureCreateSelectorWithArgs(
   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);
     }
@@ -2632,15 +2290,15 @@ const selectIssuesOfIssueTypeCount = (issueTypeId) => (state) => {
   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 = 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;
@@ -2667,7 +2325,7 @@ const selectUploadUrl = (sha1) => (state) => {
   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,
@@ -2675,8 +2333,8 @@ const initialState$i = {
 };
 const mapSlice = 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;
@@ -2748,7 +2406,7 @@ var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
   LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
   return LicenseStatus2;
 })(LicenseStatus || {});
-const initialState$h = {
+const initialState$o = {
   users: {},
   currentUser: {
     id: 0,
@@ -2759,8 +2417,8 @@ const initialState$h = {
 };
 const userSlice = 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 = {};
@@ -2822,52 +2480,26 @@ const selectUser = (userId) => (state) => {
 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 = 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 = createSelector(
   [selectCurrentUser, selectOrganizationAccesses],
@@ -2879,60 +2511,39 @@ const selectActiveOrganizationAccess = createSelector(
   }
 );
 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 = 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 = createSelector(
   [selectLicenses],
   (licenses) => Object.values(licenses).filter((license) => license.is_active)
@@ -2942,90 +2553,58 @@ const selectLicensesForProjectsMapping = createSelector(
   (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 = 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 = createSlice({
   name: "projects",
-  initialState: initialState$d,
+  initialState: initialState$k,
   reducers: {
     setProjects: (state, action) => {
       const projectsMap = {};
@@ -3089,16 +2668,7 @@ const projectSlice = createSlice({
       } 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 {
@@ -3109,16 +2679,7 @@ const {
   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;
@@ -3149,7 +2710,7 @@ const selectSortedProjects = createSelector(
 );
 const projectReducer = projectSlice.reducer;
 const selectProjectUsersIds = createSelector(
-  [selectProjectAccesses],
+  [selectProjectAccessMapping],
   (projectAccesses) => Object.values(projectAccesses).map((projectAccess) => projectAccess.user)
 );
 const selectProjectUsersAsMapping = createSelector(
@@ -3181,47 +2742,14 @@ const selectSortedProjectUsers = createSelector(
     });
   }
 );
-const selectProjectAttachmentMapping = (state) => state.projectReducer.attachments;
-const selectAllProjectAttachments = createSelector(
-  [selectProjectAttachmentMapping],
-  (mapping) => Object.values(mapping)
-);
-const selectProjectAttachment = (attachmentId) => (state) => {
-  return state.projectReducer.attachments[attachmentId];
-};
-const selectAttachmentsOfProject = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAllProjectAttachments, (_state, projectId) => projectId],
-    (attachments, projectId) => {
-      return attachments.filter(({ project }) => projectId === project);
-    }
-  )
-);
-const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
-  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 = 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) {
@@ -3340,14 +2868,14 @@ const createOfflineAction = (request2, baseUrl) => {
     }
   };
 };
-const initialState$b = {
+const initialState$i = {
   deletedRequests: [],
   latestRetryTime: 0
 };
 const outboxSlice = 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
@@ -3379,7 +2907,7 @@ const selectDeletedRequests = (state) => state.outboxReducer.deletedRequests;
 const selectLatestRetryTime = (state) => state.outboxReducer.latestRetryTime;
 const { enqueueRequest, markForDeletion, markAsDeleted, _setLatestRetryTime } = outboxSlice.actions;
 const outboxReducer = outboxSlice.reducer;
-const initialState$a = {
+const initialState$h = {
   projectFiles: {},
   activeProjectFileId: null,
   isImportingProjectFile: false,
@@ -3387,8 +2915,8 @@ const initialState$a = {
 };
 const projectFileSlice = 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) {
@@ -3489,12 +3017,75 @@ const selectProjectFiles = createSelector(
 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 = 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 = createSelector(
+  [selectProjectAttachmentMapping],
+  (mapping) => Object.values(mapping)
+);
+const selectProjectAttachment = (attachmentId) => (state) => {
+  return state.projectAttachmentReducer.instances[attachmentId];
+};
+const selectAttachmentsOfProject = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectAllProjectAttachments, (_state, projectId) => projectId],
+    (attachments, projectId) => {
+      return attachments.filter(({ project }) => projectId === project);
+    }
+  )
+);
+const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
+  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 = createSlice({
   name: "rehydrated",
-  initialState: initialState$9,
+  initialState: initialState$f,
   // The `reducers` field lets us define reducers and generate associated actions
   reducers: {
     setRehydrated: (state, action) => {
@@ -3504,7 +3095,7 @@ const rehydratedSlice = createSlice({
 });
 const selectRehydrated = (state) => state.rehydratedReducer.isRehydrated;
 const rehydratedReducer = rehydratedSlice.reducer;
-const initialState$8 = {
+const initialState$e = {
   useIssueTemplate: false,
   placementMode: false,
   enableClustering: false,
@@ -3522,8 +3113,8 @@ const initialState$8 = {
 };
 const settingSlice = 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;
@@ -3582,119 +3173,36 @@ const formRevisionSortFn = (formRevisionA, formRevisionB) => {
     return revisionA < revisionB ? -1 : 1;
   }
 };
-const initialState$7 = {
-  formRevisions: {},
-  attachments: {}
-};
+const formRevisionAdapter = createModelAdapter((revision) => revision.offline_id);
+const initialState$d = formRevisionAdapter.getInitialState({});
 const formRevisionsSlice = 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 = 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;
@@ -3723,7 +3231,7 @@ const selectFormRevisionsOfForm = restructureCreateSelectorWithArgs(
 const selectLatestFormRevisionsOfAssetTypes = restructureCreateSelectorWithArgs(
   createSelector(
     [
-      (state) => state.formReducer.forms,
+      (state) => state.formReducer.instances,
       selectFormRevisionMapping,
       (_state, assetTypeIds) => assetTypeIds
     ],
@@ -3757,67 +3265,28 @@ const selectLatestFormRevisionByForm = createSelector([selectFormRevisionMapping
   }
   return latestRevisions;
 });
-const selectUserFormRevisionAttachmentsMapping = (state) => {
-  return state.formRevisionReducer.attachments;
-};
-const selectAttachmentsOfFormRevision = restructureCreateSelectorWithArgs(
-  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 = 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(
   createSelector(
     [
-      (state) => state.formReducer.forms,
-      (state) => state.formRevisionReducer.formRevisions,
+      (state) => state.formReducer.instances,
+      (state) => state.formRevisionReducer.instances,
       (_state, search) => search
     ],
     (userForms, revisions, search) => {
@@ -3850,10 +3319,10 @@ const selectFilteredForms = restructureCreateSelectorWithArgs(
   )
 );
 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(
   createSelector(
@@ -3878,123 +3347,21 @@ const selectGeneralFormCount = createSelector([selectFormMapping], (userForms) =
   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 = 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 {
@@ -4005,16 +3372,10 @@ const {
   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 = createSelector(
   [selectFormSubmissionsMapping],
@@ -4023,7 +3384,7 @@ const selectFormSubmissions = createSelector(
   }
 );
 const selectFormSubmission = (submissionId) => (state) => {
-  return state.formSubmissionReducer.formSubmissions[submissionId];
+  return state.formSubmissionReducer.instances[submissionId];
 };
 const selectFormSubmissionsOfForm = restructureCreateSelectorWithArgs(
   createSelector(
@@ -4128,8 +3489,40 @@ const selectFormSubmissionsByAssets = createSelector(
     return assetSubmissionMapping;
   }
 );
+const formSubmissionReducer = formSubmissionSlice.reducer;
+const formSubmissionAttachmentAdapter = createModelAdapter(
+  (attachment) => attachment.offline_id
+);
+const initialState$a = formSubmissionAttachmentAdapter.getInitialState({});
+const formSubmissionAttachmentSlice = 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(
   createSelector(
@@ -4139,48 +3532,81 @@ const selectAttachmentsOfFormSubmission = restructureCreateSelectorWithArgs(
     }
   )
 );
-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 = 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(
+  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 = 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(
+  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 = 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) => {
@@ -4320,34 +3746,10 @@ const documentSlice = createSlice({
         }
         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 = createSelector(
   [selectDocumentsMapping],
@@ -4377,13 +3779,43 @@ const selectRootDocuments = createSelector(
   [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 = 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 = createSelector(
   [selectDocumentAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
 const selectDocumentAttachment = (attachmentId) => (state) => {
-  return state.documentsReducer.attachments[attachmentId];
+  return state.documentAttachmentReducer.instances[attachmentId];
 };
 const selectAttachmentsOfDocument = restructureCreateSelectorWithArgs(
   createSelector(
@@ -4410,48 +3842,28 @@ const selectAttachmentsOfDocumentByType = restructureCreateSelectorWithArgs(
     }
   )
 );
-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 = 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 = createSelector([selectTeamsMapping], (teams) => {
   return Object.values(teams);
 });
 const selectTeam = (teamId) => (state) => {
-  return state.teamReducer.teams[teamId];
+  return state.teamReducer.instances[teamId];
 };
 const selectTeamsOfOrganization = restructureCreateSelectorWithArgs(
   createSelector(
@@ -4467,43 +3879,23 @@ const selectTeamsOfUser = restructureCreateSelectorWithArgs(
   })
 );
 const teamReducer = teamSlice.reducer;
-const initialState$1 = {
-  conversations: {}
-};
+const agentUserConversationAdapter = createModelAdapter(
+  (conversation) => conversation.offline_id
+);
+const initialState$4 = agentUserConversationAdapter.getInitialState({});
 const agentsSlice = 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 = createSelector(
   [selectConversationMapping],
   (conversationMapping) => Object.values(conversationMapping)
@@ -4515,6 +3907,132 @@ const selectConversation = restructureCreateSelectorWithArgs(
   )
 );
 const agentsReducer = agentsSlice.reducer;
+const issueCommentAdapter = createModelAdapter((comment) => comment.offline_id);
+const initialState$3 = issueCommentAdapter.getInitialState({});
+const issueCommentSlice = 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(
+  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 = 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(
+  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 = 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 = createSelector(
+  [selectIssueAttachmentMapping],
+  (mapping) => Object.values(mapping)
+);
+const selectAttachmentsOfIssue = restructureCreateSelectorWithArgs(
+  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(
+  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
 };
@@ -4543,15 +4061,19 @@ const overmapReducers = {
   authReducer,
   categoryReducer,
   assetReducer,
+  assetAttachmentReducer,
   assetStageCompletionReducer,
   assetStageReducer,
   assetTypeReducer,
+  assetTypeAttachmentReducer,
   issueReducer,
+  issueAttachmentReducer,
   issueTypeReducer,
   mapReducer,
   organizationReducer,
   outboxReducer,
   projectReducer,
+  projectAttachmentReducer,
   projectAccessReducer,
   organizationAccessReducer,
   projectFileReducer,
@@ -4559,20 +4081,25 @@ const overmapReducers = {
   settingReducer,
   formReducer,
   formRevisionReducer,
+  formRevisionAttachmentReducer,
+  formSubmissionAttachmentReducer,
   formSubmissionReducer,
   userReducer,
   workspaceReducer,
   emailDomainsReducer,
   licenseReducer,
   documentsReducer,
+  documentAttachmentReducer,
   teamReducer,
-  agentsReducer
+  agentsReducer,
+  issueCommentReducer,
+  issueUpdateReducer
 };
 const overmapReducer = 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);
@@ -5298,24 +4825,14 @@ class CategoryService extends BaseApiService {
     });
     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,
@@ -5330,7 +4847,7 @@ class CategoryService extends BaseApiService {
     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,
@@ -5343,33 +4860,20 @@ class CategoryService extends BaseApiService {
       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) {
@@ -5420,10 +4924,10 @@ class AssetService extends BaseApiService {
     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",
@@ -5440,10 +4944,10 @@ class AssetService extends BaseApiService {
   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,
@@ -5451,9 +4955,7 @@ class AssetService extends BaseApiService {
       blockers: affectedOfflineIds,
       blocks: affectedOfflineIds
     }).catch((err) => {
-      if (allAssetsOfAssetType) {
-        store.dispatch(addAssetsInBatches(allAssetsOfAssetType));
-      }
+      store.dispatch(addAssets(allAssetsOfAssetType));
       throw err;
     });
   }
@@ -5503,7 +5005,7 @@ class AssetService extends BaseApiService {
     }
     void Promise.all(batchPromises).then((result) => {
       const allCreatedAssets = result.flat();
-      store.dispatch(addAssetsInBatches(allCreatedAssets));
+      store.dispatch(addAssets(allCreatedAssets));
     });
     return batchPromises;
   }
@@ -5516,14 +5018,14 @@ class AssetService extends BaseApiService {
       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`);
     }
@@ -5677,7 +5179,11 @@ class AssetStageService extends BaseApiService {
   }
   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",
@@ -5688,13 +5194,17 @@ class AssetStageService extends BaseApiService {
         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",
@@ -5704,7 +5214,7 @@ class AssetStageService extends BaseApiService {
         blocks: [stageId]
       });
     } catch (e) {
-      store.dispatch(linkStageToForm({ stageId, formId: formId2 }));
+      store.dispatch(setStage(stage));
       throw e;
     }
   }
@@ -5717,7 +5227,7 @@ class AssetStageService extends BaseApiService {
       blockers: [],
       blocks: []
     });
-    store.dispatch(addStages(result));
+    store.dispatch(initializeStages(result));
   }
 }
 const AttachmentModelMeta = {
@@ -5755,22 +5265,22 @@ const AttachmentModelMeta = {
 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;
   }
@@ -5790,22 +5300,7 @@ class BaseAttachmentService extends BaseApiService {
       });
     }
   }
-  // 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();
@@ -5839,7 +5334,7 @@ class BaseAttachmentService extends BaseApiService {
         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}`,
@@ -5854,22 +5349,22 @@ class BaseAttachmentService extends BaseApiService {
       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",
@@ -5883,15 +5378,37 @@ class BaseAttachmentService extends BaseApiService {
         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({
@@ -5906,28 +5423,10 @@ class AssetAttachmentService extends BaseAttachmentService {
     });
   }
   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 {
@@ -5973,7 +5472,7 @@ class AssetTypeService extends BaseApiService {
     }
     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",
@@ -5997,13 +5496,20 @@ class AssetTypeService extends BaseApiService {
       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({
@@ -6018,33 +5524,10 @@ class AssetTypeAttachmentService extends BaseAttachmentService {
     });
   }
   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 {
@@ -6066,13 +5549,13 @@ class IssueCommentService extends BaseApiService {
       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`);
     }
@@ -6091,11 +5574,11 @@ class IssueCommentService extends BaseApiService {
     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,
@@ -6140,13 +5623,20 @@ class IssueUpdateService extends BaseApiService {
         `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({
@@ -6161,28 +5651,10 @@ class IssueAttachmentService extends BaseAttachmentService {
     });
   }
   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 {
@@ -6238,41 +5710,22 @@ class IssueService extends BaseApiService {
           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,
@@ -6289,7 +5742,7 @@ class IssueService extends BaseApiService {
             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`
@@ -6352,28 +5805,26 @@ class IssueService extends BaseApiService {
     });
     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",
@@ -6384,7 +5835,7 @@ class IssueService extends BaseApiService {
       });
     } catch (e) {
       dispatch(addIssue(backup));
-      dispatch(addIssueAttachments(attachments));
+      dispatch(addIssueAttachments(attachmentsOfIssue));
       dispatch(addIssueUpdates(updatesOfIssue));
       dispatch(addActiveProjectIssuesCount(1));
       throw e;
@@ -6397,9 +5848,23 @@ class IssueService extends BaseApiService {
     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 {
@@ -6441,7 +5906,8 @@ class IssueTypeService extends BaseApiService {
   }
   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.`);
     }
@@ -6467,13 +5933,13 @@ class IssueTypeService extends BaseApiService {
   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}/`,
@@ -6498,7 +5964,7 @@ class IssueTypeService extends BaseApiService {
       blockers: [],
       blocks: []
     });
-    store.dispatch(setIssueTypes(result));
+    store.dispatch(initializeIssueTypes(result));
   }
 }
 class MainService extends BaseApiService {
@@ -6632,12 +6098,12 @@ class MainService extends BaseApiService {
     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));
@@ -6695,7 +6161,7 @@ class ProjectAccessService extends BaseApiService {
   // 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,
@@ -6818,6 +6284,13 @@ class ProjectAttachmentService extends BaseAttachmentService {
   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({
@@ -6832,28 +6305,10 @@ class ProjectAttachmentService extends BaseAttachmentService {
     });
   }
   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 {
@@ -6931,9 +6386,9 @@ class ProjectService extends BaseApiService {
     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);
@@ -7188,8 +6643,13 @@ class UserFormService extends BaseApiService {
   }
   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",
@@ -7199,14 +6659,19 @@ class UserFormService extends BaseApiService {
         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",
@@ -7216,7 +6681,7 @@ class UserFormService extends BaseApiService {
         blocks: [`favorite-${formId2}`]
       });
     } catch (e) {
-      store.dispatch(favoriteForm({ formId: formId2 }));
+      store.dispatch(updateForm(form));
       throw e;
     }
   }
@@ -7317,7 +6782,7 @@ class UserFormService extends BaseApiService {
     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));
   }
 }
@@ -7544,7 +7009,10 @@ class UserFormSubmissionService extends BaseApiService {
       ...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",
@@ -7566,7 +7034,10 @@ class UserFormSubmissionService extends BaseApiService {
   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));
@@ -7581,7 +7052,7 @@ class UserFormSubmissionService extends BaseApiService {
       });
     } catch (e) {
       store.dispatch(addActiveProjectFormSubmissionsCount(1));
-      store.dispatch(addFormSubmission(submission));
+      store.dispatch(addFormSubmission(submissionToBeDeleted));
       store.dispatch(addFormSubmissionAttachments(submissionAttachments));
       throw e;
     }
@@ -7621,15 +7092,15 @@ class WorkspaceService extends BaseApiService {
       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,
@@ -7649,8 +7120,8 @@ class WorkspaceService extends BaseApiService {
       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) => {
@@ -7678,7 +7149,7 @@ class OrganizationAccessService extends BaseApiService {
     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",
@@ -7702,7 +7173,7 @@ class OrganizationAccessService extends BaseApiService {
       blockers: [],
       blocks: []
     });
-    store.dispatch(setOrganizationAccesses(result));
+    store.dispatch(initializeOrganizationAccesses(result));
   }
 }
 const cachedRequestPromises = {};
@@ -7937,15 +7408,6 @@ class EmailVerificationService extends BaseApiService {
   }
 }
 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",
@@ -7957,7 +7419,7 @@ class EmailDomainsService extends BaseApiService {
     });
   }
   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,
@@ -7974,9 +7436,14 @@ class EmailDomainsService extends BaseApiService {
     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 {
@@ -8005,8 +7472,8 @@ class OrganizationService extends BaseApiService {
     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));
     }
@@ -8319,6 +7786,13 @@ class DocumentAttachmentService extends BaseAttachmentService {
   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({
@@ -8333,28 +7807,10 @@ class DocumentAttachmentService extends BaseAttachmentService {
     });
   }
   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 {
@@ -8395,7 +7851,7 @@ class AgentService extends BaseApiService {
       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");
       }
@@ -8441,7 +7897,7 @@ class AgentService extends BaseApiService {
       blockers: ["agent-conversations"],
       blocks: ["agent-conversations"]
     });
-    store.dispatch(setConversations(result));
+    store.dispatch(initializeConversations(result));
   }
 }
 class TeamService extends BaseApiService {
@@ -8479,7 +7935,10 @@ class TeamService extends BaseApiService {
   // TODO: @Audiopolis / Magnus - should we pass a offline_id as one arg and a UpdatedTeamProps as a second arg instead of this set up?
   update(team) {
     const { store } = this.client;
-    const teamToBeUpdated = 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
@@ -8503,7 +7962,7 @@ class TeamService extends BaseApiService {
   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`);
     }
@@ -8523,7 +7982,7 @@ class TeamService extends BaseApiService {
   }
   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`);
     }
@@ -8548,7 +8007,7 @@ class TeamService extends BaseApiService {
   }
   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`);
     }
@@ -8557,7 +8016,7 @@ class TeamService extends BaseApiService {
   }
   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`);
     }
@@ -16914,7 +16373,7 @@ export {
   addAssetType,
   addAssetTypeAttachment,
   addAssetTypeAttachments,
-  addAssetsInBatches,
+  addAssets,
   addCategory,
   addConversation,
   addDocumentAttachment,
@@ -16942,12 +16401,9 @@ export {
   addIssueUpdates,
   addIssues,
   addLicenses,
-  addOrReplaceCategories,
-  addOrReplaceIssueComment,
   addOrReplaceProjectFile,
   addOrReplaceProjectFiles,
   addOrReplaceProjects,
-  addOrReplaceWorkspaces,
   addProjectAttachment,
   addProjectAttachments,
   addStageCompletion,
@@ -16960,12 +16416,16 @@ export {
   agentsReducer,
   agentsSlice,
   areArraysEqual,
+  assetAttachmentReducer,
+  assetAttachmentSlice,
   assetReducer,
   assetSlice,
   assetStageCompletionReducer,
   assetStageCompletionSlice,
   assetStageReducer,
   assetStageSlice,
+  assetTypeAttachmentReducer,
+  assetTypeAttachmentSlice,
   assetTypeReducer,
   assetTypeSlice,
   authReducer,
@@ -16988,7 +16448,17 @@ export {
   decodeFormValues,
   defaultBadgeColor,
   defaultStore,
+  deleteAsset,
+  deleteAssetAttachment,
+  deleteAssetAttachments,
   deleteAssetType,
+  deleteAssetTypeAttachment,
+  deleteAssetTypeAttachments,
+  deleteAssets,
+  deleteCategory,
+  deleteDocumentAttachment,
+  deleteDocumentAttachments,
+  deleteEmailDomain,
   deleteForm,
   deleteFormRevision,
   deleteFormRevisionAttachment,
@@ -16998,12 +16468,28 @@ export {
   deleteFormSubmissionAttachment,
   deleteFormSubmissionAttachments,
   deleteFormSubmissions,
+  deleteIssue,
+  deleteIssueAttachment,
+  deleteIssueAttachments,
+  deleteIssueComment,
+  deleteIssueComments,
+  deleteIssueUpdate,
+  deleteIssueUpdates,
+  deleteIssues,
+  deleteOrganizationAccess,
   deleteProject,
+  deleteProjectAccess,
+  deleteProjectAccesses,
+  deleteProjectAttachment,
+  deleteProjectAttachments,
   deleteTeam,
+  deleteWorkspace,
   dequeue,
   deserialize,
   deserializeField,
   discard,
+  documentAttachmentReducer,
+  documentAttachmentSlice,
   documentSlice,
   documentsReducer,
   downloadFile,
@@ -17025,17 +16511,20 @@ export {
   enqueue,
   enqueueRequest,
   errorColor,
-  favoriteForm,
   fileReducer,
   fileSlice,
   fileToBlob,
   flattenFields,
   flipCoordinates,
   formReducer,
+  formRevisionAttachmentReducer,
+  formRevisionAttachmentSlice,
   formRevisionReducer,
   formRevisionToSchema,
   formRevisionsSlice,
   formSlice,
+  formSubmissionAttachmentReducer,
+  formSubmissionAttachmentSlice,
   formSubmissionReducer,
   formSubmissionSlice,
   index as forms,
@@ -17054,16 +16543,40 @@ export {
   hideAllCategories,
   hideCategory,
   initialFormValues,
+  initializeAssetAttachments,
+  initializeAssetTypeAttachments,
+  initializeAssetTypes,
+  initializeAssets,
+  initializeCategories,
+  initializeConversations,
+  initializeDocumentAttachments,
+  initializeEmailDomains,
+  initializeFormRevisionAttachments,
+  initializeFormRevisions,
+  initializeFormSubmissionAttachments,
+  initializeIssueAttachments,
+  initializeIssueTypes,
+  initializeIssueUpdates,
+  initializeIssues,
+  initializeOrganizationAccesses,
+  initializeProjectAttachments,
+  initializeStages,
+  initializeWorkspaces,
   isConditionMet,
   isToday,
+  issueAttachmentReducer,
+  issueAttachmentSlice,
+  issueCommentReducer,
+  issueCommentSlice,
   issueReducer,
   issueSlice,
   issueToSearchResult,
   issueTypeReducer,
   issueTypeSlice,
+  issueUpdateReducer,
+  issueUpdateSlice,
   licenseReducer,
   licenseSlice,
-  linkStageToForm,
   literalToCoordinates,
   logOnlyOnce,
   makeClient,
@@ -17090,54 +16603,27 @@ export {
   overmapEnhancer,
   overmapReducer,
   overmapReducers,
-  patchCategory,
   performRequest,
   primaryColor,
   projectAccessReducer,
   projectAccessSlice,
+  projectAttachmentReducer,
+  projectAttachmentSlice,
   projectFileReducer,
   projectFileSlice,
   projectReducer,
   projectSlice,
   rehydratedReducer,
   rehydratedSlice,
-  removeAllAssetsOfType,
-  removeAsset,
-  removeAssetAttachment,
-  removeAssetAttachments,
-  removeAssetTypeAttachment,
-  removeAssetTypeAttachments,
-  removeAssets,
-  removeAttachmentsOfIssue,
-  removeCategory,
-  removeColor,
-  removeDocumentAttachment,
-  removeDocumentAttachments,
   removeDocuments,
-  removeEmailDomain,
   removeFavouriteProjectId,
-  removeIssue,
-  removeIssueAttachment,
-  removeIssueAttachments,
-  removeIssueComment,
-  removeIssueComments,
   removeIssueType,
-  removeIssueUpdate,
-  removeIssueUpdates,
-  removeIssues,
-  removeOrganizationAccess,
-  removeProjectAccess,
-  removeProjectAccessesOfProject,
-  removeProjectAttachment,
-  removeProjectAttachments,
   removeProjectFile,
   removeProjectFilesOfProject,
   removeRecentIssue,
   removeStageCompletions,
   removeStages,
   removeUser,
-  removeWorkspace,
-  replaceCategory,
   resetProjectFileObjectUrls,
   resetRecentIssues,
   resetStore,
@@ -17146,7 +16632,6 @@ export {
   saveActiveProjectFileBounds,
   searchIssues,
   selectAccessToken,
-  selectActiveIssueId,
   selectActiveLicense,
   selectActiveOrganization,
   selectActiveOrganizationAccess,
@@ -17160,7 +16645,6 @@ export {
   selectActiveStatusLicenses,
   selectActiveWorkspace,
   selectActiveWorkspaceId,
-  selectAllAttachments,
   selectAllDocumentAttachments,
   selectAllProjectAttachments,
   selectAncestorIdsOfDocument,
@@ -17196,11 +16680,10 @@ export {
   selectAttachmentsOfProjectByType,
   selectCategories,
   selectCategoriesOfWorkspace,
-  selectCategory,
+  selectCategoryById,
   selectCategoryMapping,
   selectCategoryVisibility,
   selectCenterMapToProject,
-  selectCommentMapping,
   selectCommentsOfIssue,
   selectCompletedStageIdsForAsset,
   selectCompletedStages,
@@ -17214,7 +16697,9 @@ export {
   selectDocumentAttachmentMapping,
   selectDocuments,
   selectDocumentsMapping,
+  selectEmailDomains,
   selectEmailDomainsAsMapping,
+  selectEmailDomainsOfOrganization,
   selectEnableClustering,
   selectEnableDuplicateIssues,
   selectEnablePlacementMode,
@@ -17223,7 +16708,6 @@ export {
   selectEnabledProjectFiles,
   selectExpandedSections,
   selectFavouriteProjects,
-  selectFileAttachmentsOfIssue,
   selectFilteredForms,
   selectForm,
   selectFormMapping,
@@ -17255,6 +16739,7 @@ export {
   selectIssueAttachment,
   selectIssueAttachmentMapping,
   selectIssueAttachments,
+  selectIssueCommentMapping,
   selectIssueCountOfCategory,
   selectIssueMapping,
   selectIssueType,
@@ -17289,9 +16774,9 @@ export {
   selectOrganizationsMapping,
   selectOrganizationsWithAccess,
   selectPermittedWorkspaceIds,
-  selectPhotoAttachmentsOfIssue,
   selectProjectAccess,
   selectProjectAccessForUser,
+  selectProjectAccessMapping,
   selectProjectAccessUserMapping,
   selectProjectAccesses,
   selectProjectAttachment,
@@ -17308,7 +16793,6 @@ export {
   selectRehydrated,
   selectRootDocuments,
   selectShowTooltips,
-  selectSortedEmailDomains,
   selectSortedFormSubmissionsOfForm,
   selectSortedOrganizationLicenses,
   selectSortedOrganizationUsers,
@@ -17327,7 +16811,6 @@ export {
   selectTeamsOfOrganization,
   selectTeamsOfUser,
   selectUploadUrl,
-  selectUsedColors,
   selectUser,
   selectUserFormRevisionAttachmentsMapping,
   selectUsersAsMapping,
@@ -17336,34 +16819,32 @@ export {
   selectWorkspace,
   selectWorkspaceMapping,
   selectWorkspaces,
-  setActiveIssueId,
   setActiveOrganizationId,
   setActiveProjectFileId,
   setActiveProjectId,
   setActiveWorkspaceId,
   setAppearance,
+  setAsset,
   setAssetAttachment,
   setAssetAttachments,
   setAssetTypeAttachment,
   setAssetTypeAttachments,
-  setAssetTypes,
   setAssets,
-  setCategories,
   setCenterMapToProject,
   setConversation,
-  setConversations,
   setCurrentUser,
   setDocumentAttachment,
   setDocumentAttachments,
   setDocuments,
-  setEmailDomains,
   setEnableClustering,
   setEnableDuplicateIssues,
   setEnablePlacementMode,
+  setForm,
   setFormRevision,
+  setFormRevisionAttachment,
   setFormRevisionAttachments,
-  setFormRevisions,
   setFormSubmission,
+  setFormSubmissionAttachment,
   setFormSubmissionAttachments,
   setFormSubmissions,
   setForms,
@@ -17375,13 +16856,10 @@ export {
   setIssueComment,
   setIssueComments,
   setIssueType,
-  setIssueTypes,
-  setIssueUpdates,
-  setIssues,
+  setIssueUpdate,
   setLicenses,
   setLoggedIn,
   setMapStyle,
-  setOrganizationAccesses,
   setOrganizations,
   setProfilePicture,
   setProjectAccesses,
@@ -17391,6 +16869,7 @@ export {
   setProjects,
   setSectionExpanded,
   setShowTooltips,
+  setStage,
   setStageCompletions,
   setTeam,
   setTeams,
@@ -17413,10 +16892,8 @@ export {
   toOfflineIdRecord,
   toggleAssetTypeVisibility,
   truncate,
-  unfavoriteForm,
   unhideAllCategories,
   unhideCategory,
-  unlinkStageToForm,
   updateActiveOrganization,
   updateAsset,
   updateAssetAttachment,
@@ -17424,11 +16901,16 @@ export {
   updateAssetTypeAttachment,
   updateAssetTypeAttachments,
   updateAssets,
+  updateCategory,
   updateConversation,
   updateDocumentAttachment,
   updateDocumentAttachments,
   updateDocuments,
+  updateForm,
+  updateFormRevisionAttachment,
+  updateFormRevisionAttachments,
   updateFormSubmission,
+  updateFormSubmissionAttachment,
   updateFormSubmissionAttachments,
   updateFormSubmissions,
   updateIssue,
@@ -17441,8 +16923,10 @@ export {
   updateProjectAccess,
   updateProjectAttachment,
   updateProjectAttachments,
+  updateStage,
   updateStages,
   updateTeam,
+  updateWorkspace,
   useAppDispatch,
   useAppSelector,
   useFieldInput,