@overmap-ai/core 1.0.63-table-filters.0 → 1.0.63

package/dist/overmap-core.js

@@ -874,24 +874,32 @@ const selectCategoryMapping = (state) => state.categoryReducer.instances;
 const selectCategories = createSelector([selectCategoryMapping], (categoryMapping) => {
   return Object.values(categoryMapping);
 });
-const selectCategoriesOfWorkspace = restructureCreateSelectorWithArgs(
+const selectCategoryById = (id) => (state) => {
+  return state.categoryReducer.instances[id];
+};
+const selectCategoriesByIds = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectCategories, (_state, workspaceId) => workspaceId],
-    (categories, workspaceId) => categories.filter((category) => category.workspace === workspaceId)
+    [selectCategoryMapping, (_state, categoryIds) => categoryIds],
+    (categoryMapping, categoryIds) => {
+      const categories = [];
+      for (const categoryId of categoryIds) {
+        const category = categoryMapping[categoryId];
+        if (category) {
+          categories.push(category);
+        } else {
+          console.warn("selectCategoryByIds: No category exists with the id", categoryId);
+        }
+      }
+      return categories;
+    }
   )
 );
-const selectCategoryById = restructureCreateSelectorWithArgs(
+const selectCategoriesOfWorkspace = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectCategoryMapping, (_state, categoryId) => categoryId],
-    (mapping, categoryId) => mapping[categoryId]
+    [selectCategories, (_state, workspaceId) => workspaceId],
+    (categories, workspaceId) => categories.filter((category) => category.workspace === workspaceId)
   )
 );
-const selectCategoriesByIds = restructureCreateSelectorWithArgs(
-  createSelector([selectCategoryMapping, (_, ids) => ids], (categoryMapping, ids) => {
-    const idsSet = new Set(ids);
-    return Object.values(categoryMapping).filter((category) => idsSet.has(category.offline_id));
-  })
-);
 const selectIssueCountOfCategory = (categoryId) => (state) => {
   return Object.values(state.issueReducer.instances).filter((issue) => issue.category === categoryId).length;
 };
@@ -914,36 +922,26 @@ const selectAssetTypes = createSelector(
   [selectAssetTypesMapping],
   (mapping) => Object.values(mapping)
 );
-const selectAssetType = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAssetTypesMapping, (_state, assetTypeId) => assetTypeId],
-    (mapping, assetTypeId) => mapping[assetTypeId]
-  )
-);
-const selectNumberOfAssetTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
+const selectAssetTypeById = (id) => (state) => {
+  return state.assetTypeReducer.instances[id];
+};
+const selectAssetTypesByIds = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectAssetTypesMapping, (_state, args) => args],
-    (mapping, args) => {
-      var _a2;
-      const name = ((_a2 = args.name) == null ? void 0 : _a2.toLowerCase()) ?? null;
-      return Object.values(mapping).filter(
-        (assetType) => {
-          var _a3;
-          return (((_a3 = assetType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && assetType.offline_id !== args.assetTypeId;
+    [selectAssetTypesMapping, (_state, assetTypeIds) => assetTypeIds],
+    (assetTypeMapping, assetTypeIds) => {
+      const assetTypes = [];
+      for (const assetTypeId of assetTypeIds) {
+        const assetType = assetTypeMapping[assetTypeId];
+        if (assetType) {
+          assetTypes.push(assetType);
+        } else {
+          console.warn("selectAssetTypesByIds: No assetType exists with the id", assetTypeId);
         }
-      ).length;
+      }
+      return assetTypes;
     }
   )
 );
-const selectAssetTypesByName = restructureCreateSelectorWithArgs(
-  createSelector([selectAssetTypesMapping, (_state, name) => name], (mapping, name) => {
-    name = (name == null ? void 0 : name.toLowerCase()) ?? null;
-    return Object.values(mapping).filter((assetType) => {
-      var _a2;
-      return (((_a2 = assetType.name) == null ? void 0 : _a2.toLowerCase()) ?? null) === name;
-    });
-  })
-);
 const assetTypeReducer = assetTypeSlice.reducer;
 const assetAdapter = createModelAdapter((asset) => asset.offline_id);
 const initialState$y = assetAdapter.getInitialState({});
@@ -952,42 +950,15 @@ const assetSlice = createSlice({
   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) => {
-      assetAdapter.addOne(state, action);
-      prevAssets = null;
-    },
-    addAssets: (state, action) => {
-      assetAdapter.addMany(state, action);
-      prevAssets = null;
-    },
-    setAsset: (state, action) => {
-      assetAdapter.setOne(state, action);
-      prevAssets = null;
-    },
-    setAssets: (state, action) => {
-      assetAdapter.setMany(state, action);
-      prevAssets = null;
-    },
-    updateAsset: (state, action) => {
-      assetAdapter.updateOne(state, action);
-      prevAssets = null;
-    },
-    updateAssets: (state, action) => {
-      assetAdapter.updateMany(state, action);
-      prevAssets = null;
-    },
-    deleteAsset: (state, action) => {
-      assetAdapter.deleteOne(state, action);
-      prevAssets = null;
-    },
-    deleteAssets: (state, action) => {
-      assetAdapter.deleteMany(state, action);
-      prevAssets = null;
-    }
+    initializeAssets: assetAdapter.initialize,
+    addAsset: assetAdapter.addOne,
+    addAssets: assetAdapter.addMany,
+    setAsset: assetAdapter.setOne,
+    setAssets: assetAdapter.setMany,
+    updateAsset: assetAdapter.updateOne,
+    updateAssets: assetAdapter.updateMany,
+    deleteAsset: assetAdapter.deleteOne,
+    deleteAssets: assetAdapter.deleteMany
   }
 });
 const {
@@ -1001,22 +972,29 @@ const {
   setAsset,
   setAssets
 } = assetSlice.actions;
-let prevAssets = null;
-const selectAssets = (state) => {
-  if (!prevAssets) {
-    prevAssets = Object.values(state.assetReducer.instances);
-  }
-  return prevAssets;
-};
 const selectAssetsMapping = (state) => state.assetReducer.instances;
+const selectAssets = createSelector([selectAssetsMapping], (assetsMapping) => {
+  return Object.values(assetsMapping);
+});
 const selectAssetsOfAssetType = restructureCreateSelectorWithArgs(
   createSelector([selectAssets, (_state, assetTypeId) => assetTypeId], (components, assetTypeId) => {
     return components.filter((asset) => asset.asset_type === assetTypeId);
   })
 );
-const selectAsset = (assetId) => (state) => {
+const selectAssetById = (assetId) => (state) => {
   return state.assetReducer.instances[assetId];
 };
+const selectAssetsByIds = restructureCreateSelectorWithArgs(
+  createSelector([selectAssetsMapping, (_, assetIds) => assetIds], (assetsMapping, assetIds) => {
+    const assets = [];
+    for (const assetId of assetIds) {
+      const asset = assetsMapping[assetId];
+      if (asset)
+        assets.push(asset);
+    }
+    return assets;
+  })
+);
 const selectAssetToAssetTypeMapping = createSelector(
   [selectAssets, selectAssetTypesMapping],
   (assets, assetTypeMapping) => {
@@ -1037,19 +1015,7 @@ const selectAssetToAssetTypeMapping = createSelector(
   }
 );
 const selectNumberOfAssetsOfAssetType = (assetTypeId) => (state) => {
-  var _a2;
-  if (!assetTypeId)
-    return 0;
-  return (_a2 = selectAssetsOfAssetType(assetTypeId)(state)) == null ? void 0 : _a2.length;
-};
-const selectAssetTypesFromIds = (assetTypeIds) => (state) => {
-  return assetTypeIds.reduce((acc, assetTypeId) => {
-    const assetType = state.assetTypeReducer.instances[assetTypeId];
-    if (assetType) {
-      acc.push(assetType);
-    }
-    return acc;
-  }, []);
+  return selectAssetsOfAssetType(assetTypeId)(state).length;
 };
 const assetReducer = assetSlice.reducer;
 const assetAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
@@ -1086,8 +1052,8 @@ const selectAssetAttachments = createSelector(
   [selectAssetAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
-const selectAssetAttachment = (attachmentId) => (state) => {
-  return state.assetAttachmentReducer.instances[attachmentId];
+const selectAssetAttachmentById = (id) => (state) => {
+  return state.assetAttachmentReducer.instances[id];
 };
 const selectAttachmentsOfAsset = restructureCreateSelectorWithArgs(
   createSelector(
@@ -1188,19 +1154,16 @@ const assetStageSlice = createSlice({
   }
 });
 const selectStageMapping = (state) => state.assetStageReducer.instances;
-const selectStage = restructureCreateSelectorWithArgs(
+const selectAssetStageById = restructureCreateSelectorWithArgs(
   createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
     return stageMapping[stageId];
   })
 );
-const selectStages = createSelector(
-  [selectStageMapping],
-  (stageMapping) => {
-    return Object.values(stageMapping);
-  }
-);
+const selectAssetStages = createSelector([selectStageMapping], (stageMapping) => {
+  return Object.values(stageMapping);
+});
 const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
-  createSelector([selectStages, (_state, assetTypeIds) => assetTypeIds], (stages, assetTypeIds) => {
+  createSelector([selectAssetStages, (_state, assetTypeIds) => assetTypeIds], (stages, assetTypeIds) => {
     const assetTypeIdsSet = new Set(assetTypeIds);
     const ret = {};
     for (const stage of stages) {
@@ -1229,13 +1192,22 @@ const selectAssetTypeStagesMapping = restructureCreateSelectorWithArgs(
   })
 );
 const selectStagesOfAssetType = restructureCreateSelectorWithArgs(
-  createSelector([selectStages, (_state, assetTypeId) => assetTypeId], (stages, assetTypeId) => {
+  createSelector([selectAssetStages, (_state, assetTypeId) => assetTypeId], (stages, assetTypeId) => {
     return stages.filter((stage) => stage.asset_type === assetTypeId).sort((a, b) => a.priority - b.priority);
   })
 );
-const selectStagesFromStageIds = restructureCreateSelectorWithArgs(
+const selectAssetStagesByIds = restructureCreateSelectorWithArgs(
   createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
-    return stageIds.map((offline_id) => stageMapping[offline_id]).filter((stage) => !!stage);
+    const assetStages = [];
+    for (const stageId of stageIds) {
+      const stage = stageMapping[stageId];
+      if (stage) {
+        assetStages.push(stage);
+      } else {
+        console.warn("selectStagesFromStageIds: No stage exists with the id", stageId);
+      }
+    }
+    return assetStages;
   })
 );
 const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
@@ -1291,8 +1263,8 @@ const selectAssetTypeAttachments = createSelector(
   [selectAssetTypeAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
-const selectAssetTypeAttachment = (attachmentId) => (state) => {
-  return state.assetTypeAttachmentReducer.instances[attachmentId];
+const selectAssetTypeAttachmentById = (id) => (state) => {
+  return state.assetTypeAttachmentReducer.instances[id];
 };
 const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
   createSelector(
@@ -1342,8 +1314,8 @@ const selectMainWorkspace = createSelector(
     return workspaces.find((workspace) => workspace.name.toLowerCase() === "main");
   }
 );
-const selectWorkspaceById = (workspaceId) => (state) => {
-  return state.workspaceReducer.instances[workspaceId];
+const selectWorkspaceById = (id) => (state) => {
+  return state.workspaceReducer.instances[id];
 };
 const selectPermittedWorkspaceIds = createSelector(
   [selectWorkspaceMapping],
@@ -1411,11 +1383,9 @@ const {
 } = issueSlice.actions;
 const selectIssueMapping = (state) => state.issueReducer.instances;
 const selectRecentIssueIds = (state) => state.issueReducer.recentIssueIds;
-const selectIssue = restructureCreateSelectorWithArgs(
-  createSelector([selectIssueMapping, (_state, id) => id], (mapping, id) => {
-    return mapping[id];
-  })
-);
+const selectIssueById = (id) => (state) => {
+  return state.issueReducer.instances[id];
+};
 const searchIssues = restructureCreateSelectorWithArgs(
   createSelector(
     [selectIssueMapping, selectWorkspaceMapping, (_state, searchArgs) => searchArgs],
@@ -1471,6 +1441,20 @@ const searchIssues = restructureCreateSelectorWithArgs(
     }
   )
 );
+const selectIssuesByIds = restructureCreateSelectorWithArgs(
+  createSelector([selectIssueMapping, (_, issueIds) => issueIds], (issuesMapping, issueIds) => {
+    const issues = [];
+    for (const issueId of issueIds) {
+      const issue = issuesMapping[issueId];
+      if (issue) {
+        issues.push(issue);
+      } else {
+        console.warn("selectIssuesByIds: No issue exists with the id", issueId);
+      }
+    }
+    return issues;
+  })
+);
 const selectRecentIssuesAsSearchResults = createSelector(
   [selectIssueMapping, selectRecentIssueIds, selectWorkspaceMapping],
   (issueMapping, recentIssueIds, workspaceMapping) => {
@@ -1532,14 +1516,21 @@ const selectIssueTypes = createSelector(
     return Object.values(issueTypes);
   }
 );
-const selectIssueType = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectIssueTypeMapping, (_, issueTypeId) => issueTypeId],
-    (issueTypesMapping, issueTypeId) => {
-      return issueTypesMapping[issueTypeId];
+const selectIssueTypeById = (id) => (state) => {
+  return state.issueTypeReducer.instances[id];
+};
+const selectIssueTypesByIds = (issueTypeIds) => (state) => {
+  const issueTypes = [];
+  for (const issueTypeId of issueTypeIds) {
+    const issueType = state.issueTypeReducer.instances[issueTypeId];
+    if (issueType) {
+      issueTypes.push(issueType);
+    } else {
+      console.warn("selectIssueTypesByIds: No issue type exists with the id", issueTypeId);
     }
-  )
-);
+  }
+  return issueTypes;
+};
 const selectIssueTypesOfOrganization = restructureCreateSelectorWithArgs(
   createSelector(
     [selectIssueTypes, (_, organizationId) => organizationId],
@@ -1557,8 +1548,7 @@ const selectIssuesOfIssueType = restructureCreateSelectorWithArgs(
   )
 );
 const selectIssuesOfIssueTypeCount = (issueTypeId) => (state) => {
-  var _a2;
-  return ((_a2 = selectIssuesOfIssueType(issueTypeId)(state)) == null ? void 0 : _a2.length) ?? 0;
+  return selectIssuesOfIssueType(issueTypeId)(state).length;
 };
 const issueTypeReducer = issueTypeSlice.reducer;
 const initialState$q = {
@@ -1715,21 +1705,27 @@ const {
   setTourStep,
   removeUser
 } = userSlice.actions;
+const userReducer = userSlice.reducer;
 const selectCurrentUser = (state) => state.userReducer.currentUser;
-const selectUser = (userId) => (state) => {
-  if (userId === null)
-    return void 0;
-  return state.userReducer.users[userId];
+const selectUsersMapping = (state) => state.userReducer.users;
+const selectUserById = (id) => (state) => {
+  return state.userReducer.users[id];
 };
-const selectUsersAsMapping = (state) => state.userReducer.users;
 const selectUsersByIds = restructureCreateSelectorWithArgs(
-  createSelector([selectUsersAsMapping, (_, ids) => ids], (usersMapping, ids) => {
-    const idsSet = new Set(ids);
-    return Object.values(usersMapping).filter((user) => idsSet.has(user.id));
+  createSelector([selectUsersMapping, (_state, userIds) => userIds], (usersMapping, userIds) => {
+    const users = [];
+    for (const userId of userIds) {
+      const user = usersMapping[userId];
+      if (user) {
+        users.push(user);
+      } else {
+        console.warn("selectUsersByIds: No user exists with the id", userId);
+      }
+    }
+    return users;
   })
 );
 const selectFavouriteProjects = (state) => state.userReducer.currentUser.profile.favourite_project_ids;
-const userReducer = userSlice.reducer;
 const organizationAccessAdapter = createModelAdapter(
   (organizationAccess) => organizationAccess.offline_id
 );
@@ -1748,8 +1744,8 @@ const { initializeOrganizationAccesses, updateOrganizationAccess, deleteOrganiza
 const selectOrganizationAccesses = (state) => {
   return state.organizationAccessReducer.instances;
 };
-const selectOrganizationAccess = (organizationAccessId) => (state) => {
-  return state.organizationAccessReducer.instances[organizationAccessId];
+const selectOrganizationAccessById = (id) => (state) => {
+  return state.organizationAccessReducer.instances[id];
 };
 const selectActiveOrganizationAccess = createSelector(
   [selectCurrentUser, selectOrganizationAccesses],
@@ -1789,10 +1785,7 @@ const { initializeLicences, addLicenses, updateLicense } = licenseSlice.actions;
 const selectLicenses = (state) => {
   return state.licenseReducer.instances;
 };
-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 selectLicense = (id) => (state) => state.licenseReducer.instances[id];
 const selectLicenseForProject = (projectId) => (state) => Object.values(state.licenseReducer.instances).find((license) => license.project === projectId);
 const selectActiveStatusLicenses = createSelector(
   [selectLicenses],
@@ -1826,14 +1819,9 @@ const selectProjectAccesses = createSelector(
     return Object.values(projectAccesses);
   }
 );
-const selectProjectAccess = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectProjectAccessMapping, (_state, projectAccessId) => projectAccessId],
-    (projectAccesses, projectAccessId) => {
-      return projectAccesses[projectAccessId];
-    }
-  )
-);
+const selectProjectAccessById = (id) => (state) => {
+  return state.projectAccessReducer.instances[id];
+};
 const selectActiveProjectAccess = (state) => {
   const currentUser = state.userReducer.currentUser;
   const activeProjectId = state.projectReducer.activeProjectId;
@@ -1926,7 +1914,8 @@ const {
   addActiveProjectIssuesCount,
   addActiveProjectFormSubmissionsCount
 } = projectSlice.actions;
-const selectProjects = (state) => state.projectReducer.projects;
+const projectReducer = projectSlice.reducer;
+const selectProjectMapping = (state) => state.projectReducer.projects;
 const selectActiveProjectId = (state) => state.projectReducer.activeProjectId;
 const selectActiveProject = (state) => {
   const activeProjectId = selectActiveProjectId(state);
@@ -1935,23 +1924,19 @@ const selectActiveProject = (state) => {
   }
   return state.projectReducer.projects[activeProjectId] ?? null;
 };
-const selectProject = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectProjects, (_state, projectId) => projectId],
-    (projects, projectId) => projects[projectId]
-  )
-);
-const projectReducer = projectSlice.reducer;
+const selectProjectById = (id) => (state) => {
+  return state.projectReducer.projects[id];
+};
 const selectProjectUsersIds = createSelector(
   [selectProjectAccessMapping],
   (projectAccesses) => Object.values(projectAccesses).map((projectAccess) => projectAccess.user)
 );
 const selectProjectUsersAsMapping = createSelector(
-  [selectProjectUsersIds, selectUsersAsMapping],
+  [selectProjectUsersIds, selectUsersMapping],
   (projectUserIds, users) => projectUserIds.reduce((accum, userId) => ({ ...accum, [userId]: users[userId] }), {})
 );
 const selectProjectsWithAccess = createSelector(
-  [selectProjects],
+  [selectProjectMapping],
   (projects) => Object.values(projects).filter((project) => !project.invited)
 );
 const selectSortedProjectUsers = createSelector(
@@ -1991,27 +1976,30 @@ const organizationSlice = createSlice({
   }
 });
 const { setOrganizations } = organizationSlice.actions;
-const selectOrganizations = (state) => {
-  return Object.values(state.organizationReducer.organizations);
-};
 const selectOrganizationsMapping = (state) => {
   return state.organizationReducer.organizations;
 };
+const selectOrganizations = createSelector([selectOrganizationsMapping], (organizationsMapping) => {
+  return Object.values(organizationsMapping);
+});
+const selectOrganizationById = (id) => (state) => {
+  return state.organizationReducer.organizations[id];
+};
 const selectOrganizationsWithAccess = createSelector(
   [selectOrganizations],
   (organizations) => Object.values(organizations).filter((organization) => organization.has_access)
 );
-const selectOrganizationById = (organizationId) => (state) => {
-  return state.organizationReducer.organizations[organizationId];
-};
 const selectOrganizationUsersIds = createSelector(
   [selectOrganizationAccesses],
   (organizationAccesses) => Object.values(organizationAccesses).map((organizationAccess) => organizationAccess.user)
 );
 const selectProjectsOfOrganization = restructureCreateSelectorWithArgs(
-  createSelector([selectProjects, (_, organizationId) => organizationId], (projects, organizationId) => {
-    return Object.values(projects).filter((project) => project.organization_owner === organizationId);
-  })
+  createSelector(
+    [selectProjectMapping, (_, organizationId) => organizationId],
+    (projects, organizationId) => {
+      return Object.values(projects).filter((project) => project.organization_owner === organizationId);
+    }
+  )
 );
 const selectLicensesOfOrganization = restructureCreateSelectorWithArgs(
   createSelector([selectLicenses, (_, organizationId) => organizationId], (licenses, organizationId) => {
@@ -2019,7 +2007,7 @@ const selectLicensesOfOrganization = restructureCreateSelectorWithArgs(
   })
 );
 const selectOrganizationUsersAsMapping = createSelector(
-  [selectOrganizationUsersIds, selectUsersAsMapping],
+  [selectOrganizationUsersIds, selectUsersMapping],
   (organizationUserIds, users) => organizationUserIds.reduce((accum, userId) => ({ ...accum, [userId]: users[userId] }), {})
 );
 const selectSortedOrganizationUsers = createSelector(
@@ -2043,9 +2031,6 @@ const selectSortedOrganizationUsers = createSelector(
     });
   }
 );
-const selectOrganization = (id) => (state) => {
-  return state.organizationReducer.organizations[id];
-};
 const organizationReducer = organizationSlice.reducer;
 const createOfflineAction = (request2, baseUrl, serviceName) => {
   const requestWithUuid = request2.uuid ? request2 : { ...request2, uuid: v4() };
@@ -2229,16 +2214,13 @@ const selectAllProjectAttachments = createSelector(
   [selectProjectAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
-const selectProjectAttachment = (attachmentId) => (state) => {
-  return state.projectAttachmentReducer.instances[attachmentId];
+const selectProjectAttachmentById = (id) => (state) => {
+  return state.projectAttachmentReducer.instances[id];
 };
 const selectAttachmentsOfProject = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAllProjectAttachments, (_state, projectId) => projectId],
-    (attachments, projectId) => {
-      return attachments.filter(({ project }) => projectId === project);
-    }
-  )
+  createSelector([selectAllProjectAttachments, (_, projectId) => projectId], (attachments, projectId) => {
+    return attachments.filter(({ project }) => projectId === project);
+  })
 );
 const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
   createSelector(
@@ -2274,22 +2256,6 @@ const rehydratedSlice = createSlice({
 const { setRehydrated } = rehydratedSlice.actions;
 const selectRehydrated = (state) => state.rehydratedReducer.isRehydrated;
 const rehydratedReducer = rehydratedSlice.reducer;
-const initialState$f = {
-  isFetchingInitialData: false
-};
-const settingSlice = createSlice({
-  name: "settings",
-  initialState: initialState$f,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
-  reducers: {
-    setIsFetchingInitialData: (state, action) => {
-      state.isFetchingInitialData = action.payload;
-    }
-  }
-});
-const { setIsFetchingInitialData } = settingSlice.actions;
-const settingReducer = settingSlice.reducer;
-const selectIsFetchingInitialData = (state) => state.settingReducer.isFetchingInitialData;
 const formRevisionSortFn = (formRevisionA, formRevisionB) => {
   const revisionA = formRevisionA.revision;
   const revisionB = formRevisionB.revision;
@@ -2304,11 +2270,11 @@ const formRevisionSortFn = (formRevisionA, formRevisionB) => {
   }
 };
 const formRevisionAdapter = createModelAdapter((revision) => revision.offline_id);
-const initialState$e = formRevisionAdapter.getInitialState({});
+const initialState$f = formRevisionAdapter.getInitialState({});
 const formRevisionsSlice = createSlice({
   name: "formRevisions",
-  initialState: initialState$e,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
+  initialState: initialState$f,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
   reducers: {
     initializeFormRevisions: formRevisionAdapter.initialize,
     setFormRevision: formRevisionAdapter.setOne,
@@ -2331,7 +2297,7 @@ const selectFormRevisions = createSelector(
   [selectFormRevisionMapping],
   (formRevisions) => Object.values(formRevisions)
 );
-const selectFormRevision = (formRevisionId) => (state) => {
+const selectFormRevisionById = (formRevisionId) => (state) => {
   return state.formRevisionReducer.instances[formRevisionId];
 };
 const _selectLatestFormRevision = (formRevisions, formId) => {
@@ -2369,32 +2335,6 @@ const selectFormRevisionsOfForm = restructureCreateSelectorWithArgs(
     }
   )
 );
-const selectLatestFormRevisionsOfAssetTypes = restructureCreateSelectorWithArgs(
-  createSelector(
-    [
-      (state) => state.formReducer.instances,
-      selectFormRevisionMapping,
-      (_state, assetTypeIds) => assetTypeIds
-    ],
-    (formsMapping, revisions, assetTypeIds) => {
-      const assetTypeIdsSet = new Set(assetTypeIds);
-      const formsOfAssetTypes = {};
-      const ret = {};
-      for (const form of Object.values(formsMapping)) {
-        if (form.asset_type && assetTypeIdsSet.has(form.asset_type)) {
-          formsOfAssetTypes[form.offline_id] = form;
-        }
-      }
-      for (const revision of Object.values(revisions)) {
-        const form = formsOfAssetTypes[revision.form];
-        if (!form || !form.asset_type || ret[form.asset_type] && formRevisionSortFn(ret[form.asset_type], revision) > 0)
-          continue;
-        ret[form.asset_type] = revision;
-      }
-      return ret;
-    }
-  )
-);
 const selectLatestFormRevisionByForm = createSelector([selectFormRevisionMapping], (revisions) => {
   const latestRevisions = {};
   for (const revision of Object.values(revisions)) {
@@ -2408,11 +2348,11 @@ const selectLatestFormRevisionByForm = createSelector([selectFormRevisionMapping
 });
 const formRevisionReducer = formRevisionsSlice.reducer;
 const formAdapter = createModelAdapter((form) => form.offline_id);
-const initialState$d = formAdapter.getInitialState({});
+const initialState$e = formAdapter.getInitialState({});
 const formSlice = createSlice({
   name: "forms",
-  initialState: initialState$d,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
+  initialState: initialState$e,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
   reducers: {
     initializeForms: formAdapter.initialize,
     setForm: formAdapter.setOne,
@@ -2423,9 +2363,13 @@ const formSlice = createSlice({
   }
 });
 const { initializeForms, setForm, addForm, addForms, updateForm, deleteForm } = formSlice.actions;
-const selectFormsMapping = (state) => {
+const formReducer = formSlice.reducer;
+const selectFormMapping = (state) => {
   return state.formReducer.instances;
 };
+const selectForms = createSelector([selectFormMapping], (formsMapping) => {
+  return Object.values(formsMapping);
+});
 const selectFilteredForms = restructureCreateSelectorWithArgs(
   createSelector(
     [
@@ -2462,12 +2406,9 @@ const selectFilteredForms = restructureCreateSelectorWithArgs(
     { memoizeOptions: { equalityCheck: shallowEqual } }
   )
 );
-const selectForm = (formId) => (state) => {
+const selectFormById = (formId) => (state) => {
   return state.formReducer.instances[formId];
 };
-const selectFormMapping = (state) => {
-  return state.formReducer.instances;
-};
 const selectFormOfAssetType = restructureCreateSelectorWithArgs(
   createSelector(
     [selectFormMapping, (_state, assetTypeId) => assetTypeId],
@@ -2490,13 +2431,12 @@ const selectFormsCount = createSelector([selectFormMapping], (formsMapping) => {
 const selectGeneralFormCount = createSelector([selectFormMapping], (formsMapping) => {
   return Object.values(formsMapping).filter((form) => !form.asset_type).length;
 });
-const formReducer = formSlice.reducer;
 const submissionAdapter = createModelAdapter((submission) => submission.offline_id);
-const initialState$c = submissionAdapter.getInitialState({});
+const initialState$d = submissionAdapter.getInitialState({});
 const formSubmissionSlice = createSlice({
   name: "formSubmissions",
-  initialState: initialState$c,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
+  initialState: initialState$d,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
   reducers: {
     initializeFormSubmissions: submissionAdapter.initialize,
     setFormSubmission: submissionAdapter.setOne,
@@ -2529,7 +2469,7 @@ const selectFormSubmissions = createSelector(
     return Object.values(submissions);
   }
 );
-const selectFormSubmission = (submissionId) => (state) => {
+const selectFormSubmissionById = (submissionId) => (state) => {
   return state.formSubmissionReducer.instances[submissionId];
 };
 const selectFormSubmissionsOfForm = restructureCreateSelectorWithArgs(
@@ -2704,11 +2644,11 @@ const formSubmissionReducer = formSubmissionSlice.reducer;
 const formSubmissionAttachmentAdapter = createModelAdapter(
   (attachment) => attachment.offline_id
 );
-const initialState$b = formSubmissionAttachmentAdapter.getInitialState({});
+const initialState$c = formSubmissionAttachmentAdapter.getInitialState({});
 const formSubmissionAttachmentSlice = createSlice({
   name: "formSubmissionAttachments",
-  initialState: initialState$b,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
+  initialState: initialState$c,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
   reducers: {
     initializeFormSubmissionAttachments: formSubmissionAttachmentAdapter.initialize,
     addFormSubmissionAttachment: formSubmissionAttachmentAdapter.addOne,
@@ -2735,6 +2675,15 @@ const {
 const selectFormSubmissionAttachmentsMapping = (state) => {
   return state.formSubmissionAttachmentReducer.instances;
 };
+const selectFormSubmissionAttachemntsByIds = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectFormSubmissionAttachmentsMapping, (_, attachmentIds) => attachmentIds],
+    (mapping, attachmentIds) => {
+      const attachmentIdsSet = new Set(attachmentIds);
+      return Object.values(mapping).filter((attachment) => attachmentIdsSet.has(attachment.offline_id));
+    }
+  )
+);
 const selectAttachmentsOfFormSubmission = restructureCreateSelectorWithArgs(
   createSelector(
     [selectFormSubmissionAttachmentsMapping, (_state, submissionId) => submissionId],
@@ -2747,11 +2696,11 @@ const formSubmissionAttachmentReducer = formSubmissionAttachmentSlice.reducer;
 const formRevisionAttachmentAdapter = createModelAdapter(
   (attachment) => attachment.offline_id
 );
-const initialState$a = formRevisionAttachmentAdapter.getInitialState({});
+const initialState$b = formRevisionAttachmentAdapter.getInitialState({});
 const formRevisionAttachmentSlice = createSlice({
   name: "formRevisionAttachments",
-  initialState: initialState$a,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$a)),
+  initialState: initialState$b,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
   reducers: {
     initializeFormRevisionAttachments: formRevisionAttachmentAdapter.initialize,
     addFormRevisionAttachment: formRevisionAttachmentAdapter.addOne,
@@ -2788,10 +2737,10 @@ const selectAttachmentsOfFormRevision = restructureCreateSelectorWithArgs(
 );
 const formRevisionAttachmentReducer = formRevisionAttachmentSlice.reducer;
 const emailDomainAdapter = createModelAdapter((emailDomain) => emailDomain.offline_id);
-const initialState$9 = emailDomainAdapter.getInitialState({});
+const initialState$a = emailDomainAdapter.getInitialState({});
 const emailDomainsSlice = createSlice({
   name: "emailDomains",
-  initialState: initialState$9,
+  initialState: initialState$a,
   reducers: {
     initializeEmailDomains: emailDomainAdapter.initialize,
     addEmailDomain: emailDomainAdapter.addOne,
@@ -2800,7 +2749,7 @@ const emailDomainsSlice = createSlice({
 });
 const { initializeEmailDomains, addEmailDomain, deleteEmailDomain } = emailDomainsSlice.actions;
 const selectEmailDomainsAsMapping = (state) => state.emailDomainsReducer.instances;
-const selectEmailDomains = (state) => Object.values(state.emailDomainsReducer.instances);
+const selectEmailDomains = createSelector([selectEmailDomainsAsMapping], (mapping) => Object.values(mapping));
 const selectEmailDomainsOfOrganization = restructureCreateSelectorWithArgs(
   createSelector(
     [selectEmailDomains, (_, organizationId) => organizationId],
@@ -2810,14 +2759,14 @@ const selectEmailDomainsOfOrganization = restructureCreateSelectorWithArgs(
   )
 );
 const emailDomainsReducer = emailDomainsSlice.reducer;
-const initialState$8 = {
+const initialState$9 = {
   documents: {}
 };
 const documentSlice = createSlice({
   name: "documents",
-  initialState: initialState$8,
+  initialState: initialState$9,
   extraReducers: (builder) => builder.addCase("RESET", (state) => {
-    Object.assign(state, initialState$8);
+    Object.assign(state, initialState$9);
   }),
   reducers: {
     setDocuments: (state, action) => {
@@ -2966,10 +2915,24 @@ const selectDocuments = createSelector(
   [selectDocumentsMapping],
   (mapping) => Object.values(mapping)
 );
-const selectDocument = restructureCreateSelectorWithArgs(
+const selectDocumentById = (documentId) => (state) => {
+  return state.documentsReducer.documents[documentId];
+};
+const selectDocumentsByIds = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectDocumentsMapping, (_state, documentId) => documentId],
-    (mapping, documentId) => mapping[documentId]
+    [selectDocumentsMapping, (_state, documentIds) => documentIds],
+    (mapping, documentIds) => {
+      const documents = [];
+      for (const documentId of documentIds) {
+        const document2 = mapping[documentId];
+        if (document2) {
+          documents.push(document2);
+        } else {
+          console.warn("selectDocumentByIds: No document exists with the id", documentId);
+        }
+      }
+      return documents;
+    }
   )
 );
 const selectAncestorIdsOfDocument = restructureCreateSelectorWithArgs(
@@ -2992,11 +2955,11 @@ const selectRootDocuments = createSelector(
 );
 const documentsReducer = documentSlice.reducer;
 const documentAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-const initialState$7 = documentAttachmentAdapter.getInitialState({});
+const initialState$8 = documentAttachmentAdapter.getInitialState({});
 const documentAttachmentSlice = createSlice({
   name: "documentAttachments",
-  initialState: initialState$7,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
+  initialState: initialState$8,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
   reducers: {
     initializeDocumentAttachments: documentAttachmentAdapter.initialize,
     addDocumentAttachment: documentAttachmentAdapter.addOne,
@@ -3025,8 +2988,8 @@ const selectAllDocumentAttachments = createSelector(
   [selectDocumentAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
-const selectDocumentAttachment = (attachmentId) => (state) => {
-  return state.documentAttachmentReducer.instances[attachmentId];
+const selectDocumentAttachmentById = (id) => (state) => {
+  return state.documentAttachmentReducer.instances[id];
 };
 const selectAttachmentsOfDocument = restructureCreateSelectorWithArgs(
   createSelector(
@@ -3055,11 +3018,11 @@ const selectAttachmentsOfDocumentByType = restructureCreateSelectorWithArgs(
 );
 const documentAttachmentReducer = documentAttachmentSlice.reducer;
 const teamAdapter = createModelAdapter((team) => team.offline_id);
-const initialState$6 = teamAdapter.getInitialState({});
+const initialState$7 = teamAdapter.getInitialState({});
 const teamSlice = createSlice({
   name: "teams",
-  initialState: initialState$6,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
+  initialState: initialState$7,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
   reducers: {
     setTeam: teamAdapter.setOne,
     initializeTeams: teamAdapter.initialize,
@@ -3073,8 +3036,8 @@ const selectTeamsMapping = (state) => state.teamReducer.instances;
 const selectTeams = createSelector([selectTeamsMapping], (teams) => {
   return Object.values(teams);
 });
-const selectTeam = (teamId) => (state) => {
-  return state.teamReducer.instances[teamId];
+const selectTeamById = (id) => (state) => {
+  return state.teamReducer.instances[id];
 };
 const selectTeamsOfOrganization = restructureCreateSelectorWithArgs(
   createSelector(
@@ -3093,11 +3056,11 @@ const teamReducer = teamSlice.reducer;
 const agentUserConversationAdapter = createModelAdapter(
   (conversation) => conversation.offline_id
 );
-const initialState$5 = agentUserConversationAdapter.getInitialState({});
+const initialState$6 = agentUserConversationAdapter.getInitialState({});
 const agentsSlice = createSlice({
   name: "agents",
-  initialState: initialState$5,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
+  initialState: initialState$6,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
   reducers: {
     initializeConversations: agentUserConversationAdapter.initialize,
     addConversation: agentUserConversationAdapter.addOne,
@@ -3119,11 +3082,11 @@ const selectConversation = restructureCreateSelectorWithArgs(
 );
 const agentsReducer = agentsSlice.reducer;
 const issueCommentAdapter = createModelAdapter((comment) => comment.offline_id);
-const initialState$4 = issueCommentAdapter.getInitialState({});
+const initialState$5 = issueCommentAdapter.getInitialState({});
 const issueCommentSlice = createSlice({
   name: "issueComments",
-  initialState: initialState$4,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
+  initialState: initialState$5,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
   reducers: {
     addIssueComment: issueCommentAdapter.addOne,
     addIssueComments: issueCommentAdapter.addMany,
@@ -3152,11 +3115,11 @@ const selectCommentsOfIssue = restructureCreateSelectorWithArgs(
 );
 const issueCommentReducer = issueCommentSlice.reducer;
 const issueUpdateAdapter = createModelAdapter((issueUpdate) => issueUpdate.offline_id);
-const initialState$3 = issueUpdateAdapter.getInitialState({});
+const initialState$4 = issueUpdateAdapter.getInitialState({});
 const issueUpdateSlice = createSlice({
   name: "issueUpdates",
-  initialState: initialState$3,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$3)),
+  initialState: initialState$4,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
   reducers: {
     initializeIssueUpdates: issueUpdateAdapter.setMany,
     setIssueUpdate: issueUpdateAdapter.setOne,
@@ -3185,11 +3148,11 @@ const selectIssueUpdatesOfIssue = restructureCreateSelectorWithArgs(
 );
 const issueUpdateReducer = issueUpdateSlice.reducer;
 const issueAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-const initialState$2 = issueAttachmentAdapter.getInitialState({});
+const initialState$3 = issueAttachmentAdapter.getInitialState({});
 const issueAttachmentSlice = createSlice({
   name: "issueAttachments",
-  initialState: initialState$2,
-  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$2)),
+  initialState: initialState$3,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$3)),
   reducers: {
     initializeIssueAttachments: issueAttachmentAdapter.initialize,
     addIssueAttachment: issueAttachmentAdapter.addOne,
@@ -3226,8 +3189,8 @@ const selectAttachmentsOfIssue = restructureCreateSelectorWithArgs(
     }
   )
 );
-const selectIssueAttachment = (attachmentId) => (root) => {
-  return root.issueAttachmentReducer.instances[attachmentId];
+const selectIssueAttachmentById = (id) => (root) => {
+  return root.issueAttachmentReducer.instances[id];
 };
 const selectAttachmentsOfIssueByType = restructureCreateSelectorWithArgs(
   createSelector(
@@ -3247,23 +3210,23 @@ const selectAttachmentsOfIssueByType = restructureCreateSelectorWithArgs(
   )
 );
 const issueAttachmentReducer = issueAttachmentSlice.reducer;
-const initialState$1 = {
+const initialState$2 = {
   version: 0
 };
 const versioningSlice = createSlice({
   name: "versioning",
-  initialState: initialState$1,
+  initialState: initialState$2,
   reducers: {}
 });
 const versioningReducer = versioningSlice.reducer;
 const geoImageAdapter = createModelAdapter((model) => model.offline_id);
-const initialState = geoImageAdapter.getInitialState({});
+const initialState$1 = geoImageAdapter.getInitialState({});
 const geoImageSlice = createSlice({
   name: "geoImages",
-  initialState,
+  initialState: initialState$1,
   extraReducers: (builder) => {
     builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState);
+      Object.assign(state, initialState$1);
     });
   },
   reducers: {
@@ -3300,6 +3263,67 @@ const selectGeoImagesOfProject = restructureCreateSelectorWithArgs(
   })
 );
 const geoImageReducer = geoImageSlice.reducer;
+const issueAssociationAdapter = createModelAdapter((assoc) => assoc.offline_id);
+const initialState = issueAssociationAdapter.getInitialState({});
+const issueAssociationSlice = createSlice({
+  name: "issueAssociations",
+  initialState,
+  extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState)),
+  reducers: {
+    initializeIssueAssociations: issueAssociationAdapter.initialize,
+    addIssueAssociation: issueAssociationAdapter.addOne,
+    addIssueAssociations: issueAssociationAdapter.addMany,
+    setIssueAssociation: issueAssociationAdapter.setOne,
+    setIssueAssociations: issueAssociationAdapter.setMany,
+    updateIssueAssociation: issueAssociationAdapter.updateOne,
+    updateIssueAssociations: issueAssociationAdapter.updateMany,
+    deleteIssueAssociation: issueAssociationAdapter.deleteOne,
+    deleteIssueAssociations: issueAssociationAdapter.deleteMany
+  }
+});
+const {
+  initializeIssueAssociations,
+  setIssueAssociations,
+  setIssueAssociation,
+  updateIssueAssociation,
+  updateIssueAssociations,
+  addIssueAssociation,
+  addIssueAssociations,
+  deleteIssueAssociation,
+  deleteIssueAssociations
+} = issueAssociationSlice.actions;
+const selectIssueAssociationMapping = (state) => state.issueAssociationReducer.instances;
+const selectIssueAssociations = createSelector([selectIssueAssociationMapping], (associations) => {
+  return Object.values(associations);
+});
+const selectIssueAssociationById = (id) => (state) => {
+  return state.issueAssociationReducer.instances[id];
+};
+const selectIssueAssociationsToIssue = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectIssueAssociationMapping, (_state, issueId) => issueId],
+    (associationMapping, issueId) => {
+      return Object.values(associationMapping).filter((assoc) => assoc.associated_issue === issueId);
+    }
+  )
+);
+const selectIssueAssociationsOfIssue = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectIssueAssociationMapping, (_state, issueId) => issueId],
+    (associationMapping, issueId) => {
+      return Object.values(associationMapping).filter((assoc) => assoc.issue === issueId);
+    }
+  )
+);
+const selectIssueAssociationsOfAsset = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectIssueAssociationMapping, (_state, assetId) => assetId],
+    (associationMapping, assetId) => {
+      return Object.values(associationMapping).filter((assoc) => assoc.asset === assetId);
+    }
+  )
+);
+const issueAssociationReducer = issueAssociationSlice.reducer;
 const fullAssetMarkerSize = 45;
 const DEFAULT_ISSUE_STATUS = IssueStatus.BACKLOG;
 const DEFAULT_ISSUE_PRIORITY = IssuePriority.MEDIUM;
@@ -3356,7 +3380,6 @@ const overmapReducers = {
   organizationAccessReducer,
   projectFileReducer,
   rehydratedReducer,
-  settingReducer,
   formReducer,
   formRevisionReducer,
   formRevisionAttachmentReducer,
@@ -3372,7 +3395,8 @@ const overmapReducers = {
   agentsReducer,
   issueCommentReducer,
   issueUpdateReducer,
-  geoImageReducer
+  geoImageReducer,
+  issueAssociationReducer
 };
 const overmapReducer = combineReducers(overmapReducers);
 const resetStore = "RESET";
@@ -3389,7 +3413,7 @@ function handleWorkspaceRemoval(draft, action) {
     throw new Error("Tried to delete main workspace");
   }
   const categoriesInThisWorkspace = new Set(
-    (selectCategoriesOfWorkspace(workspaceId)(draft) ?? []).map((category) => category.offline_id)
+    selectCategoriesOfWorkspace(workspaceId)(draft).map((category) => category.offline_id)
   );
   for (const issue of issuesVisibleInWorkspace) {
     if (issue.category && categoriesInThisWorkspace.has(issue.category)) {
@@ -4163,11 +4187,13 @@ class AssetService extends BaseApiService {
   }
   async remove(assetId) {
     const { store } = this.client;
-    const assetToBeDeleted = selectAsset(assetId)(store.getState());
+    const state = store.getState();
+    const assetToBeDeleted = selectAssetById(assetId)(state);
     if (!assetToBeDeleted)
       throw new Error(`No asset with id ${assetId} found in the store`);
-    const attachmentsOfAssets = selectAttachmentsOfAsset(assetId)(store.getState());
-    const formSubmissionsOfAssets = selectFormSubmissionsOfAsset(assetId)(store.getState());
+    const attachmentsOfAssets = selectAttachmentsOfAsset(assetId)(state);
+    const formSubmissionsOfAssets = selectFormSubmissionsOfAsset(assetId)(state);
+    const issueAssociations = selectIssueAssociationsOfAsset(assetId)(state);
     this.dispatch(deleteAsset(assetId));
     if (attachmentsOfAssets.length > 0) {
       const attachmentsOfAssetIds = attachmentsOfAssets.map(({ offline_id }) => offline_id);
@@ -4177,6 +4203,10 @@ class AssetService extends BaseApiService {
       const formSubmissionsOfAssetIds = formSubmissionsOfAssets.map(({ offline_id }) => offline_id);
       this.dispatch(deleteFormSubmissions(formSubmissionsOfAssetIds));
     }
+    if (issueAssociations.length > 0) {
+      const issueAssociationsIds = issueAssociations.map(({ offline_id }) => offline_id);
+      this.dispatch(deleteIssueAssociations(issueAssociationsIds));
+    }
     return this.enqueueRequest({
       description: "Delete asset",
       method: HttpMethod.DELETE,
@@ -4187,13 +4217,14 @@ class AssetService extends BaseApiService {
       this.dispatch(addAsset(assetToBeDeleted));
       this.dispatch(addAssetAttachments(attachmentsOfAssets));
       this.dispatch(addFormSubmissions(formSubmissionsOfAssets));
+      this.dispatch(addIssueAssociations(issueAssociations));
       throw err;
     });
   }
   async deleteAllAssetsOfAssetType(assetTypeId) {
     const { store } = this.client;
     const state = store.getState();
-    const allAssetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state) ?? [];
+    const allAssetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state);
     const allAssetsOfAssetTypeIds = allAssetsOfAssetType.map((c) => c.offline_id);
     const affectedOfflineIds = [assetTypeId, ...allAssetsOfAssetTypeIds];
     store.dispatch(deleteAssets(allAssetsOfAssetTypeIds));
@@ -4210,7 +4241,6 @@ class AssetService extends BaseApiService {
   }
   // TODO: payload does not require asset_type
   bulkAdd(assetsToCreate, workspaceId, assetTypeId, batchSize) {
-    const { store } = this.client;
     const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
     const transactionId = v4();
     const assetBatches = chunkArray(assetsToCreate, batchSize).map((assetBatch) => {
@@ -4254,7 +4284,7 @@ class AssetService extends BaseApiService {
     }
     void Promise.all(batchPromises).then((result) => {
       const allCreatedAssets = result.flat();
-      store.dispatch(addAssets(allCreatedAssets));
+      this.dispatch(addAssets(allCreatedAssets));
     });
     return batchPromises;
   }
@@ -4273,7 +4303,7 @@ class AssetStageCompletionService extends BaseApiService {
   add(assetId, stageId) {
     var _a2;
     const { store } = this.client;
-    const assetTypeId = (_a2 = selectAsset(assetId)(store.getState())) == null ? void 0 : _a2.asset_type;
+    const assetTypeId = (_a2 = selectAssetById(assetId)(store.getState())) == null ? void 0 : _a2.asset_type;
     if (!assetTypeId) {
       throw new Error(`Asset with offline_id ${assetId} not found`);
     }
@@ -4379,12 +4409,7 @@ class AssetStageService extends BaseApiService {
   async bulkUpdateStages(stagesToUpdate, assetTypeId) {
     const store = this.client.store;
     const state = store.getState();
-    const prevStages = selectStagesFromStageIds(
-      stagesToUpdate.map(({ offline_id }) => offline_id)
-    )(state);
-    if (!prevStages) {
-      throw new Error("Could not find the desired stages to update within the store");
-    }
+    const prevStages = selectAssetStagesByIds(stagesToUpdate.map(({ offline_id }) => offline_id))(state);
     this.dispatch(updateStages(stagesToUpdate));
     return this.enqueueRequest({
       description: "Edit asset stages",
@@ -4501,8 +4526,9 @@ class BaseUploadService extends BaseApiService {
     return objectsWithSha1.filter((object) => object.file_sha1 === sha1).length;
   }
   processPresignedUrls(presignedUrls) {
+    const promisesBySha1 = {};
     for (const [sha1, presignedUrl] of Object.entries(presignedUrls)) {
-      void this.enqueueRequest({
+      promisesBySha1[sha1] = this.enqueueRequest({
         url: presignedUrl.url,
         description: "Upload file to S3",
         method: HttpMethod.POST,
@@ -4515,6 +4541,7 @@ class BaseUploadService extends BaseApiService {
         s3url: presignedUrl
       });
     }
+    return promisesBySha1;
   }
 }
 const AttachmentModelMeta = {
@@ -4634,7 +4661,7 @@ class BaseAttachmentService extends BaseUploadService {
   }
   // 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(projectId) {
+  async refreshStore(projectId, _organizationId) {
     const meta = AttachmentModelMeta[this.attachmentModel];
     const result = await this.enqueueRequest({
       description: `Get ${meta.name} attachments`,
@@ -4656,7 +4683,7 @@ class AssetAttachmentService extends BaseAttachmentService {
     __publicField(this, "removeAttachments", deleteAssetAttachments);
     __publicField(this, "removeAttachment", deleteAssetAttachment);
     __publicField(this, "setAttachment", setAssetAttachment);
-    __publicField(this, "selectAttachment", selectAssetAttachment);
+    __publicField(this, "selectAttachment", selectAssetAttachmentById);
   }
   buildOfflineAttachment(data) {
     return offline({
@@ -4680,13 +4707,11 @@ class AssetAttachmentService extends BaseAttachmentService {
 class AssetTypeService extends BaseApiService {
   add(assetType) {
     const offlineAssetType = offline(assetType);
-    const { store } = this.client;
-    const activeProjectId = store.getState().projectReducer.activeProjectId;
     this.dispatch(addAssetType(offlineAssetType));
     const promise = this.enqueueRequest({
       description: "Create asset type",
       method: HttpMethod.POST,
-      url: `/projects/${activeProjectId}/asset-types/`,
+      url: `/projects/${assetType.project}/asset-types/`,
       payload: { ...offlineAssetType },
       blockers: [],
       blocks: [offlineAssetType.offline_id]
@@ -4707,11 +4732,11 @@ class AssetTypeService extends BaseApiService {
   async delete(assetTypeId) {
     const { store } = this.client;
     const state = store.getState();
-    const assetType = selectAssetType(assetTypeId)(state);
+    const assetType = selectAssetTypeById(assetTypeId)(state);
     if (!assetType) {
       throw new Error(`Expected asset type with offline_id ${assetTypeId} to exist`);
     }
-    const stagesOfAssetType = selectStagesOfAssetType(assetTypeId)(state) ?? [];
+    const stagesOfAssetType = selectStagesOfAssetType(assetTypeId)(state);
     const attachmentsOfAssetType = selectAttachmentsOfAssetType(assetTypeId)(state);
     this.dispatch(deleteAssetType(assetTypeId));
     if (stagesOfAssetType.length > 0) {
@@ -4756,7 +4781,7 @@ class AssetTypeAttachmentService extends BaseAttachmentService {
     __publicField(this, "removeAttachments", deleteAssetTypeAttachments);
     __publicField(this, "removeAttachment", deleteAssetTypeAttachment);
     __publicField(this, "setAttachment", setAssetTypeAttachment);
-    __publicField(this, "selectAttachment", selectAssetTypeAttachment);
+    __publicField(this, "selectAttachment", selectAssetTypeAttachmentById);
   }
   buildOfflineAttachment(data) {
     return offline({
@@ -4880,7 +4905,7 @@ class IssueAttachmentService extends BaseAttachmentService {
     __publicField(this, "removeAttachments", deleteIssueAttachments);
     __publicField(this, "removeAttachment", deleteIssueAttachment);
     __publicField(this, "setAttachment", setIssueAttachment);
-    __publicField(this, "selectAttachment", selectIssueAttachment);
+    __publicField(this, "selectAttachment", selectIssueAttachmentById);
   }
   buildOfflineAttachment(data) {
     return offline({
@@ -4961,7 +4986,7 @@ class IssueService extends BaseApiService {
   }
   update(issue) {
     const state = this.client.store.getState();
-    const issueToBeUpdated = selectIssue(issue.offline_id)(state);
+    const issueToBeUpdated = selectIssueById(issue.offline_id)(state);
     if (!issueToBeUpdated) {
       throw new Error(
         `Attempting to update an issue with offline_id ${issue.offline_id} that doesn't exist in the store`
@@ -5055,13 +5080,19 @@ class IssueService extends BaseApiService {
   async remove(id) {
     const { store } = this.client;
     const state = store.getState();
-    const backup = selectIssue(id)(state);
+    const backup = selectIssueById(id)(state);
     if (!backup) {
       throw new Error(`No issue with id ${id} found in the store`);
     }
     const attachmentsOfIssue = selectAttachmentsOfIssue(id)(state);
     const updatesOfIssue = selectIssueUpdatesOfIssue(id)(state);
     const formSubmissionsOfIssue = selectFormSubmissionsOfIssue(id)(state);
+    const issueAssociationsRecord = {};
+    for (const issueAssociation of selectIssueAssociationsToIssue(id)(state))
+      issueAssociationsRecord[issueAssociation.offline_id] = issueAssociation;
+    for (const issueAssociation of selectIssueAssociationsOfIssue(id)(state))
+      issueAssociationsRecord[issueAssociation.offline_id] = issueAssociation;
+    const issueAssociations = Object.values(issueAssociationsRecord);
     this.dispatch(deleteIssue(id));
     this.dispatch(addActiveProjectIssuesCount(-1));
     if (attachmentsOfIssue.length > 0)
@@ -5070,6 +5101,8 @@ class IssueService extends BaseApiService {
       this.dispatch(deleteIssueUpdates(updatesOfIssue.map(({ offline_id }) => offline_id)));
     if (formSubmissionsOfIssue.length > 0)
       this.dispatch(deleteFormSubmissions(formSubmissionsOfIssue.map(({ offline_id }) => offline_id)));
+    if (issueAssociations.length > 0)
+      this.dispatch(deleteIssueAssociations(issueAssociations.map(({ offline_id }) => offline_id)));
     try {
       return await this.enqueueRequest({
         description: "Delete issue",
@@ -5084,6 +5117,7 @@ class IssueService extends BaseApiService {
       this.dispatch(addIssueUpdates(updatesOfIssue));
       this.dispatch(addActiveProjectIssuesCount(1));
       this.dispatch(addFormSubmissions(formSubmissionsOfIssue));
+      this.dispatch(addIssueAssociations(issueAssociations));
       throw e;
     }
   }
@@ -5127,7 +5161,7 @@ class IssueTypeService extends BaseApiService {
         offline_id: offlineIssueType.offline_id,
         submitted_at: offlineIssueType.submitted_at,
         icon: offlineIssueType.icon,
-        icon_color: offlineIssueType.icon_color,
+        color: offlineIssueType.color,
         name: offlineIssueType.name,
         description: offlineIssueType.description
       },
@@ -5141,24 +5175,24 @@ class IssueTypeService extends BaseApiService {
     });
     return [offlineIssueType, promise];
   }
-  update(issueTypeFields) {
+  update(payload) {
     const { store } = this.client;
     const state = store.getState();
-    const issueTypeToBeUpdated = selectIssueType(issueTypeFields.offline_id)(state);
+    const issueTypeToBeUpdated = selectIssueTypeById(payload.offline_id)(state);
     if (!issueTypeToBeUpdated) {
-      throw new Error(`IssueType with offline_id ${issueTypeFields.offline_id} does not exist in the store.`);
+      throw new Error(`IssueType with offline_id ${payload.offline_id} does not exist in the store.`);
     }
     const offlineUpdatedIssueType = {
       ...issueTypeToBeUpdated,
-      ...issueTypeFields
+      ...payload
     };
     this.dispatch(updateIssueType(offlineUpdatedIssueType));
     const promise = this.enqueueRequest({
       method: HttpMethod.PATCH,
-      url: `/issues/types/${issueTypeFields.offline_id}/`,
-      payload: issueTypeFields,
-      blockers: [issueTypeFields.offline_id],
-      blocks: [issueTypeFields.offline_id]
+      url: `/issues/types/${payload.offline_id}/`,
+      payload,
+      blockers: [payload.offline_id],
+      blocks: [payload.offline_id]
     });
     promise.then((updatedIssueType) => {
       this.dispatch(setIssueType(updatedIssueType));
@@ -5170,11 +5204,11 @@ class IssueTypeService extends BaseApiService {
   delete(issueTypeId) {
     const { store } = this.client;
     const state = store.getState();
-    const issueTypeToDelete = selectIssueType(issueTypeId)(state);
+    const issueTypeToDelete = selectIssueTypeById(issueTypeId)(state);
     if (!issueTypeToDelete) {
       throw new Error(`IssueType with offline_id ${issueTypeId} does not exist in the store.`);
     }
-    const issuesOfIssueType = selectIssuesOfIssueType(issueTypeId)(state) ?? [];
+    const issuesOfIssueType = selectIssuesOfIssueType(issueTypeId)(state);
     this.dispatch(removeIssueType(issueTypeId));
     this.dispatch(deleteIssues(issuesOfIssueType.map((issue) => issue.offline_id)));
     const promise = this.enqueueRequest({
@@ -5347,7 +5381,7 @@ class ProjectAttachmentService extends BaseAttachmentService {
     __publicField(this, "removeAttachments", deleteProjectAttachments);
     __publicField(this, "removeAttachment", deleteProjectAttachment);
     __publicField(this, "setAttachment", setProjectAttachment);
-    __publicField(this, "selectAttachment", selectProjectAttachment);
+    __publicField(this, "selectAttachment", selectProjectAttachmentById);
   }
   buildOfflineAttachment(data) {
     return offline({
@@ -5418,7 +5452,7 @@ class ProjectService extends BaseApiService {
   async delete(projectId) {
     const { store } = this.client;
     const state = store.getState();
-    const projects = selectProjects(state);
+    const projects = selectProjectMapping(state);
     const project = projects[projectId];
     if (!project) {
       throw new Error("Expected project to exist");
@@ -5672,10 +5706,6 @@ class FormService extends BaseUploadService {
     const offlineRevision = offline(revision);
     const { store } = this.client;
     const state = store.getState();
-    const activeProjectId = state.projectReducer.activeProjectId;
-    if (!activeProjectId) {
-      throw new Error("Cannot create form revision when there is no active project.");
-    }
     const currentUserId = state.userReducer.currentUser.id;
     const { fields, images } = await separateImageFromFields(offlineRevision.fields);
     const fullRevision = {
@@ -5714,10 +5744,9 @@ class FormService extends BaseUploadService {
     });
     return [fullRevision, offlineFormRevisionAttachments, promise, attachmentsPromise];
   }
-  async favorite(formId) {
+  async favorite(formId, projectId) {
     const { store } = this.client;
     const state = store.getState();
-    const activeProjectId = state.projectReducer.activeProjectId;
     const form = state.formReducer.instances[formId];
     if (!form) {
       throw new Error(`Expected form to exist, got ${form}`);
@@ -5727,7 +5756,7 @@ class FormService extends BaseUploadService {
       await this.enqueueRequest({
         description: "Favorite form",
         method: HttpMethod.POST,
-        url: `/forms/${formId}/favorite/${activeProjectId}/`,
+        url: `/forms/${formId}/favorite/${projectId}/`,
         blockers: [formId, `favorite-${formId}`],
         blocks: [`favorite-${formId}`]
       });
@@ -5736,10 +5765,9 @@ class FormService extends BaseUploadService {
       throw e;
     }
   }
-  async unfavorite(formId) {
+  async unfavorite(formId, projectId) {
     const { store } = this.client;
     const state = store.getState();
-    const activeProjectId = state.projectReducer.activeProjectId;
     const form = state.formReducer.instances[formId];
     if (!form) {
       throw new Error(`Expected form to exist, got ${form}`);
@@ -5749,7 +5777,7 @@ class FormService extends BaseUploadService {
       return await this.enqueueRequest({
         description: "Unfavorite form",
         method: HttpMethod.DELETE,
-        url: `/forms/${formId}/unfavorite/${activeProjectId}/`,
+        url: `/forms/${formId}/unfavorite/${projectId}/`,
         blockers: [formId, `favorite-${formId}`],
         blocks: [`favorite-${formId}`]
       });
@@ -5761,16 +5789,16 @@ class FormService extends BaseUploadService {
   async delete(formId) {
     const { store } = this.client;
     const state = store.getState();
-    const form = selectForm(formId)(state);
+    const form = selectFormById(formId)(state);
     if (!form) {
       throw new Error("Expected form to exist");
     }
     const formSubmissions = selectFormSubmissionsOfForm(formId)(state);
-    if (formSubmissions && formSubmissions.length > 0) {
+    if (formSubmissions.length > 0) {
       this.dispatch(deleteFormSubmissions(formSubmissions.map(({ offline_id }) => offline_id)));
     }
     const formRevisions = selectFormRevisionsOfForm(formId)(state);
-    if (formRevisions && formRevisions.length > 0) {
+    if (formRevisions.length > 0) {
       this.dispatch(deleteFormRevisions(formRevisions.map(({ offline_id }) => offline_id)));
     }
     this.dispatch(deleteForm(formId));
@@ -5784,10 +5812,10 @@ class FormService extends BaseUploadService {
       });
     } catch (e) {
       this.dispatch(addForm(form));
-      if (formRevisions && formRevisions.length > 0) {
+      if (formRevisions.length > 0) {
         this.dispatch(addFormRevisions(formRevisions));
       }
-      if (formSubmissions && formSubmissions.length > 0) {
+      if (formSubmissions.length > 0) {
         this.dispatch(addFormSubmissions(formSubmissions));
       }
       throw e;
@@ -5938,14 +5966,29 @@ class FormSubmissionService extends BaseUploadService {
     });
     return [offlineFormSubmissionAttachments, promise.then(({ attachments }) => attachments)];
   }
+  async bulkDeleteSubmissionAttachments(submissionId, attachmentsIds) {
+    const { store } = this.client;
+    const state = store.getState();
+    const formSubmissionAttachments = selectFormSubmissionAttachemntsByIds(attachmentsIds)(state);
+    this.dispatch(deleteFormSubmissionAttachments(attachmentsIds));
+    try {
+      await this.enqueueRequest({
+        description: "Delete form submission attachments",
+        method: HttpMethod.DELETE,
+        url: `/forms/submissions/${submissionId}/attachments/bulk/`,
+        payload: { attachments: attachmentsIds },
+        blockers: [submissionId, ...attachmentsIds],
+        blocks: []
+      });
+    } catch (e) {
+      this.dispatch(addFormSubmissionAttachments(formSubmissionAttachments));
+      throw e;
+    }
+  }
   // Outer promise is for hashing and caching files for submission attachments
   async add(payload) {
     const { store } = this.client;
     const state = store.getState();
-    const activeProjectId = state.projectReducer.activeProjectId;
-    if (!activeProjectId) {
-      throw new Error("Expected an active project");
-    }
     const { values, files } = separateFilesFromValues(payload.values);
     const offlineSubmission = offline({
       ...payload,
@@ -5957,7 +6000,7 @@ class FormSubmissionService extends BaseUploadService {
       description: "Respond to form",
       method: HttpMethod.POST,
       url: `/forms/revisions/${payload.form_revision}/respond/`,
-      payload: { ...offlineSubmission, project: activeProjectId },
+      payload: offlineSubmission,
       blockers: [payload.issue, payload.asset, payload.asset_stage, "add-form-entry"].filter(
         (x) => x !== void 0
       ),
@@ -6077,10 +6120,64 @@ class FormSubmissionService extends BaseUploadService {
     });
     return batchPromises;
   }
+  async update(payload) {
+    const { store } = this.client;
+    const state = store.getState();
+    const submissionToBeUpdated = selectFormSubmissionById(payload.offline_id)(state);
+    if (!submissionToBeUpdated) {
+      throw new Error(`Expected submission with offline_id ${payload.offline_id} to exist`);
+    }
+    const { values, files } = separateFilesFromValues(payload.values ?? {});
+    const updatedSubmission = {
+      ...submissionToBeUpdated,
+      ...payload,
+      // values could also have a partial update
+      values: {
+        ...submissionToBeUpdated.values,
+        ...values
+      }
+    };
+    this.dispatch(updateFormSubmission(updatedSubmission));
+    const promise = this.enqueueRequest({
+      description: "Delete user form submissions",
+      method: HttpMethod.PATCH,
+      url: `/forms/submissions/${updatedSubmission.offline_id}/`,
+      payload: updatedSubmission,
+      blockers: [updatedSubmission.offline_id],
+      blocks: [updatedSubmission.offline_id]
+    });
+    const formSubmissionAttachments = selectAttachmentsOfFormSubmission(payload.offline_id)(state);
+    const formSubmissionAttachmentIdsToBeDeleted = [];
+    for (const attachment of formSubmissionAttachments) {
+      if (attachment.field_identifier in files) {
+        formSubmissionAttachmentIdsToBeDeleted.push(attachment.offline_id);
+      }
+    }
+    const [offlineFormSubmissionAttachments, attachmentsPromise] = await this.bulkAddSubmissionAttachments(
+      payload.offline_id,
+      files
+    );
+    const deleteAttachmentsPromise = this.bulkDeleteSubmissionAttachments(
+      payload.offline_id,
+      formSubmissionAttachmentIdsToBeDeleted
+    );
+    promise.then((result) => {
+      this.dispatch(setFormSubmission(result));
+    }).catch(() => {
+      this.dispatch(setFormSubmission(submissionToBeUpdated));
+    });
+    return [
+      updatedSubmission,
+      offlineFormSubmissionAttachments,
+      promise,
+      attachmentsPromise,
+      deleteAttachmentsPromise
+    ];
+  }
   async delete(submissionId) {
     const { store } = this.client;
     const state = store.getState();
-    const submissionToBeDeleted = selectFormSubmission(submissionId)(store.getState());
+    const submissionToBeDeleted = selectFormSubmissionById(submissionId)(state);
     if (!submissionToBeDeleted) {
       throw new Error(`Expected submission with offline_id ${submissionId} to exist`);
     }
@@ -6124,13 +6221,12 @@ class FormSubmissionService extends BaseUploadService {
 }
 class WorkspaceService extends BaseApiService {
   add(workspace) {
-    const { store } = this.client;
     const offlineWorkspace = offline(workspace);
     this.dispatch(addWorkspace(offlineWorkspace));
     const promise = this.enqueueRequest({
       description: "Create Workspace",
       method: HttpMethod.POST,
-      url: `/projects/${store.getState().projectReducer.activeProjectId}/workspaces/`,
+      url: `/projects/${workspace.project}/workspaces/`,
       payload: offlineWorkspace,
       blockers: ["add-workspace"],
       blocks: [offlineWorkspace.offline_id]
@@ -6665,27 +6761,20 @@ class LicenseService extends BaseApiService {
   }
 }
 class DocumentService extends BaseApiService {
-  // TODO: Support adding for project or organization
-  add(document2) {
+  add(payload) {
     const { store } = this.client;
     const currentUserId = store.getState().userReducer.currentUser.id;
-    const activeProjectId = store.getState().projectReducer.activeProjectId;
-    if (!activeProjectId) {
-      throw new Error("No active project ID while creating document.");
-    }
-    const offlineDocument = offline(document2);
-    const submittedDocument = {
-      ...offlineDocument,
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const offlineDocument = offline({
+      ...payload,
       created_by: currentUserId,
-      project: activeProjectId,
-      organization: null,
-      children_documents: []
-    };
-    this.dispatch(addDocuments([submittedDocument]));
+      submitted_at: submittedAt
+    });
+    this.dispatch(addDocuments([offlineDocument]));
     const promise = this.enqueueRequest({
       description: "Create Document",
       method: HttpMethod.POST,
-      url: `/projects/${activeProjectId}/documents/`,
+      url: "/documents/",
       payload: offlineDocument,
       queryParams: {
         parent_document: offlineDocument.parent_document ?? void 0
@@ -6697,7 +6786,7 @@ class DocumentService extends BaseApiService {
     promise.catch(() => {
       this.dispatch(removeDocuments([offlineDocument.offline_id]));
     });
-    return [submittedDocument, promise];
+    return [offlineDocument, promise];
   }
   update(document2) {
     const { store } = this.client;
@@ -6824,7 +6913,7 @@ class DocumentAttachmentService extends BaseAttachmentService {
     __publicField(this, "removeAttachments", deleteDocumentAttachments);
     __publicField(this, "removeAttachment", deleteDocumentAttachment);
     __publicField(this, "setAttachment", setDocumentAttachment);
-    __publicField(this, "selectAttachment", selectDocumentAttachment);
+    __publicField(this, "selectAttachment", selectDocumentAttachmentById);
   }
   buildOfflineAttachment(data) {
     return offline({
@@ -6838,12 +6927,107 @@ class DocumentAttachmentService extends BaseAttachmentService {
       document: data.modelId
     });
   }
+  // NOTE: overriding the method from BaseAttachmentService since document attachments get vectorized
   async attachFilesToDocument(files, documentId) {
-    return this.attachFiles(files, documentId, this.buildOfflineAttachment.bind(this));
+    const { store } = this.client;
+    const currentUser = store.getState().userReducer.currentUser;
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const offlineAttachments = [];
+    const attachmentPayloads = [];
+    const filePayloads = {};
+    const sha1ToAttachmentIds = {};
+    for (const file of files) {
+      const sha1 = await hashFile(file);
+      if (!(sha1 in filePayloads)) {
+        filePayloads[sha1] = {
+          sha1,
+          file_type: file.type,
+          extension: file.name.split(".").pop(),
+          size: file.size
+        };
+        sha1ToAttachmentIds[sha1] = [];
+        await this.client.files.addCache(file, sha1);
+      }
+      const offlineAttachment = this.buildOfflineAttachment({
+        file,
+        sha1,
+        submittedAt,
+        createdBy: currentUser.id,
+        description: "",
+        modelId: documentId
+      });
+      offlineAttachments.push(offlineAttachment);
+      attachmentPayloads.push({
+        offline_id: offlineAttachment.offline_id,
+        name: offlineAttachment.file_name,
+        sha1: offlineAttachment.file_sha1,
+        description: offlineAttachment.description
+      });
+      sha1ToAttachmentIds[sha1].push(offlineAttachment.offline_id);
+    }
+    this.dispatch(this.addAttachments(offlineAttachments));
+    const promise = this.enqueueRequest({
+      description: "Attach files to document",
+      method: HttpMethod.POST,
+      url: `/documents/${documentId}/attach/`,
+      payload: {
+        submitted_at: submittedAt,
+        attachments: attachmentPayloads,
+        files: Object.values(filePayloads)
+      },
+      blocks: offlineAttachments.map((attachment) => attachment.offline_id),
+      blockers: offlineAttachments.map((attachment) => attachment.file_sha1)
+    });
+    promise.then(({ attachments, presigned_urls }) => {
+      this.dispatch(this.updateAttachments(attachments));
+      const promisesBySha1 = this.processPresignedUrls(presigned_urls);
+      for (const [sha1, promise2] of Object.entries(promisesBySha1)) {
+        void promise2.then(() => {
+          const attachmentIds = sha1ToAttachmentIds[sha1];
+          for (const attachmentId of attachmentIds) {
+            this.makeReadable(attachmentId);
+          }
+        });
+      }
+    }).catch(() => {
+      this.dispatch(this.removeAttachments(offlineAttachments.map((attachment) => attachment.offline_id)));
+    });
+    return [offlineAttachments, promise.then(({ attachments }) => attachments)];
   }
   async deleteDocumentAttachment(attachmentId) {
     return this.deleteAttachment(attachmentId);
   }
+  makeReadable(attachmnentId) {
+    void this.enqueueRequest({
+      description: "Add attachment to AI assistant",
+      method: HttpMethod.PATCH,
+      url: `/document-attachments/${attachmnentId}/`,
+      payload: {
+        readable_to_assistant: true
+      },
+      // passing through "index-document-attachment" so at most one document attachment being indexed at a time
+      blockers: ["index-document-attachment", attachmnentId],
+      blocks: ["index-document-attachment"]
+    });
+  }
+  async refreshStore(projectId, organizationId) {
+    const projectDocumentAttachments = await this.enqueueRequest({
+      description: "Get document attachments",
+      method: HttpMethod.GET,
+      url: `/projects/${projectId}/document-attachments/`,
+      blocks: [],
+      blockers: []
+    });
+    this.dispatch(this.initializeAttachments(projectDocumentAttachments));
+    const organizationDocumentAttachments = await this.enqueueRequest({
+      description: "Get document attachments",
+      method: HttpMethod.GET,
+      url: `/organizations/${organizationId}/document-attachments/`,
+      blocks: [],
+      blockers: []
+    });
+    this.dispatch(this.addAttachments(organizationDocumentAttachments));
+  }
 }
 class AgentService extends BaseApiService {
   async startConversation(prompt) {
@@ -6959,7 +7143,7 @@ class TeamService extends BaseApiService {
   // TODO: @Audiopolis / Magnus - should we pass a offline_id as one arg and a UpdatedTeamProps as a second arg instead of this set up?
   update(team) {
     const { store } = this.client;
-    const teamToBeUpdated = selectTeam(team.offline_id)(store.getState());
+    const teamToBeUpdated = selectTeamById(team.offline_id)(store.getState());
     if (!teamToBeUpdated) {
       throw new Error(`Expected team with offline_id ${team.offline_id} to exist`);
     }
@@ -6986,7 +7170,7 @@ class TeamService extends BaseApiService {
   async delete(teamId) {
     const { store } = this.client;
     const state = store.getState();
-    const team = selectTeam(teamId)(state);
+    const team = selectTeamById(teamId)(state);
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7006,7 +7190,7 @@ class TeamService extends BaseApiService {
   }
   async setMembers(teamId, members) {
     const { store } = this.client;
-    const team = selectTeam(teamId)(store.getState());
+    const team = selectTeamById(teamId)(store.getState());
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7031,7 +7215,7 @@ class TeamService extends BaseApiService {
   }
   async addMembers(teamId, members) {
     const { store } = this.client;
-    const team = selectTeam(teamId)(store.getState());
+    const team = selectTeamById(teamId)(store.getState());
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7040,7 +7224,7 @@ class TeamService extends BaseApiService {
   }
   async removeMembers(teamId, members) {
     const { store } = this.client;
-    const team = selectTeam(teamId)(store.getState());
+    const team = selectTeamById(teamId)(store.getState());
     if (!team) {
       throw new Error(`Expected team with id ${teamId} to exist`);
     }
@@ -7257,6 +7441,72 @@ class GeoImageService extends BaseUploadService {
     store.dispatch(initializeGeoImages(result));
   }
 }
+class IssueAssociationService extends BaseUploadService {
+  add(payload) {
+    const { store } = this.client;
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const createdBy = store.getState().userReducer.currentUser.id;
+    const offlineIssueAssociation = offline({
+      ...payload,
+      submitted_at: submittedAt,
+      created_by: createdBy
+    });
+    this.dispatch(addIssueAssociation(offlineIssueAssociation));
+    const promise = this.enqueueRequest({
+      description: "Add issue association",
+      method: HttpMethod.POST,
+      url: "/issues/associations/",
+      payload: {
+        offline_id: offlineIssueAssociation.offline_id,
+        submitted_at: submittedAt,
+        created_by: createdBy,
+        ...payload
+      },
+      blockers: [
+        payload.associated_issue,
+        ...payload.issue ? [payload.issue] : [],
+        ...payload.asset ? [payload.asset] : []
+      ],
+      blocks: [offlineIssueAssociation.offline_id]
+    });
+    promise.then((issueAssociation) => {
+      this.dispatch(updateIssueAssociation(issueAssociation));
+    }).catch(() => {
+      this.dispatch(deleteIssueAssociation(offlineIssueAssociation.offline_id));
+    });
+    return [offlineIssueAssociation, promise];
+  }
+  async delete(id) {
+    const { store } = this.client;
+    const issueAssociation = selectIssueAssociationById(id)(store.getState());
+    if (!issueAssociation) {
+      throw new Error(`Issue association with id ${id} not found in store.`);
+    }
+    this.dispatch(deleteIssueAssociation(id));
+    const promise = this.enqueueRequest({
+      description: "Delete issue association",
+      method: HttpMethod.DELETE,
+      url: `/issues/associations/${id}/`,
+      blockers: [id],
+      blocks: []
+    });
+    promise.catch(() => {
+      this.dispatch(addIssueAssociation(issueAssociation));
+    });
+    return promise;
+  }
+  async refreshStore(projectId) {
+    const issueAssociations = await this.enqueueRequest({
+      description: "Fetch issue associations",
+      method: HttpMethod.GET,
+      url: "/issues/associations/",
+      queryParams: { project_id: projectId.toString() },
+      blockers: [],
+      blocks: []
+    });
+    this.dispatch(initializeIssueAssociations(issueAssociations));
+  }
+}
 export {
   APIError,
   AgentService,
@@ -7285,6 +7535,7 @@ export {
   GREEN,
   GeoImageService,
   HttpMethod,
+  IssueAssociationService,
   IssueAttachmentService,
   IssueCommentService,
   IssuePriority,
@@ -7346,6 +7597,8 @@ export {
   addGeoImage,
   addGeoImages,
   addIssue,
+  addIssueAssociation,
+  addIssueAssociations,
   addIssueAttachment,
   addIssueAttachments,
   addIssueComment,
@@ -7423,6 +7676,8 @@ export {
   deleteGeoImage,
   deleteGeoImages,
   deleteIssue,
+  deleteIssueAssociation,
+  deleteIssueAssociations,
   deleteIssueAttachment,
   deleteIssueAttachments,
   deleteIssueComment,
@@ -7495,6 +7750,7 @@ export {
   initializeFormSubmissions,
   initializeForms,
   initializeGeoImages,
+  initializeIssueAssociations,
   initializeIssueAttachments,
   initializeIssueTypes,
   initializeIssueUpdates,
@@ -7507,6 +7763,8 @@ export {
   initializeTeams,
   initializeWorkspaces,
   isToday,
+  issueAssociationReducer,
+  issueAssociationSlice,
   issueAttachmentReducer,
   issueAttachmentSlice,
   issueCommentReducer,
@@ -7569,7 +7827,6 @@ export {
   saveActiveProjectFileBounds,
   searchIssues,
   selectAccessToken,
-  selectActiveLicense,
   selectActiveOrganizationAccess,
   selectActiveProject,
   selectActiveProjectAccess,
@@ -7579,21 +7836,24 @@ export {
   selectAllDocumentAttachments,
   selectAllProjectAttachments,
   selectAncestorIdsOfDocument,
-  selectAsset,
-  selectAssetAttachment,
+  selectAssetAttachmentById,
   selectAssetAttachmentMapping,
   selectAssetAttachments,
+  selectAssetById,
+  selectAssetStageById,
+  selectAssetStages,
+  selectAssetStagesByIds,
   selectAssetToAssetTypeMapping,
-  selectAssetType,
-  selectAssetTypeAttachment,
+  selectAssetTypeAttachmentById,
   selectAssetTypeAttachmentMapping,
   selectAssetTypeAttachments,
+  selectAssetTypeById,
   selectAssetTypeStagesMapping,
   selectAssetTypes,
-  selectAssetTypesByName,
-  selectAssetTypesFromIds,
+  selectAssetTypesByIds,
   selectAssetTypesMapping,
   selectAssets,
+  selectAssetsByIds,
   selectAssetsMapping,
   selectAssetsOfAssetType,
   selectAttachedFormSubmissionsOfAsset,
@@ -7623,27 +7883,29 @@ export {
   selectConversations,
   selectCurrentUser,
   selectDeletedRequests,
-  selectDocument,
-  selectDocumentAttachment,
+  selectDocumentAttachmentById,
   selectDocumentAttachmentMapping,
+  selectDocumentById,
   selectDocuments,
+  selectDocumentsByIds,
   selectDocumentsMapping,
   selectEmailDomains,
   selectEmailDomainsAsMapping,
   selectEmailDomainsOfOrganization,
   selectFavouriteProjects,
   selectFilteredForms,
-  selectForm,
+  selectFormById,
   selectFormMapping,
   selectFormOfAssetType,
   selectFormOfIssueType,
-  selectFormRevision,
   selectFormRevisionAttachmentsMapping,
+  selectFormRevisionById,
   selectFormRevisionMapping,
   selectFormRevisions,
   selectFormRevisionsOfForm,
-  selectFormSubmission,
+  selectFormSubmissionAttachemntsByIds,
   selectFormSubmissionAttachmentsMapping,
+  selectFormSubmissionById,
   selectFormSubmissions,
   selectFormSubmissionsByAssets,
   selectFormSubmissionsByFormRevisions,
@@ -7652,34 +7914,40 @@ export {
   selectFormSubmissionsOfAsset,
   selectFormSubmissionsOfForm,
   selectFormSubmissionsOfIssue,
+  selectForms,
   selectFormsCount,
-  selectFormsMapping,
   selectGeneralFormCount,
   selectGeoImageById,
   selectGeoImageMapping,
   selectGeoImages,
   selectGeoImagesOfProject,
-  selectIsFetchingInitialData,
   selectIsImportingProjectFile,
   selectIsLoggedIn,
-  selectIssue,
-  selectIssueAttachment,
+  selectIssueAssociationById,
+  selectIssueAssociationMapping,
+  selectIssueAssociations,
+  selectIssueAssociationsOfAsset,
+  selectIssueAssociationsOfIssue,
+  selectIssueAssociationsToIssue,
+  selectIssueAttachmentById,
   selectIssueAttachmentMapping,
   selectIssueAttachments,
+  selectIssueById,
   selectIssueCommentMapping,
   selectIssueCountOfCategory,
   selectIssueMapping,
-  selectIssueType,
+  selectIssueTypeById,
   selectIssueTypeMapping,
   selectIssueTypes,
+  selectIssueTypesByIds,
   selectIssueTypesOfOrganization,
   selectIssueUpdateMapping,
   selectIssueUpdatesOfIssue,
+  selectIssuesByIds,
   selectIssuesOfIssueType,
   selectIssuesOfIssueTypeCount,
   selectLatestFormRevisionByForm,
   selectLatestFormRevisionOfForm,
-  selectLatestFormRevisionsOfAssetTypes,
   selectLatestRetryTime,
   selectLicense,
   selectLicenseForProject,
@@ -7687,10 +7955,8 @@ export {
   selectLicensesForProjectsMapping,
   selectLicensesOfOrganization,
   selectMainWorkspace,
-  selectNumberOfAssetTypesMatchingCaseInsensitiveName,
   selectNumberOfAssetsOfAssetType,
-  selectOrganization,
-  selectOrganizationAccess,
+  selectOrganizationAccessById,
   selectOrganizationAccessForUser,
   selectOrganizationAccessUserMapping,
   selectOrganizationAccesses,
@@ -7701,20 +7967,20 @@ export {
   selectOrganizationsMapping,
   selectOrganizationsWithAccess,
   selectPermittedWorkspaceIds,
-  selectProject,
-  selectProjectAccess,
+  selectProjectAccessById,
   selectProjectAccessForUser,
   selectProjectAccessMapping,
   selectProjectAccessUserMapping,
   selectProjectAccesses,
-  selectProjectAttachment,
+  selectProjectAttachmentById,
   selectProjectAttachmentMapping,
+  selectProjectById,
   selectProjectFileById,
   selectProjectFileMapping,
   selectProjectFiles,
+  selectProjectMapping,
   selectProjectUsersAsMapping,
   selectProjectUsersIds,
-  selectProjects,
   selectProjectsOfOrganization,
   selectProjectsWithAccess,
   selectRecentIssueIds,
@@ -7724,22 +7990,19 @@ export {
   selectSortedFormSubmissionsOfForm,
   selectSortedOrganizationUsers,
   selectSortedProjectUsers,
-  selectStage,
   selectStageFormIdsFromStageIds,
   selectStageMapping,
-  selectStages,
   selectStagesFromAssetTypeIds,
-  selectStagesFromStageIds,
   selectStagesOfAssetType,
-  selectTeam,
+  selectTeamById,
   selectTeams,
   selectTeamsMapping,
   selectTeamsOfOrganization,
   selectTeamsOfUser,
   selectUploadUrl,
-  selectUser,
-  selectUsersAsMapping,
+  selectUserById,
   selectUsersByIds,
+  selectUsersMapping,
   selectWorkspaceById,
   selectWorkspaceMapping,
   selectWorkspaces,
@@ -7766,8 +8029,9 @@ export {
   setFormSubmissions,
   setGeoImage,
   setGeoImages,
-  setIsFetchingInitialData,
   setIsImportingProjectFile,
+  setIssueAssociation,
+  setIssueAssociations,
   setIssueAttachment,
   setIssueAttachments,
   setIssueComment,
@@ -7789,8 +8053,6 @@ export {
   setUploadUrl,
   setUsers,
   setWorkspaces,
-  settingReducer,
-  settingSlice,
   shallowEqual,
   slugify,
   spacesToDashesLower,
@@ -7821,6 +8083,8 @@ export {
   updateGeoImage,
   updateGeoImages,
   updateIssue,
+  updateIssueAssociation,
+  updateIssueAssociations,
   updateIssueAttachment,
   updateIssueAttachments,
   updateIssueType,