@overmap-ai/core 1.0.53-add-agent-sdk.0 → 1.0.53-attachment-creation-flows.0

package/dist/overmap-core.umd.cjs

@@ -1567,6 +1567,9 @@ var __publicField = (obj, key, value) => {
     return Object.values(state.issueReducer.issues).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) {
@@ -1591,6 +1594,15 @@ var __publicField = (obj, key, value) => {
       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];
@@ -1624,12 +1636,6 @@ var __publicField = (obj, key, value) => {
         state.components = toOfflineIdRecord(action.payload);
         prevComponents = null;
       },
-      setComponentAttachments: setAttachments,
-      addComponentAttachment: addAttachment,
-      addComponentAttachments: addAttachments,
-      updateComponentAttachment: updateAttachment,
-      removeComponentAttachment: removeAttachment,
-      removeComponentAttachments: removeAttachments,
       updateComponent: (state, action) => {
         if (action.payload.offline_id in state.components) {
           state.components[action.payload.offline_id] = action.payload;
@@ -1654,9 +1660,35 @@ var __publicField = (obj, key, value) => {
           }
         }
         prevComponents = null;
-      }
+      },
+      // Attachments
+      setComponentAttachment: setAttachment,
+      setComponentAttachments: setAttachments,
+      addComponentAttachment: addAttachment,
+      addComponentAttachments: addAttachments,
+      updateComponentAttachment: updateAttachment,
+      updateComponentAttachments: updateAttachments,
+      removeComponentAttachment: removeAttachment,
+      removeComponentAttachments: removeAttachments
     }
   });
+  const {
+    addComponent,
+    updateComponent,
+    removeComponent,
+    addComponentsInBatches,
+    setComponents,
+    removeAllComponentsOfType,
+    // Attachments
+    setComponentAttachment,
+    setComponentAttachments,
+    addComponentAttachment,
+    addComponentAttachments,
+    updateComponentAttachment,
+    updateComponentAttachments,
+    removeComponentAttachment,
+    removeComponentAttachments
+  } = componentSlice.actions;
   let prevComponents = null;
   const selectComponents = (state) => {
     if (!prevComponents) {
@@ -1751,20 +1783,6 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const {
-    addComponent,
-    updateComponent,
-    removeComponent,
-    addComponentsInBatches,
-    setComponents,
-    setComponentAttachments,
-    addComponentAttachment,
-    addComponentAttachments,
-    updateComponentAttachment,
-    removeComponentAttachment,
-    removeComponentAttachments,
-    removeAllComponentsOfType
-  } = componentSlice.actions;
   const componentReducer = componentSlice.reducer;
   const initialState$o = {
     completionsByComponentId: {}
@@ -1955,20 +1973,38 @@ var __publicField = (obj, key, value) => {
       setComponentTypes: (state, action) => {
         state.componentTypes = toOfflineIdRecord(action.payload);
       },
-      setComponentTypeAttachments: setAttachments,
-      addComponentTypeAttachment: addAttachment,
-      addComponentTypeAttachments: addAttachments,
-      updateComponentTypeAttachment: updateAttachment,
-      removeComponentTypeAttachment: removeAttachment,
-      removeComponentTypeAttachments: removeAttachments,
       toggleComponentTypeVisibility: (state, action) => {
         state.hiddenComponentTypeIds[action.payload] = !state.hiddenComponentTypeIds[action.payload];
       },
       deleteComponentType: (state, action) => {
         delete state.componentTypes[action.payload];
-      }
+      },
+      // Attachments
+      setComponentTypeAttachment: setAttachment,
+      setComponentTypeAttachments: setAttachments,
+      addComponentTypeAttachment: addAttachment,
+      addComponentTypeAttachments: addAttachments,
+      updateComponentTypeAttachment: updateAttachment,
+      updateComponentTypeAttachments: updateAttachments,
+      removeComponentTypeAttachment: removeAttachment,
+      removeComponentTypeAttachments: removeAttachments
     }
   });
+  const {
+    addComponentType,
+    setComponentTypes,
+    toggleComponentTypeVisibility,
+    deleteComponentType,
+    // Attachmet
+    setComponentTypeAttachment,
+    setComponentTypeAttachments,
+    addComponentTypeAttachment,
+    addComponentTypeAttachments,
+    updateComponentTypeAttachment,
+    updateComponentTypeAttachments,
+    removeComponentTypeAttachment,
+    removeComponentTypeAttachments
+  } = componentTypeSlice.actions;
   const selectComponentTypesMapping = (state) => state.componentTypeReducer.componentTypes;
   const selectComponentTypes = toolkit.createSelector(
     [selectComponentTypesMapping],
@@ -2045,18 +2081,6 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const {
-    addComponentType,
-    setComponentTypes,
-    setComponentTypeAttachments,
-    addComponentTypeAttachment,
-    addComponentTypeAttachments,
-    updateComponentTypeAttachment,
-    removeComponentTypeAttachment,
-    removeComponentTypeAttachments,
-    toggleComponentTypeVisibility,
-    deleteComponentType
-  } = componentTypeSlice.actions;
   const componentTypeReducer = componentTypeSlice.reducer;
   const initialState$l = {
     workspaces: {},
@@ -2146,7 +2170,6 @@ var __publicField = (obj, key, value) => {
           state.issues[issue.offline_id] = issue;
         });
       },
-      setIssueAttachments: setAttachments,
       setIssueUpdates: (state, action) => {
         if (action.payload.filter(onlyUniqueOfflineIds).length !== action.payload.length) {
           throw new Error("Tried to use setIssues reducer with duplicate ID's");
@@ -2176,8 +2199,6 @@ var __publicField = (obj, key, value) => {
           state.issues[issue.offline_id] = issue;
         }
       },
-      addIssueAttachment: addAttachment,
-      addIssueAttachments: addAttachments,
       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}`);
@@ -2199,7 +2220,6 @@ var __publicField = (obj, key, value) => {
           throw new Error(`Tried to update issue with ID that doesn't exist: ${action.payload.offline_id}`);
         }
       },
-      updateIssueAttachment: updateAttachment,
       removeIssue: (state, action) => {
         if (action.payload in state.issues) {
           delete state.issues[action.payload];
@@ -2212,7 +2232,6 @@ var __publicField = (obj, key, value) => {
           delete state.issues[issueId];
         }
       },
-      removeIssueAttachment: removeAttachment,
       removeIssueUpdate: (state, action) => {
         if (action.payload in state.updates) {
           delete state.updates[action.payload];
@@ -2309,12 +2328,19 @@ var __publicField = (obj, key, value) => {
         if (indexToRemove !== -1) {
           state.recentIssueIds.splice(indexToRemove, 1);
         }
-      }
+      },
+      // Attachments
+      setIssueAttachment: setAttachment,
+      setIssueAttachments: setAttachments,
+      addIssueAttachment: addAttachment,
+      addIssueAttachments: addAttachments,
+      updateIssueAttachment: updateAttachment,
+      updateIssueAttachments: updateAttachments,
+      removeIssueAttachment: removeAttachment,
+      removeIssueAttachments: removeAttachments
     }
   });
   const {
-    addIssueAttachment,
-    addIssueAttachments,
     addIssue,
     addIssues,
     addIssueUpdate,
@@ -2322,7 +2348,6 @@ var __publicField = (obj, key, value) => {
     addOrReplaceIssueComment,
     addToRecentIssues,
     cleanRecentIssues,
-    removeIssueAttachment,
     removeAttachmentsOfIssue,
     removeIssue,
     removeIssues,
@@ -2331,13 +2356,20 @@ var __publicField = (obj, key, value) => {
     removeRecentIssue,
     resetRecentIssues,
     setActiveIssueId,
-    setIssueAttachments,
     setIssueUpdates,
     setIssues,
     setVisibleStatuses,
     setVisibleUserIds,
-    updateIssueAttachment,
     updateIssue,
+    // Attachments
+    setIssueAttachment,
+    setIssueAttachments,
+    addIssueAttachment,
+    addIssueAttachments,
+    updateIssueAttachment,
+    updateIssueAttachments,
+    removeIssueAttachment,
+    removeIssueAttachments,
     // Commments
     addIssueComment,
     addIssueComments,
@@ -2706,6 +2738,14 @@ var __publicField = (obj, key, value) => {
     OrganizationAccessLevel2[OrganizationAccessLevel2["ADMIN"] = 2] = "ADMIN";
     return OrganizationAccessLevel2;
   })(OrganizationAccessLevel || {});
+  var AttachmentModel = /* @__PURE__ */ ((AttachmentModel2) => {
+    AttachmentModel2["Issue"] = "issue";
+    AttachmentModel2["Component"] = "component";
+    AttachmentModel2["ComponentType"] = "component_type";
+    AttachmentModel2["Project"] = "project";
+    AttachmentModel2["Document"] = "document";
+    return AttachmentModel2;
+  })(AttachmentModel || {});
   var IssueUpdateChange = /* @__PURE__ */ ((IssueUpdateChange2) => {
     IssueUpdateChange2["STATUS"] = "status";
     IssueUpdateChange2["PRIORITY"] = "priority";
@@ -3093,11 +3133,13 @@ var __publicField = (obj, key, value) => {
           throw new Error("Update form submissions count: no active project");
         }
       },
-      // Attachment related
+      // Attachments
+      setProjectAttachment: setAttachment,
       setProjectAttachments: setAttachments,
       addProjectAttachment: addAttachment,
       addProjectAttachments: addAttachments,
       updateProjectAttachment: updateAttachment,
+      updateProjectAttachments: updateAttachments,
       removeProjectAttachment: removeAttachment,
       removeProjectAttachments: removeAttachments
     }
@@ -3112,11 +3154,13 @@ var __publicField = (obj, key, value) => {
     acceptProjectInvite,
     addActiveProjectIssuesCount,
     addActiveProjectFormSubmissionsCount,
-    // Attachment related
+    // Attachments
+    setProjectAttachment,
     setProjectAttachments,
     addProjectAttachment,
     addProjectAttachments,
     updateProjectAttachment,
+    updateProjectAttachments,
     removeProjectAttachment,
     removeProjectAttachments
   } = projectSlice.actions;
@@ -3187,6 +3231,9 @@ var __publicField = (obj, key, value) => {
     [selectProjectAttachmentMapping],
     (mapping) => Object.values(mapping)
   );
+  const selectProjectAttachment = (attachmentId) => (state) => {
+    return state.projectReducer.attachments[attachmentId];
+  };
   const selectAttachmentsOfProject = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [selectAllProjectAttachments, (_state, projectId) => projectId],
@@ -4302,10 +4349,13 @@ var __publicField = (obj, key, value) => {
           delete state.documents[documentId];
         }
       },
+      // Attachments
+      setDocumentAttachment: setAttachment,
       setDocumentAttachments: setAttachments,
       addDocumentAttachment: addAttachment,
       addDocumentAttachments: addAttachments,
       updateDocumentAttachment: updateAttachment,
+      updateDocumentAttachments: updateAttachments,
       removeDocumentAttachment: removeAttachment,
       removeDocumentAttachments: removeAttachments
     }
@@ -4316,10 +4366,13 @@ var __publicField = (obj, key, value) => {
     updateDocuments,
     moveDocument,
     removeDocuments,
+    // Attachments
+    setDocumentAttachment,
     setDocumentAttachments,
     addDocumentAttachment,
     addDocumentAttachments,
     updateDocumentAttachment,
+    updateDocumentAttachments,
     removeDocumentAttachment,
     removeDocumentAttachments
   } = documentSlice.actions;
@@ -5009,553 +5062,6 @@ var __publicField = (obj, key, value) => {
       return promise;
     }
   }
-  class AttachmentService extends BaseApiService {
-    fetchAll(projectId) {
-      const promise = this.enqueueRequest({
-        description: "Fetch attachments",
-        method: HttpMethod.GET,
-        url: `/attachments/${projectId}/`,
-        blocks: [],
-        blockers: []
-      });
-      const state = this.client.store.getState();
-      const allAttachments = {
-        issue_attachments: Object.values(state.issueReducer.attachments),
-        component_attachments: Object.values(state.componentReducer.attachments),
-        component_type_attachments: Object.values(state.componentTypeReducer.attachments),
-        project_attachments: Object.values(state.projectReducer.attachments),
-        document_attachments: Object.values(state.documentsReducer.attachments)
-      };
-      return [allAttachments, promise];
-    }
-    // Attachments aren't models, so we use the OptimisticGenericResult type instead
-    async addIssueAttachment(attachmentPayload) {
-      const { issue, file_sha1, offline_id } = attachmentPayload;
-      if (!attachmentPayload.file.objectURL) {
-        throw new Error("Expected attachmentPayload.file.objectURL to be defined.");
-      }
-      const offlineAttachment = {
-        ...attachmentPayload,
-        file: attachmentPayload.file.objectURL,
-        file_name: attachmentPayload.file.name,
-        file_type: attachmentPayload.file.type,
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        created_by: this.client.store.getState().userReducer.currentUser.id
-      };
-      await this.client.files.addCache(attachmentPayload.file, file_sha1);
-      this.client.store.dispatch(addIssueAttachment(offlineAttachment));
-      const [fileProps] = await this.client.files.uploadFileToS3(file_sha1);
-      const promise = this.enqueueRequest({
-        description: "Create attachment",
-        method: HttpMethod.POST,
-        url: `/issues/${issue}/attach/`,
-        blocks: [offline_id, issue],
-        blockers: [file_sha1],
-        payload: {
-          ...offlineAttachment,
-          ...fileProps
-        }
-      });
-      promise.catch((error2) => {
-        this.client.store.dispatch(removeIssueAttachment(offlineAttachment.offline_id));
-        throw error2;
-      });
-      return [offlineAttachment, promise];
-    }
-    async addComponentAttachment(attachmentPayload) {
-      const { component, file_sha1, offline_id } = attachmentPayload;
-      if (!attachmentPayload.file.objectURL) {
-        throw new Error("Expected attachmentPayload.file.objectURL to be defined.");
-      }
-      const offlineAttachment = {
-        ...attachmentPayload,
-        file: attachmentPayload.file.objectURL,
-        file_name: attachmentPayload.file.name,
-        file_type: attachmentPayload.file.type,
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        created_by: this.client.store.getState().userReducer.currentUser.id
-      };
-      await this.client.files.addCache(attachmentPayload.file, file_sha1);
-      this.client.store.dispatch(addComponentAttachment(offlineAttachment));
-      const [fileProps] = await this.client.files.uploadFileToS3(file_sha1);
-      const promise = this.enqueueRequest({
-        description: "Create attachment",
-        method: HttpMethod.POST,
-        url: `/components/${component}/attach/`,
-        blocks: [offline_id, component],
-        blockers: [file_sha1],
-        payload: {
-          ...offlineAttachment,
-          ...fileProps
-        }
-      });
-      promise.catch((error2) => {
-        this.client.store.dispatch(removeComponentAttachment(offlineAttachment.offline_id));
-        throw error2;
-      });
-      return [offlineAttachment, promise];
-    }
-    async addComponentTypeAttachment(attachmentPayload) {
-      const { component_type, file_sha1, offline_id } = attachmentPayload;
-      if (!attachmentPayload.file.objectURL) {
-        throw new Error("Expected attachmentPayload.file.objectURL to be defined.");
-      }
-      const offlineAttachment = {
-        ...attachmentPayload,
-        file: attachmentPayload.file.objectURL,
-        file_name: attachmentPayload.file.name,
-        file_type: attachmentPayload.file.type,
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        created_by: this.client.store.getState().userReducer.currentUser.id
-      };
-      await this.client.files.addCache(attachmentPayload.file, file_sha1);
-      this.client.store.dispatch(addComponentTypeAttachment(offlineAttachment));
-      const [fileProps] = await this.client.files.uploadFileToS3(file_sha1);
-      const promise = this.enqueueRequest({
-        description: "Create attachment",
-        method: HttpMethod.POST,
-        url: `/components/types/${component_type}/attach/`,
-        blocks: [offline_id, component_type],
-        blockers: [file_sha1],
-        payload: {
-          ...offlineAttachment,
-          ...fileProps
-        }
-      });
-      promise.catch((error2) => {
-        this.client.store.dispatch(removeComponentTypeAttachment(offlineAttachment.offline_id));
-        throw error2;
-      });
-      return [offlineAttachment, promise];
-    }
-    async addDocumentAttachment(attachmentPayload) {
-      const { description: description2, document: document2, file_sha1, offline_id } = attachmentPayload;
-      if (!attachmentPayload.file.objectURL) {
-        throw new Error("Expected attachmentPayload.file.objectURL to be defined.");
-      }
-      const offlineAttachment = {
-        ...attachmentPayload,
-        file: attachmentPayload.file.objectURL,
-        file_name: attachmentPayload.file.name,
-        file_type: attachmentPayload.file.type,
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        created_by: this.client.store.getState().userReducer.currentUser.id
-      };
-      await this.client.files.addCache(attachmentPayload.file, file_sha1);
-      this.client.store.dispatch(addDocumentAttachment(offlineAttachment));
-      const [fileProps] = await this.client.files.uploadFileToS3(file_sha1);
-      const promise = this.enqueueRequest({
-        description: "Create attachment",
-        method: HttpMethod.POST,
-        url: `/documents/${document2}/attach/`,
-        blocks: [offline_id, document2],
-        blockers: [file_sha1],
-        payload: {
-          offline_id,
-          document: document2,
-          description: description2 ?? "",
-          submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-          ...fileProps
-        }
-      });
-      promise.catch((error2) => {
-        this.client.store.dispatch(removeDocumentAttachment(offlineAttachment.offline_id));
-        throw error2;
-      });
-      return [offlineAttachment, promise];
-    }
-    /** the outer Promise is needed to await the hashing of each file, which is required before offline use. If wanting to
-     * attach promise handlers to the request to add the attachment in the backend, apply it on the promise returned from the
-     * OptimisticModelResult. */
-    attachFilesToIssue(filesToSubmit, issueId) {
-      return filesToSubmit.map((file) => {
-        if (!(file instanceof File)) {
-          throw new Error("Expected a File instance.");
-        }
-        const photoAttachmentPromise = async (file2) => {
-          const hash = await hashFile(file2);
-          const attachment = offline({
-            file: file2,
-            file_name: file2.name,
-            file_type: file2.type,
-            issue: issueId,
-            file_sha1: hash,
-            submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-            created_by: this.client.store.getState().userReducer.currentUser.id
-          });
-          return this.addIssueAttachment(attachment);
-        };
-        return photoAttachmentPromise(file);
-      });
-    }
-    attachFilesToComponent(filesToSubmit, componentId) {
-      return filesToSubmit.map((file) => {
-        if (!(file instanceof File)) {
-          throw new Error("Expected a File instance.");
-        }
-        const photoAttachmentPromise = async (file2) => {
-          const hash = await hashFile(file2);
-          const attachment = offline({
-            file: file2,
-            file_name: file2.name,
-            file_type: file2.type,
-            component: componentId,
-            file_sha1: hash,
-            submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-            created_by: this.client.store.getState().userReducer.currentUser.id
-          });
-          return this.addComponentAttachment(attachment);
-        };
-        return photoAttachmentPromise(file);
-      });
-    }
-    attachFilesToComponentType(filesToSubmit, componentTypeId) {
-      return filesToSubmit.map((file) => {
-        if (!(file instanceof File)) {
-          throw new Error("Expected a File instance.");
-        }
-        const photoAttachmentPromise = async (file2) => {
-          const hash = await hashFile(file2);
-          const attachment = offline({
-            file: file2,
-            file_name: file2.name,
-            file_type: file2.type,
-            component_type: componentTypeId,
-            file_sha1: hash,
-            submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-            created_by: this.client.store.getState().userReducer.currentUser.id
-          });
-          return this.addComponentTypeAttachment(attachment);
-        };
-        return photoAttachmentPromise(file);
-      });
-    }
-    attachFilesToDocument(filesToSubmit, documentId) {
-      return filesToSubmit.map((file) => {
-        if (!(file instanceof File)) {
-          throw new Error("Expected a File instance.");
-        }
-        const photoAttachmentPromise = async (file2) => {
-          const hash = await hashFile(file2);
-          const attachment = offline({
-            file: file2,
-            file_name: file2.name,
-            file_type: file2.type,
-            document: documentId,
-            file_sha1: hash,
-            submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
-            created_by: this.client.store.getState().userReducer.currentUser.id
-          });
-          return this.addDocumentAttachment(attachment);
-        };
-        return photoAttachmentPromise(file);
-      });
-    }
-    async replaceIssueAttachmentFile(attachmentId, newFile) {
-      const { store } = this.client;
-      const attachment = store.getState().issueReducer.attachments[attachmentId];
-      if (!attachment)
-        throw new Error(`Attachment ${attachmentId} not found`);
-      let oldFile = void 0;
-      const newSha1 = await hashFile(newFile);
-      const performRequest2 = async () => {
-        oldFile = await this.client.files.fetchCache(attachment.file_sha1);
-        if (!oldFile) {
-          console.error(`Failed to fetch old file from cache for sha1 ${attachment.file_sha1}.`);
-        }
-        if (!newFile.objectURL) {
-          throw new Error(`newFile["objectURL"] is unexpectedly ${newFile.objectURL}`);
-        }
-        store.dispatch(
-          updateIssueAttachment({ ...attachment, file_sha1: newSha1, file: URL.createObjectURL(newFile) })
-        );
-        await this.client.files.addCache(newFile, newSha1);
-        const [fileProps] = await this.client.files.uploadFileToS3(newSha1).catch((e) => {
-          store.dispatch(updateIssueAttachment(attachment));
-          throw e;
-        });
-        const promise2 = this.enqueueRequest({
-          description: "Edit attachment",
-          method: HttpMethod.PATCH,
-          url: `/attachments/issues/${attachment.offline_id}/`,
-          isResponseBlob: false,
-          payload: fileProps,
-          blockers: [attachmentId, newSha1],
-          blocks: [attachmentId, newSha1]
-        });
-        try {
-          const result = await promise2;
-          void this.client.files.removeCache(attachment.file_sha1);
-          return result;
-        } catch (e) {
-          if (oldFile) {
-            store.dispatch(
-              updateIssueAttachment({
-                ...attachment,
-                file_sha1: attachment.file_sha1,
-                file: URL.createObjectURL(oldFile)
-              })
-            );
-          }
-          throw e;
-        }
-      };
-      const offlineAttachment = {
-        ...attachment,
-        file_sha1: newSha1,
-        file: URL.createObjectURL(newFile)
-      };
-      const promise = performRequest2();
-      return [offlineAttachment, promise];
-    }
-    async replaceComponentAttachmentFile(attachmentId, newFile) {
-      const { store } = this.client;
-      const attachment = store.getState().componentReducer.attachments[attachmentId];
-      if (!attachment)
-        throw new Error(`Attachment ${attachmentId} not found`);
-      let oldFile = void 0;
-      const newSha1 = await hashFile(newFile);
-      const performRequest2 = async () => {
-        oldFile = await this.client.files.fetchCache(attachment.file_sha1);
-        if (!oldFile) {
-          console.error(`Failed to fetch old file from cache for sha1 ${attachment.file_sha1}.`);
-        }
-        if (!newFile.objectURL) {
-          throw new Error(`newFile["objectURL"] is unexpectedly ${newFile.objectURL}`);
-        }
-        store.dispatch(
-          updateComponentAttachment({ ...attachment, file_sha1: newSha1, file: URL.createObjectURL(newFile) })
-        );
-        await this.client.files.addCache(newFile, newSha1);
-        const [fileProps] = await this.client.files.uploadFileToS3(newSha1).catch((e) => {
-          store.dispatch(updateComponentAttachment(attachment));
-          throw e;
-        });
-        const promise2 = this.enqueueRequest({
-          description: "Edit attachment",
-          method: HttpMethod.PATCH,
-          url: `/attachments/components/${attachment.offline_id}/`,
-          isResponseBlob: false,
-          payload: fileProps,
-          blockers: [attachmentId, newSha1],
-          blocks: [attachmentId, newSha1]
-        });
-        try {
-          const result = await promise2;
-          void this.client.files.removeCache(attachment.file_sha1);
-          return result;
-        } catch (e) {
-          if (oldFile) {
-            store.dispatch(
-              updateComponentAttachment({
-                ...attachment,
-                file_sha1: attachment.file_sha1,
-                file: URL.createObjectURL(oldFile)
-              })
-            );
-          }
-          throw e;
-        }
-      };
-      const offlineAttachment = {
-        ...attachment,
-        file_sha1: newSha1,
-        file: URL.createObjectURL(newFile)
-      };
-      const promise = performRequest2();
-      return [offlineAttachment, promise];
-    }
-    async replaceComponentTypeAttachmentFile(attachmentId, newFile) {
-      const { store } = this.client;
-      const attachment = store.getState().componentTypeReducer.attachments[attachmentId];
-      if (!attachment)
-        throw new Error(`Attachment ${attachmentId} not found`);
-      let oldFile = void 0;
-      const newSha1 = await hashFile(newFile);
-      const performRequest2 = async () => {
-        oldFile = await this.client.files.fetchCache(attachment.file_sha1);
-        if (!oldFile) {
-          console.error(`Failed to fetch old file from cache for sha1 ${attachment.file_sha1}.`);
-        }
-        if (!newFile.objectURL) {
-          throw new Error(`newFile["objectURL"] is unexpectedly ${newFile.objectURL}`);
-        }
-        store.dispatch(
-          updateComponentTypeAttachment({
-            ...attachment,
-            file_sha1: newSha1,
-            file: URL.createObjectURL(newFile)
-          })
-        );
-        await this.client.files.addCache(newFile, newSha1);
-        const [fileProps] = await this.client.files.uploadFileToS3(newSha1).catch((e) => {
-          store.dispatch(updateComponentTypeAttachment(attachment));
-          throw e;
-        });
-        const promise2 = this.enqueueRequest({
-          description: "Edit attachment",
-          method: HttpMethod.PATCH,
-          url: `/attachments/component_types/${attachment.offline_id}/`,
-          isResponseBlob: false,
-          payload: fileProps,
-          blockers: [attachmentId, newSha1],
-          blocks: [attachmentId, newSha1]
-        });
-        try {
-          const result = await promise2;
-          void this.client.files.removeCache(attachment.file_sha1);
-          return result;
-        } catch (e) {
-          if (oldFile) {
-            store.dispatch(
-              updateComponentTypeAttachment({
-                ...attachment,
-                file_sha1: attachment.file_sha1,
-                file: URL.createObjectURL(oldFile)
-              })
-            );
-          }
-          throw e;
-        }
-      };
-      const offlineAttachment = {
-        ...attachment,
-        file_sha1: newSha1,
-        file: URL.createObjectURL(newFile)
-      };
-      const promise = performRequest2();
-      return [offlineAttachment, promise];
-    }
-    async replaceDocumentAttachmentFile(attachmentId, newFile) {
-      const { store } = this.client;
-      const attachment = store.getState().documentsReducer.attachments[attachmentId];
-      if (!attachment)
-        throw new Error(`Attachment ${attachmentId} not found`);
-      let oldFile = void 0;
-      const newSha1 = await hashFile(newFile);
-      const performRequest2 = async () => {
-        oldFile = await this.client.files.fetchCache(attachment.file_sha1);
-        if (!oldFile) {
-          console.error(`Failed to fetch old file from cache for sha1 ${attachment.file_sha1}.`);
-        }
-        if (!newFile.objectURL) {
-          throw new Error(`newFile["objectURL"] is unexpectedly ${newFile.objectURL}`);
-        }
-        store.dispatch(
-          updateDocumentAttachment({
-            ...attachment,
-            file_sha1: newSha1,
-            file: URL.createObjectURL(newFile)
-          })
-        );
-        await this.client.files.addCache(newFile, newSha1);
-        const [fileProps] = await this.client.files.uploadFileToS3(newSha1).catch((e) => {
-          store.dispatch(updateDocumentAttachment(attachment));
-          throw e;
-        });
-        const promise2 = this.enqueueRequest({
-          description: "Edit attachment",
-          method: HttpMethod.PATCH,
-          url: `/attachments/documents/${attachment.offline_id}/`,
-          isResponseBlob: false,
-          payload: fileProps,
-          blockers: [attachmentId, newSha1],
-          blocks: [attachmentId, newSha1]
-        });
-        try {
-          const result = await promise2;
-          void this.client.files.removeCache(attachment.file_sha1);
-          return result;
-        } catch (e) {
-          if (oldFile) {
-            store.dispatch(
-              updateDocumentAttachment({
-                ...attachment,
-                file_sha1: attachment.file_sha1,
-                file: URL.createObjectURL(oldFile)
-              })
-            );
-          }
-          throw e;
-        }
-      };
-      const offlineAttachment = {
-        ...attachment,
-        file_sha1: newSha1,
-        file: URL.createObjectURL(newFile)
-      };
-      const promise = performRequest2();
-      return [offlineAttachment, promise];
-    }
-    /**
-     * Deletes an attachment and associated data in the cloud, in the Redux store and the cache.
-     * @param issueAttachmentId
-     */
-    deleteIssueAttachment(issueAttachmentId) {
-      const { store } = this.client;
-      const attachment = selectIssueAttachmentMapping(store.getState())[issueAttachmentId];
-      if (!attachment) {
-        throw new Error(`Attachment ${issueAttachmentId} not found`);
-      }
-      store.dispatch(removeIssueAttachment(issueAttachmentId));
-      void this.client.files.removeCache(attachment.file_sha1);
-      return this.enqueueRequest({
-        description: "Delete attachment",
-        method: HttpMethod.DELETE,
-        url: `/attachments/issues/${issueAttachmentId}/`,
-        blockers: [issueAttachmentId],
-        blocks: [issueAttachmentId]
-      });
-    }
-    deleteComponentAttachment(componentAttachmentId) {
-      const { store } = this.client;
-      const attachment = selectComponentAttachmentMapping(store.getState())[componentAttachmentId];
-      if (!attachment) {
-        throw new Error(`Attachment ${componentAttachmentId} not found`);
-      }
-      store.dispatch(removeComponentAttachment(componentAttachmentId));
-      void this.client.files.removeCache(attachment.file_sha1);
-      return this.enqueueRequest({
-        description: "Delete attachment",
-        method: HttpMethod.DELETE,
-        url: `/attachments/components/${componentAttachmentId}/`,
-        blockers: [componentAttachmentId],
-        blocks: [componentAttachmentId]
-      });
-    }
-    deleteComponentTypeAttachment(componentTypeAttachmentId) {
-      const { store } = this.client;
-      const attachment = selectComponentTypeAttachmentMapping(store.getState())[componentTypeAttachmentId];
-      if (!attachment) {
-        throw new Error(`Attachment ${componentTypeAttachmentId} not found`);
-      }
-      store.dispatch(removeComponentTypeAttachment(componentTypeAttachmentId));
-      void this.client.files.removeCache(attachment.file_sha1);
-      return this.enqueueRequest({
-        description: "Delete attachment",
-        method: HttpMethod.DELETE,
-        url: `/attachments/component_types/${componentTypeAttachmentId}/`,
-        blockers: [componentTypeAttachmentId],
-        blocks: [componentTypeAttachmentId]
-      });
-    }
-    deleteDocumentAttachment(documentAttachmentId) {
-      const { store } = this.client;
-      const attachment = store.getState().documentsReducer.attachments[documentAttachmentId];
-      if (!attachment) {
-        throw new Error(`Attachment ${documentAttachmentId} not found`);
-      }
-      store.dispatch(removeDocumentAttachment(documentAttachmentId));
-      void this.client.files.removeCache(attachment.file_sha1);
-      return this.enqueueRequest({
-        description: "Delete document attachment",
-        method: HttpMethod.DELETE,
-        url: `/attachments/documents/${documentAttachmentId}/`,
-        blockers: [documentAttachmentId],
-        blocks: [documentAttachmentId]
-      });
-    }
-  }
   const EXPIRING_SOON_THRESHOLD = 1800;
   function parseTokens(response) {
     if (!response.access)
@@ -6247,6 +5753,221 @@ var __publicField = (obj, key, value) => {
       store.dispatch(addStages(result));
     }
   }
+  const AttachmentModelMeta = {
+    [AttachmentModel.Issue]: {
+      name: "issue",
+      attachUrlPrefix: "/issues",
+      deleteUrlPrefix: "/issues",
+      fetchUrlPostfix: "/issue-attachments"
+    },
+    [AttachmentModel.Component]: {
+      name: "component",
+      attachUrlPrefix: "/components",
+      deleteUrlPrefix: "/components",
+      fetchUrlPostfix: "/component-attachments"
+    },
+    [AttachmentModel.ComponentType]: {
+      name: "component type",
+      attachUrlPrefix: "/components/types",
+      deleteUrlPrefix: "/components/types",
+      fetchUrlPostfix: "/component-type-attachments"
+    },
+    [AttachmentModel.Project]: {
+      name: "component project",
+      attachUrlPrefix: "/projects",
+      deleteUrlPrefix: "/projects",
+      fetchUrlPostfix: "/attachments"
+    },
+    [AttachmentModel.Document]: {
+      name: "document",
+      attachUrlPrefix: "/documents",
+      deleteUrlPrefix: "/documents",
+      fetchUrlPostfix: "/document-attachments"
+    }
+  };
+  class BaseAttachmentService extends BaseApiService {
+    getNumberOfAttachmentsWithSha1(sha1) {
+      const {
+        issueReducer: issueReducer2,
+        componentReducer: componentReducer2,
+        componentTypeReducer: componentTypeReducer2,
+        documentsReducer: documentsReducer2,
+        projectReducer: projectReducer2,
+        formSubmissionReducer: formSubmissionReducer2,
+        formRevisionReducer: formRevisionReducer2
+      } = this.client.store.getState();
+      const objectsWithSha1 = [].concat(
+        Object.values(issueReducer2.attachments),
+        Object.values(componentReducer2.attachments),
+        Object.values(componentTypeReducer2.attachments),
+        Object.values(documentsReducer2.attachments),
+        Object.values(projectReducer2.attachments),
+        Object.values(formRevisionReducer2.attachments),
+        Object.values(formSubmissionReducer2.attachments)
+      );
+      return objectsWithSha1.filter((object) => object.file_sha1 === sha1).length;
+    }
+    processPresignedUrls(presignedUrls) {
+      for (const [sha1, presignedUrl] of Object.entries(presignedUrls)) {
+        void this.enqueueRequest({
+          url: presignedUrl.url,
+          description: "Upload file to S3",
+          method: HttpMethod.POST,
+          isExternalUrl: true,
+          isAuthNeeded: false,
+          attachmentHash: sha1,
+          // TODO: can we use the sha1 as the blocker?
+          blockers: [`s3-${presignedUrl.fields.key}`],
+          blocks: [sha1],
+          s3url: presignedUrl
+        });
+      }
+    }
+    // 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.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) {
+      const { store } = this.client;
+      const currentUser = store.getState().userReducer.currentUser;
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const offlineAttachments = [];
+      const attachmentPayloads = [];
+      const filePayloads = {};
+      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
+          };
+          await this.client.files.addCache(file, sha1);
+        }
+        const offlineAttachment = buildOfflineAttachment({
+          file,
+          sha1,
+          submittedAt,
+          createdBy: currentUser.id,
+          description: "",
+          modelId
+        });
+        offlineAttachments.push(offlineAttachment);
+        attachmentPayloads.push({
+          offline_id: offlineAttachment.offline_id,
+          name: offlineAttachment.file_name,
+          sha1: offlineAttachment.file_sha1,
+          description: offlineAttachment.description
+        });
+      }
+      store.dispatch(actions.addAttachments(offlineAttachments));
+      const meta = AttachmentModelMeta[this.attachmentModel];
+      const promise = this.enqueueRequest({
+        description: `Attach files to ${meta.name}`,
+        method: HttpMethod.POST,
+        url: `${meta.attachUrlPrefix}/${modelId}/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 }) => {
+        store.dispatch(actions.updateAttachments(attachments));
+        this.processPresignedUrls(presigned_urls);
+      }).catch(() => {
+        store.dispatch(actions.removeAttachments(offlineAttachments.map((attachment) => attachment.offline_id)));
+      });
+      return [offlineAttachments, promise.then(({ attachments }) => attachments)];
+    }
+    async deleteAttachment(attachmendId, actions, selectors) {
+      const { store } = this.client;
+      const attachment = selectors.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));
+      const meta = AttachmentModelMeta[this.attachmentModel];
+      const promise = this.enqueueRequest({
+        description: "Delete attachment",
+        method: HttpMethod.DELETE,
+        url: `${meta.deleteUrlPrefix}/attachments/${attachmendId}/`,
+        blockers: [attachmendId],
+        blocks: []
+      });
+      promise.then(() => {
+        if (this.getNumberOfAttachmentsWithSha1(attachment.file_sha1) === 0) {
+          void this.client.files.removeCache(attachment.file_sha1);
+        }
+      }).catch(() => {
+        store.dispatch(actions.setAttachment(attachment));
+      });
+      return promise;
+    }
+  }
+  class ComponentAttachmentService extends BaseAttachmentService {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "attachmentModel", AttachmentModel.Component);
+    }
+    buildOfflineAttachment(data) {
+      return offline({
+        file: URL.createObjectURL(data.file),
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
+        file_name: data.file.name,
+        file_type: data.file.type,
+        submitted_at: data.submittedAt,
+        description: data.description,
+        component: data.modelId
+      });
+    }
+    async attachFilesToComponent(files, componentId) {
+      return this.attachFiles(
+        files,
+        componentId,
+        this.buildOfflineAttachment.bind(this),
+        {
+          addAttachments: addComponentAttachments,
+          updateAttachments: updateComponentAttachments,
+          removeAttachments: removeComponentAttachments
+        }
+      );
+    }
+    deleteComponentAttachment(attachmentId) {
+      return this.deleteAttachment(
+        attachmentId,
+        {
+          setAttachment: setComponentAttachment,
+          removeAttachment: removeComponentAttachment
+        },
+        {
+          selectAttachment: selectComponentAttachment
+        }
+      );
+    }
+    async refreshStore() {
+      return this.getAttachments({
+        setAttachments: setComponentAttachments
+      });
+    }
+  }
   class ComponentTypeService extends BaseApiService {
     add(componentType) {
       const offlineComponentType = offline(componentType);
@@ -6319,6 +6040,53 @@ var __publicField = (obj, key, value) => {
       store.dispatch(setComponentTypes(result));
     }
   }
+  class ComponentTypeAttachmentService extends BaseAttachmentService {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "attachmentModel", AttachmentModel.ComponentType);
+    }
+    buildOfflineAttachment(data) {
+      return offline({
+        file: URL.createObjectURL(data.file),
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
+        file_name: data.file.name,
+        file_type: data.file.type,
+        submitted_at: data.submittedAt,
+        description: data.description,
+        component_type: data.modelId
+      });
+    }
+    async attachFilesToComponentType(files, componentTypeId) {
+      return this.attachFiles(
+        files,
+        componentTypeId,
+        this.buildOfflineAttachment.bind(this),
+        {
+          addAttachments: addComponentTypeAttachments,
+          updateAttachments: updateComponentTypeAttachments,
+          removeAttachments: removeComponentTypeAttachments
+        }
+      );
+    }
+    deleteComponentTypeAttachment(attachmentId) {
+      return this.deleteAttachment(
+        attachmentId,
+        {
+          setAttachment: setComponentTypeAttachment,
+          removeAttachment: removeComponentTypeAttachment
+        },
+        {
+          selectAttachment: selectComponentTypeAttachment
+        }
+      );
+    }
+    async refreshStore() {
+      return this.getAttachments({
+        setAttachments: setComponentTypeAttachments
+      });
+    }
+  }
   class IssueCommentService extends BaseApiService {
     // Omit author and submitted_at since these will always be set internally
     add(comment) {
@@ -6415,6 +6183,48 @@ var __publicField = (obj, key, value) => {
       store.dispatch(setIssueUpdates(filteredResult));
     }
   }
+  class IssueAttachmentService extends BaseAttachmentService {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "attachmentModel", AttachmentModel.Issue);
+    }
+    buildOfflineAttachment(data) {
+      return offline({
+        file: URL.createObjectURL(data.file),
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
+        file_name: data.file.name,
+        file_type: data.file.type,
+        submitted_at: data.submittedAt,
+        description: data.description,
+        issue: data.modelId
+      });
+    }
+    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
+        }
+      );
+    }
+    async refreshStore() {
+      return this.getAttachments({
+        setAttachments: setIssueAttachments
+      });
+    }
+  }
   class IssueService extends BaseApiService {
     // Basic CRUD functions
     // TODO: Once all models are represented in `Created<TModel>`, use `Created` in `OptimisticModelResult`, so we don't
@@ -6859,6 +6669,7 @@ var __publicField = (obj, key, value) => {
         const usersResult = await usersResultPromise;
         await projectAccessRefreshPromise;
         store.dispatch(addUsers(usersResult));
+        void this.client.projectAttachments.refreshStore();
       }
       let currentWorkspaceId;
       const oldWorkspaceId = this.client.store.getState().workspaceReducer.activeWorkspaceId;
@@ -6871,35 +6682,29 @@ var __publicField = (obj, key, value) => {
         store.dispatch(setActiveWorkspaceId(currentWorkspaceId));
         void this.client.categories.refreshStore().then(() => {
           void this.client.issues.refreshStore().then(() => {
+            void this.client.issueAttachments.refreshStore().then();
             void this.client.issueComments.refreshStore().then();
+            void this.client.issueUpdates.refreshStore().then();
           });
         });
         void this.client.projectFiles.refreshStore().then();
         void this.client.componentTypes.refreshStore().then(() => {
-          void this.client.componentStages.refreshStore().then(() => {
-            void this.client.components.refreshStore(overwrite).then();
+          void this.client.componentTypeAttachments.refreshStore().then(() => {
+            void this.client.componentStages.refreshStore().then(() => {
+              void this.client.components.refreshStore(overwrite).then(() => {
+                void this.client.componentAttachments.refreshStore().then();
+              });
+            });
+            void this.client.componentStageCompletions.refreshStore().then();
           });
-          void this.client.componentStageCompletions.refreshStore().then();
         });
         void this.client.userForms.refreshStore().then(() => {
           void this.client.userFormSubmissions.refreshStore().then();
         });
       }
       if (currentProjectId) {
-        const [_offlineAttachments, promise] = this.client.attachments.fetchAll(currentProjectId);
-        void promise.then((result) => {
-          const {
-            issue_attachments,
-            component_type_attachments,
-            component_attachments,
-            project_attachments,
-            document_attachments
-          } = result;
-          store.dispatch(setIssueAttachments(issue_attachments));
-          store.dispatch(setComponentAttachments(component_attachments));
-          store.dispatch(setComponentTypeAttachments(component_type_attachments));
-          store.dispatch(setProjectAttachments(project_attachments));
-          store.dispatch(setDocumentAttachments(document_attachments));
+        void this.client.documents.refreshStore().then(() => {
+          void this.client.documentAttachments.refreshStore().then();
         });
         void this.client.documents.refreshStore();
         void this.client.issueUpdates.refreshStore();
@@ -7002,6 +6807,7 @@ var __publicField = (obj, key, value) => {
       });
       return promise;
     }
+    // TODO: This needs to be seperated into a update and create method
     saveActive() {
       const { store } = this.client;
       const state = store.getState();
@@ -7067,6 +6873,48 @@ var __publicField = (obj, key, value) => {
       });
     }
   }
+  class ProjectAttachmentService extends BaseAttachmentService {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "attachmentModel", AttachmentModel.Project);
+    }
+    buildOfflineAttachment(data) {
+      return offline({
+        file: URL.createObjectURL(data.file),
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
+        file_name: data.file.name,
+        file_type: data.file.type,
+        submitted_at: data.submittedAt,
+        description: data.description,
+        project: data.modelId
+      });
+    }
+    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
+        }
+      );
+    }
+    async refreshStore() {
+      return this.getAttachments({
+        setAttachments: setProjectAttachments
+      });
+    }
+  }
   class ProjectService extends BaseApiService {
     /**
      * Creates a new project. Due to the nature of project creation,
@@ -8458,6 +8306,48 @@ var __publicField = (obj, key, value) => {
       store.dispatch(addDocuments(await organizationDocumentsPromise));
     }
   }
+  class DocumentAttachmentService extends BaseAttachmentService {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "attachmentModel", AttachmentModel.Document);
+    }
+    buildOfflineAttachment(data) {
+      return offline({
+        file: URL.createObjectURL(data.file),
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
+        file_name: data.file.name,
+        file_type: data.file.type,
+        submitted_at: data.submittedAt,
+        description: data.description,
+        document: data.modelId
+      });
+    }
+    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
+        }
+      );
+    }
+    async refreshStore() {
+      return this.getAttachments({
+        setAttachments: setDocumentAttachments
+      });
+    }
+  }
   class AgentService extends BaseApiService {
     /**
      * Prompt the agent with a message.
@@ -8479,16 +8369,6 @@ var __publicField = (obj, key, value) => {
         queryParams: conversationId ? { conversation_id: conversationId } : {}
       });
     }
-    async fetchAll() {
-      const activeProjectId = this.client.store.getState().projectReducer.activeProjectId;
-      return this.enqueueRequest({
-        description: "Fetch agent conversations",
-        method: HttpMethod.GET,
-        url: `/projects/${activeProjectId}/agents-conversations/`,
-        blockers: ["fetch-agent-conversations"],
-        blocks: ["fetch-agent-conversations"]
-      });
-    }
     async rate(responseId, rating) {
       return this.enqueueRequest({
         description: "Rate agent response",
@@ -8642,7 +8522,6 @@ var __publicField = (obj, key, value) => {
       __publicField(this, "store");
       __publicField(this, "agent", new AgentService(this));
       __publicField(this, "files", new FileService(this));
-      __publicField(this, "attachments", new AttachmentService(this));
       __publicField(this, "auth", new AuthService(this));
       __publicField(this, "categories", new CategoryService(this));
       __publicField(this, "projectAccesses", new ProjectAccessService(this));
@@ -8652,21 +8531,26 @@ var __publicField = (obj, key, value) => {
       __publicField(this, "issueTypes", new IssueTypeService(this));
       __publicField(this, "issueComments", new IssueCommentService(this));
       __publicField(this, "issueUpdates", new IssueUpdateService(this));
+      __publicField(this, "issueAttachments", new IssueAttachmentService(this));
       __publicField(this, "workspaces", new WorkspaceService(this));
       __publicField(this, "main", new MainService(this));
       __publicField(this, "components", new ComponentService(this));
+      __publicField(this, "componentAttachments", new ComponentAttachmentService(this));
       __publicField(this, "componentTypes", new ComponentTypeService(this));
+      __publicField(this, "componentTypeAttachments", new ComponentTypeAttachmentService(this));
       __publicField(this, "componentStages", new ComponentStageService(this));
       __publicField(this, "componentStageCompletions", new ComponentStageCompletionService(this));
       __publicField(this, "userForms", new UserFormService(this));
       __publicField(this, "userFormSubmissions", new UserFormSubmissionService(this));
       __publicField(this, "projects", new ProjectService(this));
       __publicField(this, "projectFiles", new ProjectFileService(this));
+      __publicField(this, "projectAttachments", new ProjectAttachmentService(this));
       __publicField(this, "emailVerification", new EmailVerificationService(this));
       __publicField(this, "emailDomains", new EmailDomainsService(this));
       __publicField(this, "licenses", new LicenseService(this));
       __publicField(this, "documents", new DocumentService(this));
       __publicField(this, "teams", new TeamService(this));
+      __publicField(this, "documentAttachments", new DocumentAttachmentService(this));
       this.API_URL = apiUrl;
       this.store = store;
     }
@@ -16498,7 +16382,7 @@ var __publicField = (obj, key, value) => {
   }, Symbol.toStringTag, { value: "Module" }));
   exports2.APIError = APIError;
   exports2.AgentService = AgentService;
-  exports2.AttachmentService = AttachmentService;
+  exports2.AttachmentModel = AttachmentModel;
   exports2.AuthService = AuthService;
   exports2.BaseApiService = BaseApiService;
   exports2.BaseField = BaseField;
@@ -16509,15 +16393,18 @@ var __publicField = (obj, key, value) => {
   exports2.ColorPicker = ColorPicker;
   exports2.Colors = Colors;
   exports2.ColorsToString = ColorsToString;
+  exports2.ComponentAttachmentService = ComponentAttachmentService;
   exports2.ComponentService = ComponentService;
   exports2.ComponentStageColors = ComponentStageColors;
   exports2.ComponentStageCompletionService = ComponentStageCompletionService;
   exports2.ComponentStageService = ComponentStageService;
+  exports2.ComponentTypeAttachmentService = ComponentTypeAttachmentService;
   exports2.ComponentTypeService = ComponentTypeService;
   exports2.DEFAULT_ISSUE_PRIORITY = DEFAULT_ISSUE_PRIORITY;
   exports2.DEFAULT_ISSUE_STATUS = DEFAULT_ISSUE_STATUS;
   exports2.DateField = DateField;
   exports2.DateInput = DateInput;
+  exports2.DocumentAttachmentService = DocumentAttachmentService;
   exports2.DocumentService = DocumentService;
   exports2.EmailDomainsService = EmailDomainsService;
   exports2.EmailVerificationService = EmailVerificationService;
@@ -16541,6 +16428,7 @@ var __publicField = (obj, key, value) => {
   exports2.InputWithHelpText = InputWithHelpText;
   exports2.InputWithLabel = InputWithLabel;
   exports2.InputWithLabelAndHelpText = InputWithLabelAndHelpText;
+  exports2.IssueAttachmentService = IssueAttachmentService;
   exports2.IssueCommentService = IssueCommentService;
   exports2.IssuePriority = IssuePriority;
   exports2.IssueService = IssueService;
@@ -16573,6 +16461,7 @@ var __publicField = (obj, key, value) => {
   exports2.PatchFormProvider = PatchFormProvider;
   exports2.ProjectAccessLevel = ProjectAccessLevel;
   exports2.ProjectAccessService = ProjectAccessService;
+  exports2.ProjectAttachmentService = ProjectAttachmentService;
   exports2.ProjectFileService = ProjectFileService;
   exports2.ProjectService = ProjectService;
   exports2.ProjectType = ProjectType;
@@ -16803,6 +16692,7 @@ var __publicField = (obj, key, value) => {
   exports2.removeFavouriteProjectId = removeFavouriteProjectId;
   exports2.removeIssue = removeIssue;
   exports2.removeIssueAttachment = removeIssueAttachment;
+  exports2.removeIssueAttachments = removeIssueAttachments;
   exports2.removeIssueComment = removeIssueComment;
   exports2.removeIssueComments = removeIssueComments;
   exports2.removeIssueType = removeIssueType;
@@ -16977,6 +16867,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectProjectAccessForUser = selectProjectAccessForUser;
   exports2.selectProjectAccessUserMapping = selectProjectAccessUserMapping;
   exports2.selectProjectAccesses = selectProjectAccesses;
+  exports2.selectProjectAttachment = selectProjectAttachment;
   exports2.selectProjectAttachmentMapping = selectProjectAttachmentMapping;
   exports2.selectProjectFileVisibility = selectProjectFileVisibility;
   exports2.selectProjectFiles = selectProjectFiles;
@@ -17026,12 +16917,15 @@ var __publicField = (obj, key, value) => {
   exports2.setAppearance = setAppearance;
   exports2.setCategories = setCategories;
   exports2.setCenterMapToProject = setCenterMapToProject;
+  exports2.setComponentAttachment = setComponentAttachment;
   exports2.setComponentAttachments = setComponentAttachments;
+  exports2.setComponentTypeAttachment = setComponentTypeAttachment;
   exports2.setComponentTypeAttachments = setComponentTypeAttachments;
   exports2.setComponentTypes = setComponentTypes;
   exports2.setComponents = setComponents;
   exports2.setCreateProjectType = setCreateProjectType;
   exports2.setCurrentUser = setCurrentUser;
+  exports2.setDocumentAttachment = setDocumentAttachment;
   exports2.setDocumentAttachments = setDocumentAttachments;
   exports2.setDocuments = setDocuments;
   exports2.setEmailDomains = setEmailDomains;
@@ -17048,6 +16942,7 @@ var __publicField = (obj, key, value) => {
   exports2.setIsFetchingInitialData = setIsFetchingInitialData;
   exports2.setIsImportingProjectFile = setIsImportingProjectFile;
   exports2.setIsLoading = setIsLoading;
+  exports2.setIssueAttachment = setIssueAttachment;
   exports2.setIssueAttachments = setIssueAttachments;
   exports2.setIssueComment = setIssueComment;
   exports2.setIssueComments = setIssueComments;
@@ -17062,6 +16957,7 @@ var __publicField = (obj, key, value) => {
   exports2.setOrganizations = setOrganizations;
   exports2.setProfilePicture = setProfilePicture;
   exports2.setProjectAccesses = setProjectAccesses;
+  exports2.setProjectAttachment = setProjectAttachment;
   exports2.setProjectAttachments = setProjectAttachments;
   exports2.setProjectFileVisible = setProjectFileVisible;
   exports2.setProjects = setProjects;
@@ -17096,20 +16992,25 @@ var __publicField = (obj, key, value) => {
   exports2.updateActiveOrganization = updateActiveOrganization;
   exports2.updateComponent = updateComponent;
   exports2.updateComponentAttachment = updateComponentAttachment;
+  exports2.updateComponentAttachments = updateComponentAttachments;
   exports2.updateComponentTypeAttachment = updateComponentTypeAttachment;
+  exports2.updateComponentTypeAttachments = updateComponentTypeAttachments;
   exports2.updateDocumentAttachment = updateDocumentAttachment;
+  exports2.updateDocumentAttachments = updateDocumentAttachments;
   exports2.updateDocuments = updateDocuments;
   exports2.updateFormSubmission = updateFormSubmission;
   exports2.updateFormSubmissionAttachments = updateFormSubmissionAttachments;
   exports2.updateFormSubmissions = updateFormSubmissions;
   exports2.updateIssue = updateIssue;
   exports2.updateIssueAttachment = updateIssueAttachment;
+  exports2.updateIssueAttachments = updateIssueAttachments;
   exports2.updateIssueType = updateIssueType;
   exports2.updateLicense = updateLicense;
   exports2.updateOrCreateProject = updateOrCreateProject;
   exports2.updateOrganizationAccess = updateOrganizationAccess;
   exports2.updateProjectAccess = updateProjectAccess;
   exports2.updateProjectAttachment = updateProjectAttachment;
+  exports2.updateProjectAttachments = updateProjectAttachments;
   exports2.updateStages = updateStages;
   exports2.updateTeam = updateTeam;
   exports2.useAppDispatch = useAppDispatch;