@overmap-ai/core 1.0.71-fields.9 → 1.0.71-org-projs-only.1

package/dist/overmap-core.umd.cjs

@@ -747,15 +747,15 @@ var __publicField = (obj, key, value) => {
   };
   const migrations = [initialVersioning, signOut, signOut, createOutboxState];
   const manifest = Object.fromEntries(migrations.map((migration2, i) => [i, wrapMigration(migration2)]));
-  const initialState$J = {
+  const initialState$B = {
     accessToken: "",
     refreshToken: "",
     isLoggedIn: false
   };
   const authSlice = toolkit.createSlice({
     name: "auth",
-    initialState: initialState$J,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$J)),
+    initialState: initialState$B,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
     reducers: {
       setTokens: (state, action) => {
         state.accessToken = action.payload.accessToken;
@@ -843,11 +843,11 @@ var __publicField = (obj, key, value) => {
     };
   }
   const categoryAdapter = createModelAdapter((category) => category.offline_id);
-  const initialState$I = categoryAdapter.getInitialState({});
+  const initialState$A = categoryAdapter.getInitialState({});
   const categorySlice = toolkit.createSlice({
     name: "categories",
-    initialState: initialState$I,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$I)),
+    initialState: initialState$A,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$A)),
     reducers: {
       initializeCategories: categoryAdapter.initialize,
       addCategory: categoryAdapter.addOne,
@@ -891,11 +891,11 @@ var __publicField = (obj, key, value) => {
   };
   const categoryReducer = categorySlice.reducer;
   const assetAdapter = createModelAdapter((asset) => asset.offline_id);
-  const initialState$H = assetAdapter.getInitialState({});
+  const initialState$z = assetAdapter.getInitialState({});
   const assetSlice = toolkit.createSlice({
     name: "assets",
-    initialState: initialState$H,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$H)),
+    initialState: initialState$z,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
     reducers: {
       initializeAssets: assetAdapter.initialize,
       addAsset: assetAdapter.addOne,
@@ -947,11 +947,11 @@ var __publicField = (obj, key, value) => {
   };
   const assetReducer = assetSlice.reducer;
   const assetAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$G = assetAttachmentAdapter.getInitialState({});
+  const initialState$y = assetAttachmentAdapter.getInitialState({});
   const assetAttachmentSlice = toolkit.createSlice({
     name: "assetAttachments",
-    initialState: initialState$G,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$G)),
+    initialState: initialState$y,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
     reducers: {
       initializeAssetAttachments: assetAttachmentAdapter.initialize,
       addAssetAttachment: assetAttachmentAdapter.addOne,
@@ -1012,11 +1012,11 @@ var __publicField = (obj, key, value) => {
   const assetStageCompletionAdapter = createModelAdapter(
     (stageCompletion) => stageCompletion.offline_id
   );
-  const initialState$F = assetStageCompletionAdapter.getInitialState({});
+  const initialState$x = assetStageCompletionAdapter.getInitialState({});
   const assetStageCompletionSlice = toolkit.createSlice({
     name: "assetStageCompletions",
-    initialState: initialState$F,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$F)),
+    initialState: initialState$x,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
     reducers: {
       initializeAssetStageCompletions: assetStageCompletionAdapter.initialize,
       addAssetStageCompletion: assetStageCompletionAdapter.addOne,
@@ -1078,11 +1078,11 @@ var __publicField = (obj, key, value) => {
   );
   const assetStageCompletionReducer = assetStageCompletionSlice.reducer;
   const assetStageAdapter = createModelAdapter((assetStage) => assetStage.offline_id);
-  const initialState$E = assetStageAdapter.getInitialState({});
+  const initialState$w = assetStageAdapter.getInitialState({});
   const assetStageSlice = toolkit.createSlice({
     name: "assetStages",
-    initialState: initialState$E,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$E)),
+    initialState: initialState$w,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
     reducers: {
       initializeAssetStages: assetStageAdapter.initialize,
       setAssetStage: assetStageAdapter.setOne,
@@ -1162,11 +1162,11 @@ var __publicField = (obj, key, value) => {
     })
   );
   const assetTypeAdapter = createModelAdapter((assetType) => assetType.offline_id);
-  const initialState$D = assetTypeAdapter.getInitialState({});
+  const initialState$v = assetTypeAdapter.getInitialState({});
   const assetTypeSlice = toolkit.createSlice({
     name: "assetTypes",
-    initialState: initialState$D,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$D)),
+    initialState: initialState$v,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
     reducers: {
       initializeAssetTypes: assetTypeAdapter.initialize,
       setAssetType: assetTypeAdapter.setOne,
@@ -1219,11 +1219,11 @@ var __publicField = (obj, key, value) => {
   const assetTypeAttachmentAdapter = createModelAdapter(
     (attachment) => attachment.offline_id
   );
-  const initialState$C = assetTypeAttachmentAdapter.getInitialState({});
+  const initialState$u = assetTypeAttachmentAdapter.getInitialState({});
   const assetTypeAttachmentSlice = toolkit.createSlice({
     name: "assetTypeAttachments",
-    initialState: initialState$C,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$C)),
+    initialState: initialState$u,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$u)),
     reducers: {
       initializeAssetTypeAttachments: assetTypeAttachmentAdapter.initialize,
       addAssetTypeAttachment: assetTypeAttachmentAdapter.addOne,
@@ -1282,12 +1282,12 @@ var __publicField = (obj, key, value) => {
   );
   const assetTypeAttachmentReducer = assetTypeAttachmentSlice.reducer;
   const issueAdapter = createModelAdapter((issue) => issue.offline_id);
-  const initialState$B = issueAdapter.getInitialState({});
+  const initialState$t = issueAdapter.getInitialState({});
   const issueSlice = toolkit.createSlice({
     name: "issues",
-    initialState: initialState$B,
+    initialState: initialState$t,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$B);
+      Object.assign(state, initialState$t);
     }),
     reducers: {
       initializeIssues: issueAdapter.initialize,
@@ -1319,12 +1319,12 @@ var __publicField = (obj, key, value) => {
   );
   const issueReducer = issueSlice.reducer;
   const issueTypeAdapter = createModelAdapter((issueType) => issueType.offline_id);
-  const initialState$A = issueTypeAdapter.getInitialState({});
+  const initialState$s = issueTypeAdapter.getInitialState({});
   const issueTypeSlice = toolkit.createSlice({
     name: "issueTypes",
-    initialState: initialState$A,
+    initialState: initialState$s,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$A);
+      Object.assign(state, initialState$s);
     }),
     reducers: {
       initializeIssueTypes: issueTypeAdapter.initialize,
@@ -1381,15 +1381,15 @@ var __publicField = (obj, key, value) => {
     return selectIssuesOfIssueType(issueTypeId)(state).length;
   };
   const issueTypeReducer = issueTypeSlice.reducer;
-  const initialState$z = {
+  const initialState$r = {
     s3Urls: {}
   };
   const msPerHour = 1e3 * 60 * 60;
   const msPerWeek = msPerHour * 24 * 7;
   const fileSlice = toolkit.createSlice({
     name: "file",
-    initialState: initialState$z,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
+    initialState: initialState$r,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
     reducers: {
       setUploadUrl: (state, action) => {
         const { url, fields, sha1 } = action.payload;
@@ -1416,14 +1416,14 @@ var __publicField = (obj, key, value) => {
     return url;
   };
   const fileReducer = fileSlice.reducer;
-  const initialState$y = {
+  const initialState$q = {
     users: {},
     currentUser: null
   };
   const userSlice = toolkit.createSlice({
     name: "users",
-    initialState: initialState$y,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
+    initialState: initialState$q,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
     reducers: {
       setUsers: (state, action) => {
         const usersMapping = {};
@@ -1481,11 +1481,11 @@ var __publicField = (obj, key, value) => {
   const organizationAccessAdapter = createModelAdapter(
     (organizationAccess) => organizationAccess.offline_id
   );
-  const initialState$x = organizationAccessAdapter.getInitialState({});
+  const initialState$p = organizationAccessAdapter.getInitialState({});
   const organizationAccessSlice = toolkit.createSlice({
     name: "organizationAccess",
-    initialState: initialState$x,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
+    initialState: initialState$p,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
     reducers: {
       initializeOrganizationAccesses: organizationAccessAdapter.initialize,
       updateOrganizationAccess: organizationAccessAdapter.updateOne,
@@ -1522,11 +1522,11 @@ var __publicField = (obj, key, value) => {
   };
   const organizationAccessReducer = organizationAccessSlice.reducer;
   const licenseAdapter = createModelAdapter((license) => license.offline_id);
-  const initialState$w = licenseAdapter.getInitialState({});
+  const initialState$o = licenseAdapter.getInitialState({});
   const licenseSlice = toolkit.createSlice({
     name: "license",
-    initialState: initialState$w,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
+    initialState: initialState$o,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
     reducers: {
       initializeLicences: licenseAdapter.initialize,
       addLicenses: licenseAdapter.addMany,
@@ -1551,11 +1551,11 @@ var __publicField = (obj, key, value) => {
   );
   const licenseReducer = licenseSlice.reducer;
   const projectAccessAdapter = createModelAdapter((projectAccess) => projectAccess.offline_id);
-  const initialState$v = projectAccessAdapter.getInitialState({});
+  const initialState$n = projectAccessAdapter.getInitialState({});
   const projectAccessSlice = toolkit.createSlice({
     name: "projectAccess",
-    initialState: initialState$v,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
+    initialState: initialState$n,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
     reducers: {
       initializeProjectAccesses: projectAccessAdapter.initialize,
       updateProjectAccess: projectAccessAdapter.updateOne,
@@ -1596,14 +1596,14 @@ var __publicField = (obj, key, value) => {
     return projectAccesses;
   };
   const projectAccessReducer = projectAccessSlice.reducer;
-  const initialState$u = {
+  const initialState$m = {
     projects: {},
     activeProjectId: null
   };
   const projectSlice = toolkit.createSlice({
     name: "projects",
-    initialState: initialState$u,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$u)),
+    initialState: initialState$m,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
     reducers: {
       setProjects: (state, action) => {
         const projectsMap = {};
@@ -1710,13 +1710,13 @@ var __publicField = (obj, key, value) => {
       });
     }
   );
-  const initialState$t = {
+  const initialState$l = {
     organizations: {}
   };
   const organizationSlice = toolkit.createSlice({
     name: "organizations",
-    initialState: initialState$t,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$t)),
+    initialState: initialState$l,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
     reducers: {
       setOrganizations: (state, action) => {
         for (const org of action.payload) {
@@ -1807,14 +1807,14 @@ var __publicField = (obj, key, value) => {
       }
     };
   };
-  const initialState$s = {
+  const initialState$k = {
     deletedRequests: [],
     latestRetryTime: 0
   };
   const outboxSlice = toolkit.createSlice({
     name: "outbox",
-    initialState: initialState$s,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$s)),
+    initialState: initialState$k,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$k)),
     reducers: {
       // enqueueActions is a reducer that does nothing but enqueue API request to the Redux Offline outbox
       // Whenever an issue is being created, a reducer addIssue() is responsible for adding it to the offline store
@@ -1846,15 +1846,15 @@ var __publicField = (obj, key, value) => {
   const selectLatestRetryTime = (state) => state.outboxReducer.latestRetryTime;
   const { enqueueRequest, markForDeletion, markAsDeleted, _setLatestRetryTime } = outboxSlice.actions;
   const outboxReducer = outboxSlice.reducer;
-  const initialState$r = {
+  const initialState$j = {
     projectFiles: {},
     activeProjectFileId: null,
     isImportingProjectFile: false
   };
   const projectFileSlice = toolkit.createSlice({
     name: "projectFiles",
-    initialState: initialState$r,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
+    initialState: initialState$j,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
     reducers: {
       addOrReplaceProjectFiles: (state, action) => {
         for (let fileObj of action.payload) {
@@ -1941,11 +1941,11 @@ var __publicField = (obj, key, value) => {
   };
   const projectFileReducer = projectFileSlice.reducer;
   const projectAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$q = projectAttachmentAdapter.getInitialState({});
+  const initialState$i = projectAttachmentAdapter.getInitialState({});
   const projectAttachmentSlice = toolkit.createSlice({
     name: "projectAttachments",
-    initialState: initialState$q,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
+    initialState: initialState$i,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
     reducers: {
       initializeProjectAttachments: projectAttachmentAdapter.initialize,
       addProjectAttachment: projectAttachmentAdapter.addOne,
@@ -2000,12 +2000,12 @@ var __publicField = (obj, key, value) => {
     )
   );
   const projectAttachmentReducer = projectAttachmentSlice.reducer;
-  const initialState$p = {
+  const initialState$h = {
     isRehydrated: false
   };
   const rehydratedSlice = toolkit.createSlice({
     name: "rehydrated",
-    initialState: initialState$p,
+    initialState: initialState$h,
     // The `reducers` field lets us define reducers and generate associated actions
     reducers: {
       setRehydrated: (state, action) => {
@@ -2030,11 +2030,11 @@ var __publicField = (obj, key, value) => {
     }
   };
   const formRevisionAdapter = createModelAdapter((revision) => revision.offline_id);
-  const initialState$o = formRevisionAdapter.getInitialState({});
+  const initialState$g = formRevisionAdapter.getInitialState({});
   const formRevisionsSlice = toolkit.createSlice({
     name: "formRevisions",
-    initialState: initialState$o,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
+    initialState: initialState$g,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
     reducers: {
       initializeFormRevisions: formRevisionAdapter.initialize,
       setFormRevision: formRevisionAdapter.setOne,
@@ -2093,13 +2093,24 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
+  const selectLatestFormRevisionByForm = toolkit.createSelector([selectFormRevisionMapping], (revisions) => {
+    const latestRevisions = {};
+    for (const revision of Object.values(revisions)) {
+      const formId = revision.form;
+      const currentLatestRevision = latestRevisions[formId];
+      if (!currentLatestRevision || currentLatestRevision.revision < revision.revision) {
+        latestRevisions[formId] = revision;
+      }
+    }
+    return latestRevisions;
+  });
   const formRevisionReducer = formRevisionsSlice.reducer;
   const formAdapter = createModelAdapter((form) => form.offline_id);
-  const initialState$n = formAdapter.getInitialState({});
+  const initialState$f = formAdapter.getInitialState({});
   const formSlice = toolkit.createSlice({
     name: "forms",
-    initialState: initialState$n,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
+    initialState: initialState$f,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
     reducers: {
       initializeForms: formAdapter.initialize,
       setForm: formAdapter.setOne,
@@ -2117,9 +2128,6 @@ var __publicField = (obj, key, value) => {
   const selectForms = toolkit.createSelector([selectFormMapping], (formsMapping) => {
     return Object.values(formsMapping);
   });
-  const selectFormById = (formId) => (state) => {
-    return state.formReducer.instances[formId];
-  };
   const selectFilteredForms = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [
@@ -2145,12 +2153,37 @@ var __publicField = (obj, key, value) => {
       { memoizeOptions: { equalityCheck: shallowEqual } }
     )
   );
+  const selectFormById = (formId) => (state) => {
+    return state.formReducer.instances[formId];
+  };
+  const selectFormOfAssetType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectFormMapping, (_state, assetTypeId) => assetTypeId],
+      (formsMapping, assetTypeId) => {
+        return Object.values(formsMapping).find((form) => form.asset_type === assetTypeId);
+      }
+    )
+  );
+  const selectFormOfIssueType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectFormMapping, (_state, issueTypeId) => issueTypeId],
+      (formsMapping, issueTypeId) => {
+        return Object.values(formsMapping).find((form) => form.issue_type === issueTypeId);
+      }
+    )
+  );
+  const selectFormsCount = toolkit.createSelector([selectFormMapping], (formsMapping) => {
+    return Object.keys(formsMapping).length;
+  });
+  const selectGeneralFormCount = toolkit.createSelector([selectFormMapping], (formsMapping) => {
+    return Object.values(formsMapping).filter((form) => !form.asset_type).length;
+  });
   const submissionAdapter = createModelAdapter((submission) => submission.offline_id);
-  const initialState$m = submissionAdapter.getInitialState({});
+  const initialState$e = submissionAdapter.getInitialState({});
   const formSubmissionSlice = toolkit.createSlice({
     name: "formSubmissions",
-    initialState: initialState$m,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
+    initialState: initialState$e,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
     reducers: {
       initializeFormSubmissions: submissionAdapter.initialize,
       setFormSubmission: submissionAdapter.setOne,
@@ -2206,6 +2239,43 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
+  const selectFormSubmissionsByFormRevisions = toolkit.createSelector([selectFormRevisionMapping, selectFormSubmissions], (revisions, submissions) => {
+    var _a2;
+    const submissionMapping = {};
+    for (const revisionId in revisions) {
+      submissionMapping[revisionId] = [];
+    }
+    for (const submission of submissions) {
+      (_a2 = submissionMapping[submission.form_revision]) == null ? void 0 : _a2.push(submission);
+    }
+    return submissionMapping;
+  });
+  const selectSortedFormSubmissionsOfForm = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [
+        selectFormRevisionMapping,
+        selectFormSubmissionsByFormRevisions,
+        (_state, formId) => formId
+      ],
+      (revisionsMapping, submissionsByRevision, formId) => {
+        const submissionsByFormRevisions = {};
+        for (const revisionId in revisionsMapping) {
+          const revision = revisionsMapping[revisionId];
+          const submissionsOfRevision = submissionsByRevision[revisionId];
+          if (revision && submissionsOfRevision && revision.form === formId) {
+            submissionsByFormRevisions[revisionId] = submissionsOfRevision.sort(
+              (a, b) => a.submitted_at < b.submitted_at ? -1 : 1
+            );
+          }
+        }
+        return Object.entries(submissionsByFormRevisions).sort((a, b) => {
+          const aRevision = revisionsMapping[a[0]];
+          const bRevision = revisionsMapping[b[0]];
+          return formRevisionSortFn(aRevision, bRevision);
+        }).map(([_revisionId, submissions]) => submissions).flat();
+      }
+    )
+  );
   const selectFormSubmissionsOfIssue = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [selectFormSubmissions, (_state, issueId) => issueId],
@@ -2216,6 +2286,54 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
+  const selectAttachedFormSubmissionsOfIssue = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [
+        (state) => state.issueReducer.instances,
+        (state) => state.formReducer.instances,
+        (state) => state.formRevisionReducer.instances,
+        (state) => state.formSubmissionReducer.instances,
+        (_state, issueId) => issueId
+      ],
+      (issues, forms, formRevisions, submissions, issueId) => {
+        const issue = issues[issueId];
+        if (!issue)
+          return [];
+        if (!issue.issue_type) {
+          return Object.values(submissions).filter((submission) => submission.issue === issueId);
+        }
+        const issueTypeForms = new Set(
+          Object.keys(forms).filter((formId) => forms[formId].issue_type === issue.issue_type)
+        );
+        const issueTypeFormRevisions = new Set(
+          Object.keys(formRevisions).filter(
+            (formRevisionId) => issueTypeForms.has(formRevisions[formRevisionId].form)
+          )
+        );
+        return Object.values(submissions).filter(
+          (submission) => submission.issue === issueId && !issueTypeFormRevisions.has(submission.form_revision)
+        );
+      }
+    )
+  );
+  const selectFormSubmissionsByIssues = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectFormSubmissions, (_state, issueIds) => issueIds],
+      (submissions, issueIds) => {
+        var _a2;
+        const issueSubmissions = {};
+        for (const issueId of issueIds) {
+          issueSubmissions[issueId] = [];
+        }
+        for (const submission of submissions) {
+          if (submission.issue && issueIds.includes(submission.issue)) {
+            (_a2 = issueSubmissions[submission.issue]) == null ? void 0 : _a2.push(submission);
+          }
+        }
+        return issueSubmissions;
+      }
+    )
+  );
   const selectFormSubmissionsOfAsset = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [selectFormSubmissions, (_state, assetId) => assetId],
@@ -2226,15 +2344,62 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
+  const selectAttachedFormSubmissionsOfAsset = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [
+        (state) => state.assetReducer.instances,
+        (state) => state.formReducer.instances,
+        (state) => state.formRevisionReducer.instances,
+        (state) => state.formSubmissionReducer.instances,
+        (_state, assetId) => assetId
+      ],
+      (assets, forms, formRevisions, submissions, assetId) => {
+        const asset = assets[assetId];
+        if (!asset)
+          return [];
+        if (!asset.asset_type) {
+          return Object.values(submissions).filter((submission) => submission.asset === assetId);
+        }
+        const issueTypeForms = new Set(
+          Object.keys(forms).filter((formId) => forms[formId].asset_type === asset.asset_type)
+        );
+        const issueTypeFormRevisions = new Set(
+          Object.keys(formRevisions).filter(
+            (formRevisionId) => issueTypeForms.has(formRevisions[formRevisionId].form)
+          )
+        );
+        return Object.values(submissions).filter(
+          (submission) => submission.asset === assetId && !issueTypeFormRevisions.has(submission.form_revision)
+        );
+      }
+    )
+  );
+  const selectFormSubmissionsByAssets = toolkit.createSelector(
+    [selectFormSubmissionsMapping, selectAssetsMapping],
+    (submissions, assets) => {
+      var _a2;
+      const assetSubmissionMapping = {};
+      for (const assetId in assets) {
+        assetSubmissionMapping[assetId] = [];
+      }
+      for (const submissionId in submissions) {
+        const submission = submissions[submissionId];
+        if (submission.asset) {
+          (_a2 = assetSubmissionMapping[submission.asset]) == null ? void 0 : _a2.push(submission);
+        }
+      }
+      return assetSubmissionMapping;
+    }
+  );
   const formSubmissionReducer = formSubmissionSlice.reducer;
   const formSubmissionAttachmentAdapter = createModelAdapter(
     (attachment) => attachment.offline_id
   );
-  const initialState$l = formSubmissionAttachmentAdapter.getInitialState({});
+  const initialState$d = formSubmissionAttachmentAdapter.getInitialState({});
   const formSubmissionAttachmentSlice = toolkit.createSlice({
     name: "formSubmissionAttachments",
-    initialState: initialState$l,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
+    initialState: initialState$d,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
     reducers: {
       initializeFormSubmissionAttachments: formSubmissionAttachmentAdapter.initialize,
       addFormSubmissionAttachment: formSubmissionAttachmentAdapter.addOne,
@@ -2277,9 +2442,7 @@ var __publicField = (obj, key, value) => {
       [selectFormSubmissionAttachmentsMapping, (_state, submissionId) => submissionId],
       (attachmentsMapping, submissionId) => {
         return fallbackToEmptyArray(
-          Object.values(attachmentsMapping).filter(
-            (attachment) => attachment.form_submission === submissionId
-          )
+          Object.values(attachmentsMapping).filter((attachment) => attachment.submission === submissionId)
         );
       }
     )
@@ -2288,11 +2451,11 @@ var __publicField = (obj, key, value) => {
   const formRevisionAttachmentAdapter = createModelAdapter(
     (attachment) => attachment.offline_id
   );
-  const initialState$k = formRevisionAttachmentAdapter.getInitialState({});
+  const initialState$c = formRevisionAttachmentAdapter.getInitialState({});
   const formRevisionAttachmentSlice = toolkit.createSlice({
     name: "formRevisionAttachments",
-    initialState: initialState$k,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$k)),
+    initialState: initialState$c,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
     reducers: {
       initializeFormRevisionAttachments: formRevisionAttachmentAdapter.initialize,
       addFormRevisionAttachment: formRevisionAttachmentAdapter.addOne,
@@ -2324,17 +2487,17 @@ var __publicField = (obj, key, value) => {
       [selectFormRevisionAttachmentsMapping, (_state, revisionId) => revisionId],
       (attachments, revisionId) => {
         return fallbackToEmptyArray(
-          Object.values(attachments).filter((attachment) => attachment.form_revision === revisionId)
+          Object.values(attachments).filter((attachment) => attachment.revision === revisionId)
         );
       }
     )
   );
   const formRevisionAttachmentReducer = formRevisionAttachmentSlice.reducer;
   const workspaceAdapter = createModelAdapter((workspace) => workspace.offline_id);
-  const initialState$j = workspaceAdapter.getInitialState({});
+  const initialState$b = workspaceAdapter.getInitialState({});
   const workspaceSlice = toolkit.createSlice({
     name: "workspace",
-    initialState: initialState$j,
+    initialState: initialState$b,
     reducers: {
       initializeWorkspaces: workspaceAdapter.initialize,
       setWorkspaces: workspaceAdapter.setMany,
@@ -2365,10 +2528,10 @@ var __publicField = (obj, key, value) => {
   );
   const workspaceReducer = workspaceSlice.reducer;
   const emailDomainAdapter = createModelAdapter((emailDomain) => emailDomain.offline_id);
-  const initialState$i = emailDomainAdapter.getInitialState({});
+  const initialState$a = emailDomainAdapter.getInitialState({});
   const emailDomainsSlice = toolkit.createSlice({
     name: "emailDomains",
-    initialState: initialState$i,
+    initialState: initialState$a,
     reducers: {
       initializeEmailDomains: emailDomainAdapter.initialize,
       addEmailDomain: emailDomainAdapter.addOne,
@@ -2389,14 +2552,14 @@ var __publicField = (obj, key, value) => {
     )
   );
   const emailDomainsReducer = emailDomainsSlice.reducer;
-  const initialState$h = {
+  const initialState$9 = {
     documents: {}
   };
   const documentSlice = toolkit.createSlice({
     name: "documents",
-    initialState: initialState$h,
+    initialState: initialState$9,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$h);
+      Object.assign(state, initialState$9);
     }),
     reducers: {
       setDocuments: (state, action) => {
@@ -2585,11 +2748,11 @@ var __publicField = (obj, key, value) => {
   );
   const documentsReducer = documentSlice.reducer;
   const documentAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$g = documentAttachmentAdapter.getInitialState({});
+  const initialState$8 = documentAttachmentAdapter.getInitialState({});
   const documentAttachmentSlice = toolkit.createSlice({
     name: "documentAttachments",
-    initialState: initialState$g,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
+    initialState: initialState$8,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
     reducers: {
       initializeDocumentAttachments: documentAttachmentAdapter.initialize,
       addDocumentAttachment: documentAttachmentAdapter.addOne,
@@ -2648,11 +2811,11 @@ var __publicField = (obj, key, value) => {
   );
   const documentAttachmentReducer = documentAttachmentSlice.reducer;
   const teamAdapter = createModelAdapter((team) => team.offline_id);
-  const initialState$f = teamAdapter.getInitialState({});
+  const initialState$7 = teamAdapter.getInitialState({});
   const teamSlice = toolkit.createSlice({
     name: "teams",
-    initialState: initialState$f,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
+    initialState: initialState$7,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
     reducers: {
       setTeam: teamAdapter.setOne,
       initializeTeams: teamAdapter.initialize,
@@ -2703,11 +2866,11 @@ var __publicField = (obj, key, value) => {
   const agentUserConversationAdapter = createModelAdapter(
     (conversation) => conversation.offline_id
   );
-  const initialState$e = agentUserConversationAdapter.getInitialState({});
+  const initialState$6 = agentUserConversationAdapter.getInitialState({});
   const agentsSlice = toolkit.createSlice({
     name: "agents",
-    initialState: initialState$e,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
+    initialState: initialState$6,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
     reducers: {
       initializeConversations: agentUserConversationAdapter.initialize,
       addConversation: agentUserConversationAdapter.addOne,
@@ -2729,11 +2892,11 @@ var __publicField = (obj, key, value) => {
   );
   const agentsReducer = agentsSlice.reducer;
   const issueCommentAdapter = createModelAdapter((comment) => comment.offline_id);
-  const initialState$d = issueCommentAdapter.getInitialState({});
+  const initialState$5 = issueCommentAdapter.getInitialState({});
   const issueCommentSlice = toolkit.createSlice({
     name: "issueComments",
-    initialState: initialState$d,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
+    initialState: initialState$5,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
     reducers: {
       addIssueComment: issueCommentAdapter.addOne,
       addIssueComments: issueCommentAdapter.addMany,
@@ -2762,11 +2925,11 @@ var __publicField = (obj, key, value) => {
   );
   const issueCommentReducer = issueCommentSlice.reducer;
   const issueUpdateAdapter = createModelAdapter((issueUpdate) => issueUpdate.offline_id);
-  const initialState$c = issueUpdateAdapter.getInitialState({});
+  const initialState$4 = issueUpdateAdapter.getInitialState({});
   const issueUpdateSlice = toolkit.createSlice({
     name: "issueUpdates",
-    initialState: initialState$c,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
+    initialState: initialState$4,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
     reducers: {
       initializeIssueUpdates: issueUpdateAdapter.setMany,
       setIssueUpdate: issueUpdateAdapter.setOne,
@@ -2795,11 +2958,11 @@ var __publicField = (obj, key, value) => {
   );
   const issueUpdateReducer = issueUpdateSlice.reducer;
   const issueAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$b = issueAttachmentAdapter.getInitialState({});
+  const initialState$3 = issueAttachmentAdapter.getInitialState({});
   const issueAttachmentSlice = toolkit.createSlice({
     name: "issueAttachments",
-    initialState: initialState$b,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
+    initialState: initialState$3,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$3)),
     reducers: {
       initializeIssueAttachments: issueAttachmentAdapter.initialize,
       addIssueAttachment: issueAttachmentAdapter.addOne,
@@ -2857,23 +3020,23 @@ var __publicField = (obj, key, value) => {
     )
   );
   const issueAttachmentReducer = issueAttachmentSlice.reducer;
-  const initialState$a = {
+  const initialState$2 = {
     version: 0
   };
   const versioningSlice = toolkit.createSlice({
     name: "versioning",
-    initialState: initialState$a,
+    initialState: initialState$2,
     reducers: {}
   });
   const versioningReducer = versioningSlice.reducer;
   const geoImageAdapter = createModelAdapter((model) => model.offline_id);
-  const initialState$9 = geoImageAdapter.getInitialState({});
+  const initialState$1 = geoImageAdapter.getInitialState({});
   const geoImageSlice = toolkit.createSlice({
     name: "geoImages",
-    initialState: initialState$9,
+    initialState: initialState$1,
     extraReducers: (builder) => {
       builder.addCase("RESET", (state) => {
-        Object.assign(state, initialState$9);
+        Object.assign(state, initialState$1);
       });
     },
     reducers: {
@@ -2911,11 +3074,11 @@ var __publicField = (obj, key, value) => {
   );
   const geoImageReducer = geoImageSlice.reducer;
   const issueAssociationAdapter = createModelAdapter((assoc) => assoc.offline_id);
-  const initialState$8 = issueAssociationAdapter.getInitialState({});
+  const initialState = issueAssociationAdapter.getInitialState({});
   const issueAssociationSlice = toolkit.createSlice({
     name: "issueAssociations",
-    initialState: initialState$8,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
+    initialState,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState)),
     reducers: {
       initializeIssueAssociations: issueAssociationAdapter.initialize,
       addIssueAssociation: issueAssociationAdapter.addOne,
@@ -2973,432 +3136,32 @@ var __publicField = (obj, key, value) => {
     )
   );
   const issueAssociationReducer = issueAssociationSlice.reducer;
-  const issueTypeFieldValuesAdapter = createModelAdapter(
-    (fieldValues) => fieldValues.offline_id
-  );
-  const initialState$7 = issueTypeFieldValuesAdapter.getInitialState({});
-  const issueTypeFieldValuesSlice = toolkit.createSlice({
-    name: "issueTypeFieldValues",
-    initialState: initialState$7,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
-    reducers: {
-      initializeIssueTypeFieldValues: issueTypeFieldValuesAdapter.initialize,
-      addIssueTypeFieldValues: issueTypeFieldValuesAdapter.addOne,
-      addIssueTypeFieldValuesMany: issueTypeFieldValuesAdapter.addMany,
-      setIssueTypeFieldValues: issueTypeFieldValuesAdapter.setOne,
-      setIssueTypeFieldValuesMany: issueTypeFieldValuesAdapter.setMany,
-      updateIssueTypeFieldValues: issueTypeFieldValuesAdapter.updateOne,
-      updateIssueTypeFieldValuesMany: issueTypeFieldValuesAdapter.updateMany,
-      deleteIssueTypeFieldValues: issueTypeFieldValuesAdapter.deleteOne,
-      deleteIssueTypeFieldValuesMany: issueTypeFieldValuesAdapter.deleteMany
-    }
-  });
-  const {
-    initializeIssueTypeFieldValues,
-    addIssueTypeFieldValues,
-    addIssueTypeFieldValuesMany,
-    setIssueTypeFieldValues,
-    setIssueTypeFieldValuesMany,
-    updateIssueTypeFieldValues,
-    updateIssueTypeFieldValuesMany,
-    deleteIssueTypeFieldValues,
-    deleteIssueTypeFieldValuesMany
-  } = issueTypeFieldValuesSlice.actions;
-  const selectIssueTypeFieldValuesMapping = (state) => state.issueTypeFieldValuesReducer.instances;
-  const selectIssueTypeFieldValues = toolkit.createSelector([selectIssueTypeFieldValuesMapping], (fieldValuesMapping) => {
-    return Object.values(fieldValuesMapping);
-  });
-  const selectIssueTypeFieldValuesOfIssue = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectIssueTypeFieldValues, (_state, issueId) => issueId], (fieldValues, issueId) => {
-      return fallbackToEmptyArray(fieldValues.filter((fieldValue) => fieldValue.issue === issueId));
-    })
-  );
-  const selectIssueTypeFieldValuesById = (fieldValuesId) => (state) => {
-    return state.issueTypeFieldValuesReducer.instances[fieldValuesId];
-  };
-  const issueTypeFieldValuesReducer = issueTypeFieldValuesSlice.reducer;
-  const issueTypeFieldsAdapter = createModelAdapter((fields) => fields.offline_id);
-  const initialState$6 = issueTypeFieldsAdapter.getInitialState({});
-  const issueTypeFieldsSlice = toolkit.createSlice({
-    name: "issueTypeFields",
-    initialState: initialState$6,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
-    reducers: {
-      initializeIssueTypeFields: issueTypeFieldsAdapter.initialize,
-      addIssueTypeFields: issueTypeFieldsAdapter.addOne,
-      addIssueTypeFieldsMany: issueTypeFieldsAdapter.addMany,
-      setIssueTypeFields: issueTypeFieldsAdapter.setOne,
-      setIssueTypeFieldsMany: issueTypeFieldsAdapter.setMany,
-      updateIssueTypeFields: issueTypeFieldsAdapter.updateOne,
-      updateIssueTypeFieldsMany: issueTypeFieldsAdapter.updateMany,
-      deleteIssueTypeFields: issueTypeFieldsAdapter.deleteOne,
-      deleteIssueTypeFieldsMany: issueTypeFieldsAdapter.deleteMany
+  let clientStore;
+  function setClientStore(store) {
+    clientStore = store;
+  }
+  function getClientStore() {
+    return clientStore;
+  }
+  let clientSDK;
+  function setClientSDK(sdkCtor) {
+    clientSDK = sdkCtor;
+  }
+  function getClientSDK() {
+    return clientSDK;
+  }
+  const CLASS_NAME_TO_SERVICE = {};
+  class BaseService {
+    constructor(sdk) {
+      __publicField(this, "client");
+      CLASS_NAME_TO_SERVICE[this.constructor.name] = this;
+      this.client = sdk;
     }
-  });
-  const {
-    initializeIssueTypeFields,
-    addIssueTypeFields,
-    addIssueTypeFieldsMany,
-    setIssueTypeFields,
-    setIssueTypeFieldsMany,
-    updateIssueTypeFields,
-    updateIssueTypeFieldsMany,
-    deleteIssueTypeFields,
-    deleteIssueTypeFieldsMany
-  } = issueTypeFieldsSlice.actions;
-  const selectIssueTypeFieldsMapping = (state) => state.issueTypeFieldsReducer.instances;
-  const selectIssueTypeFields = toolkit.createSelector([selectIssueTypeFieldsMapping], (fieldsMapping) => {
-    return Object.values(fieldsMapping);
-  });
-  const selectIssueTypeFieldsOfIssueType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectIssueTypeFields, (_state, issueTypeId) => issueTypeId], (fields, issueTypeId) => {
-      return fallbackToEmptyArray(fields.filter((field) => field.issue_type === issueTypeId));
-    })
-  );
-  const selectLatestIssueTypeFieldsOfIssueType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectIssueTypeFields, (_state, id) => id], (fields, id) => {
-      return fields.filter((field) => field.issue_type === id).sort((a, b) => a.submitted_at > b.submitted_at ? -1 : 1)[0];
-    })
-  );
-  const selectIssueTypeValuesOfIssueType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueTypeFields, selectIssueTypeFieldValues, (_state, id) => id],
-      (fields, fieldValues, id) => {
-        const fieldsIds = new Set(
-          fields.filter((field) => field.issue_type === id).map((field) => field.offline_id)
-        );
-        return fallbackToEmptyArray(fieldValues.filter((values) => fieldsIds.has(values.fields_revision)));
-      }
-    )
-  );
-  const selectIssueTypeFieldsById = (fieldsId) => (state) => {
-    return state.issueTypeFieldsReducer.instances[fieldsId];
-  };
-  const issueTypeFieldsReducer = issueTypeFieldsSlice.reducer;
-  const issueTypeFieldsAttachmentAdapter = createModelAdapter(
-    (attachment) => attachment.offline_id
-  );
-  const initialState$5 = issueTypeFieldsAttachmentAdapter.getInitialState({});
-  const issueTypeFieldsAttachmentSlice = toolkit.createSlice({
-    name: "issueTypeFieldsAttachments",
-    initialState: initialState$5,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
-    reducers: {
-      initializeIssueTypeFieldsAttachments: issueTypeFieldsAttachmentAdapter.initialize,
-      addIssueTypeFieldsAttachment: issueTypeFieldsAttachmentAdapter.addOne,
-      addIssueTypeFieldsAttachments: issueTypeFieldsAttachmentAdapter.addMany,
-      setIssueTypeFieldsAttachment: issueTypeFieldsAttachmentAdapter.setOne,
-      setIssueTypeFieldsAttachments: issueTypeFieldsAttachmentAdapter.setMany,
-      updateIssueTypeFieldsAttachment: issueTypeFieldsAttachmentAdapter.updateOne,
-      updateIssueTypeFieldsAttachments: issueTypeFieldsAttachmentAdapter.updateMany,
-      deleteIssueTypeFieldsAttachment: issueTypeFieldsAttachmentAdapter.deleteOne,
-      deleteIssueTypeFieldsAttachments: issueTypeFieldsAttachmentAdapter.deleteMany
+    async enqueueRequest(requestDetails) {
+      return this.client.enqueueRequest(requestDetails, this.host, this.constructor.name);
     }
-  });
-  const {
-    initializeIssueTypeFieldsAttachments,
-    addIssueTypeFieldsAttachment,
-    addIssueTypeFieldsAttachments,
-    setIssueTypeFieldsAttachment,
-    setIssueTypeFieldsAttachments,
-    updateIssueTypeFieldsAttachment,
-    updateIssueTypeFieldsAttachments,
-    deleteIssueTypeFieldsAttachment,
-    deleteIssueTypeFieldsAttachments
-  } = issueTypeFieldsAttachmentSlice.actions;
-  const selectIssueTypeFieldsAttachmentsMapping = (state) => state.issueTypeFieldsAttachmentReducer.instances;
-  const selectIssueTypeFieldsAttachments = toolkit.createSelector(
-    [selectIssueTypeFieldsAttachmentsMapping],
-    (attachmentsMapping) => {
-      return Object.values(attachmentsMapping);
-    }
-  );
-  const selectAttachmentsOfIssueTypeFields = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueTypeFieldsAttachments, (_state, fieldsRevision) => fieldsRevision],
-      (attachments, fieldsRevision) => {
-        return fallbackToEmptyArray(
-          attachments.filter((attachment) => attachment.fields_revision === fieldsRevision)
-        );
-      }
-    )
-  );
-  const selectIssueTypeFieldsAttachmentById = (attachmentId) => (state) => {
-    return state.issueTypeFieldsAttachmentReducer.instances[attachmentId];
-  };
-  const issueTypeFieldsAttachmentReducer = issueTypeFieldsAttachmentSlice.reducer;
-  const issueTypeFieldValuesAttachmentAdapter = createModelAdapter(
-    (attachment) => attachment.offline_id
-  );
-  const initialState$4 = issueTypeFieldValuesAttachmentAdapter.getInitialState({});
-  const issueTypeFieldValuesAttachmentSlice = toolkit.createSlice({
-    name: "issueTypeFieldValuesAttachments",
-    initialState: initialState$4,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
-    reducers: {
-      initializeIssueTypeFieldValuesAttachments: issueTypeFieldValuesAttachmentAdapter.initialize,
-      addIssueTypeFieldValuesAttachment: issueTypeFieldValuesAttachmentAdapter.addOne,
-      addIssueTypeFieldValuesAttachments: issueTypeFieldValuesAttachmentAdapter.addMany,
-      setIssueTypeFieldValuesAttachment: issueTypeFieldValuesAttachmentAdapter.setOne,
-      setIssueTypeFieldValuesAttachments: issueTypeFieldValuesAttachmentAdapter.setMany,
-      updateIssueTypeFieldValuesAttachment: issueTypeFieldValuesAttachmentAdapter.updateOne,
-      updateIssueTypeFieldValuesAttachments: issueTypeFieldValuesAttachmentAdapter.updateMany,
-      deleteIssueTypeFieldValuesAttachment: issueTypeFieldValuesAttachmentAdapter.deleteOne,
-      deleteIssueTypeFieldValuesAttachments: issueTypeFieldValuesAttachmentAdapter.deleteMany
-    }
-  });
-  const {
-    initializeIssueTypeFieldValuesAttachments,
-    addIssueTypeFieldValuesAttachment,
-    addIssueTypeFieldValuesAttachments,
-    setIssueTypeFieldValuesAttachment,
-    setIssueTypeFieldValuesAttachments,
-    updateIssueTypeFieldValuesAttachment,
-    updateIssueTypeFieldValuesAttachments,
-    deleteIssueTypeFieldValuesAttachment,
-    deleteIssueTypeFieldValuesAttachments
-  } = issueTypeFieldValuesAttachmentSlice.actions;
-  const selectIssueTypeFieldValuesAttachmentsMapping = (state) => state.issueTypeFieldValuesAttachmentReducer.instances;
-  const selectIssueTypeFieldValuesAttachments = toolkit.createSelector(
-    [selectIssueTypeFieldValuesAttachmentsMapping],
-    (attachmentsMapping) => {
-      return Object.values(attachmentsMapping);
-    }
-  );
-  const selectAttachmentsOfIssueTypeFieldValues = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectIssueTypeFieldValuesAttachments, (_state, fieldValuesId) => fieldValuesId],
-      (attachments, fieldValuesId) => {
-        return fallbackToEmptyArray(attachments.filter((attachment) => attachment.field_values === fieldValuesId));
-      }
-    )
-  );
-  const selectIssueTypeFieldValuesAttachmentById = (attachmentId) => (state) => {
-    return state.issueTypeFieldValuesAttachmentReducer.instances[attachmentId];
-  };
-  const issueTypeFieldValuesAttachmentReducer = issueTypeFieldValuesAttachmentSlice.reducer;
-  const assetTypeFieldsAdapter = createModelAdapter((fields) => fields.offline_id);
-  const initialState$3 = assetTypeFieldsAdapter.getInitialState({});
-  const assetTypeFieldsSlice = toolkit.createSlice({
-    name: "assetTypeFields",
-    initialState: initialState$3,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$3)),
-    reducers: {
-      initializeAssetTypeFields: assetTypeFieldsAdapter.initialize,
-      addAssetTypeFields: assetTypeFieldsAdapter.addOne,
-      addAssetTypeFieldsMany: assetTypeFieldsAdapter.addMany,
-      setAssetTypeFields: assetTypeFieldsAdapter.setOne,
-      setAssetTypeFieldsMany: assetTypeFieldsAdapter.setMany,
-      updateAssetTypeFields: assetTypeFieldsAdapter.updateOne,
-      updateAssetTypeFieldsMany: assetTypeFieldsAdapter.updateMany,
-      deleteAssetTypeFields: assetTypeFieldsAdapter.deleteOne,
-      deleteAssetTypeFieldsMany: assetTypeFieldsAdapter.deleteMany
-    }
-  });
-  const {
-    initializeAssetTypeFields,
-    addAssetTypeFields,
-    addAssetTypeFieldsMany,
-    setAssetTypeFields,
-    setAssetTypeFieldsMany,
-    updateAssetTypeFields,
-    updateAssetTypeFieldsMany,
-    deleteAssetTypeFields,
-    deleteAssetTypeFieldsMany
-  } = assetTypeFieldsSlice.actions;
-  const selectAssetTypeFieldsMapping = (state) => state.assetTypeFieldsReducer.instances;
-  const selectAssetTypeFields = toolkit.createSelector([selectAssetTypeFieldsMapping], (fieldsMapping) => {
-    return Object.values(fieldsMapping);
-  });
-  const selectAssetTypeFieldsOfAssetType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectAssetTypeFields, (_state, assetTypeId) => assetTypeId], (fields, assetTypeId) => {
-      return fallbackToEmptyArray(fields.filter((field) => field.asset_type === assetTypeId));
-    })
-  );
-  const selectLatestAssetTypeFieldsOfAssetType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectAssetTypeFields, (_state, id) => id], (fields, id) => {
-      return fields.filter((field) => field.asset_type === id).sort((a, b) => a.submitted_at > b.submitted_at ? -1 : 1)[0];
-    })
-  );
-  const selectAssetTypeFieldsById = (fieldsId) => (state) => {
-    return state.assetTypeFieldsReducer.instances[fieldsId];
-  };
-  const assetTypeFieldsReducer = assetTypeFieldsSlice.reducer;
-  const assetTypeFieldValuesAdapter = createModelAdapter(
-    (fieldValues) => fieldValues.offline_id
-  );
-  const initialState$2 = assetTypeFieldValuesAdapter.getInitialState({});
-  const assetTypeFieldValuesSlice = toolkit.createSlice({
-    name: "assetTypeFieldValues",
-    initialState: initialState$2,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$2)),
-    reducers: {
-      initializeAssetTypeFieldValues: assetTypeFieldValuesAdapter.initialize,
-      addAssetTypeFieldValues: assetTypeFieldValuesAdapter.addOne,
-      addAssetTypeFieldValuesMany: assetTypeFieldValuesAdapter.addMany,
-      setAssetTypeFieldValues: assetTypeFieldValuesAdapter.setOne,
-      setAssetTypeFieldValuesMany: assetTypeFieldValuesAdapter.setMany,
-      updateAssetTypeFieldValues: assetTypeFieldValuesAdapter.updateOne,
-      updateAssetTypeFieldValuesMany: assetTypeFieldValuesAdapter.updateMany,
-      deleteAssetTypeFieldValues: assetTypeFieldValuesAdapter.deleteOne,
-      deleteAssetTypeFieldValuesMany: assetTypeFieldValuesAdapter.deleteMany
-    }
-  });
-  const {
-    initializeAssetTypeFieldValues,
-    addAssetTypeFieldValues,
-    addAssetTypeFieldValuesMany,
-    setAssetTypeFieldValues,
-    setAssetTypeFieldValuesMany,
-    updateAssetTypeFieldValues,
-    updateAssetTypeFieldValuesMany,
-    deleteAssetTypeFieldValues,
-    deleteAssetTypeFieldValuesMany
-  } = assetTypeFieldValuesSlice.actions;
-  const selectAssetTypeFieldValuesMapping = (state) => state.assetTypeFieldValuesReducer.instances;
-  const selectAssetTypeFieldValues = toolkit.createSelector([selectAssetTypeFieldValuesMapping], (fieldValuesMapping) => {
-    return Object.values(fieldValuesMapping);
-  });
-  const selectAssetTypeFieldValuesOfAsset = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectAssetTypeFieldValues, (_state, assetId) => assetId], (fieldValues, assetId) => {
-      return fallbackToEmptyArray(fieldValues.filter((fieldValue) => fieldValue.asset === assetId));
-    })
-  );
-  const selectAssetTypeValuesOfAssetType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAssetTypeFields, selectAssetTypeFieldValues, (_state, id) => id],
-      (fields, fieldValues, id) => {
-        const fieldsIds = new Set(
-          fields.filter((field) => field.asset_type === id).map((field) => field.offline_id)
-        );
-        return fallbackToEmptyArray(fieldValues.filter((values) => fieldsIds.has(values.fields_revision)));
-      }
-    )
-  );
-  const selectAssetTypeFieldValuesById = (fieldValuesId) => (state) => {
-    return state.assetTypeFieldValuesReducer.instances[fieldValuesId];
-  };
-  const assetTypeFieldValuesReducer = assetTypeFieldValuesSlice.reducer;
-  const assetTypeFieldsAttachmentAdapter = createModelAdapter(
-    (attachment) => attachment.offline_id
-  );
-  const initialState$1 = assetTypeFieldsAttachmentAdapter.getInitialState({});
-  const assetTypeFieldsAttachmentSlice = toolkit.createSlice({
-    name: "assetTypeFieldsAttachments",
-    initialState: initialState$1,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$1)),
-    reducers: {
-      initializeAssetTypeFieldsAttachments: assetTypeFieldsAttachmentAdapter.initialize,
-      addAssetTypeFieldsAttachment: assetTypeFieldsAttachmentAdapter.addOne,
-      addAssetTypeFieldsAttachments: assetTypeFieldsAttachmentAdapter.addMany,
-      setAssetTypeFieldsAttachment: assetTypeFieldsAttachmentAdapter.setOne,
-      setAssetTypeFieldsAttachments: assetTypeFieldsAttachmentAdapter.setMany,
-      updateAssetTypeFieldsAttachment: assetTypeFieldsAttachmentAdapter.updateOne,
-      updateAssetTypeFieldsAttachments: assetTypeFieldsAttachmentAdapter.updateMany,
-      deleteAssetTypeFieldsAttachment: assetTypeFieldsAttachmentAdapter.deleteOne,
-      deleteAssetTypeFieldsAttachments: assetTypeFieldsAttachmentAdapter.deleteMany
-    }
-  });
-  const {
-    initializeAssetTypeFieldsAttachments,
-    addAssetTypeFieldsAttachment,
-    addAssetTypeFieldsAttachments,
-    setAssetTypeFieldsAttachment,
-    setAssetTypeFieldsAttachments,
-    updateAssetTypeFieldsAttachment,
-    updateAssetTypeFieldsAttachments,
-    deleteAssetTypeFieldsAttachment,
-    deleteAssetTypeFieldsAttachments
-  } = assetTypeFieldsAttachmentSlice.actions;
-  const selectAssetTypeFieldsAttachmentsMapping = (state) => state.assetTypeFieldsAttachmentReducer.instances;
-  const selectAssetTypeFieldsAttachments = toolkit.createSelector(
-    [selectAssetTypeFieldsAttachmentsMapping],
-    (attachmentsMapping) => {
-      return Object.values(attachmentsMapping);
-    }
-  );
-  const selectAttachmentsOfAssetTypeFields = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectAssetTypeFieldsAttachments, (_state, id) => id], (attachments, id) => {
-      return fallbackToEmptyArray(attachments.filter((attachment) => attachment.fields_revision === id));
-    })
-  );
-  const selectAssetTypeFieldsAttachmentById = (attachmentId) => (state) => {
-    return state.assetTypeFieldsAttachmentReducer.instances[attachmentId];
-  };
-  const assetTypeFieldsAttachmentReducer = assetTypeFieldsAttachmentSlice.reducer;
-  const assetTypeFieldValuesAttachmentAdapter = createModelAdapter(
-    (attachment) => attachment.offline_id
-  );
-  const initialState = assetTypeFieldValuesAttachmentAdapter.getInitialState({});
-  const assetTypeFieldValuesAttachmentSlice = toolkit.createSlice({
-    name: "assetTypeFieldValuesAttachments",
-    initialState,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState)),
-    reducers: {
-      initializeAssetTypeFieldValuesAttachments: assetTypeFieldValuesAttachmentAdapter.initialize,
-      addAssetTypeFieldValuesAttachment: assetTypeFieldValuesAttachmentAdapter.addOne,
-      addAssetTypeFieldValuesAttachments: assetTypeFieldValuesAttachmentAdapter.addMany,
-      setAssetTypeFieldValuesAttachment: assetTypeFieldValuesAttachmentAdapter.setOne,
-      setAssetTypeFieldValuesAttachments: assetTypeFieldValuesAttachmentAdapter.setMany,
-      updateAssetTypeFieldValuesAttachment: assetTypeFieldValuesAttachmentAdapter.updateOne,
-      updateAssetTypeFieldValuesAttachments: assetTypeFieldValuesAttachmentAdapter.updateMany,
-      deleteAssetTypeFieldValuesAttachment: assetTypeFieldValuesAttachmentAdapter.deleteOne,
-      deleteAssetTypeFieldValuesAttachments: assetTypeFieldValuesAttachmentAdapter.deleteMany
-    }
-  });
-  const {
-    initializeAssetTypeFieldValuesAttachments,
-    addAssetTypeFieldValuesAttachment,
-    addAssetTypeFieldValuesAttachments,
-    setAssetTypeFieldValuesAttachment,
-    setAssetTypeFieldValuesAttachments,
-    updateAssetTypeFieldValuesAttachment,
-    updateAssetTypeFieldValuesAttachments,
-    deleteAssetTypeFieldValuesAttachment,
-    deleteAssetTypeFieldValuesAttachments
-  } = assetTypeFieldValuesAttachmentSlice.actions;
-  const selectAssetTypeFieldValuesAttachmentsMapping = (state) => state.assetTypeFieldValuesAttachmentReducer.instances;
-  const selectAssetTypeFieldValuesAttachments = toolkit.createSelector(
-    [selectAssetTypeFieldValuesAttachmentsMapping],
-    (attachmentsMapping) => {
-      return Object.values(attachmentsMapping);
-    }
-  );
-  const selectAttachmentsOfAssetTypeFieldValues = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectAssetTypeFieldValuesAttachments, (_state, id) => id], (attachments, id) => {
-      return fallbackToEmptyArray(attachments.filter((attachment) => attachment.field_values === id));
-    })
-  );
-  const selectAssetTypeFieldValuesAttachmentById = (attachmentId) => (state) => {
-    return state.assetTypeFieldValuesAttachmentReducer.instances[attachmentId];
-  };
-  const assetTypeFieldValuesAttachmentReducer = assetTypeFieldValuesAttachmentSlice.reducer;
-  let clientStore;
-  function setClientStore(store) {
-    clientStore = store;
-  }
-  function getClientStore() {
-    return clientStore;
-  }
-  let clientSDK;
-  function setClientSDK(sdkCtor) {
-    clientSDK = sdkCtor;
-  }
-  function getClientSDK() {
-    return clientSDK;
-  }
-  const CLASS_NAME_TO_SERVICE = {};
-  class BaseService {
-    constructor(sdk) {
-      __publicField(this, "client");
-      CLASS_NAME_TO_SERVICE[this.constructor.name] = this;
-      this.client = sdk;
-    }
-    async enqueueRequest(requestDetails) {
-      return this.client.enqueueRequest(requestDetails, this.host, this.constructor.name);
-    }
-    dispatch(action) {
-      this.client.store.dispatch(action);
+    dispatch(action) {
+      this.client.store.dispatch(action);
     }
   }
   const VERSION_REDUCER_KEY = "versioning";
@@ -3441,15 +3204,7 @@ var __publicField = (obj, key, value) => {
     issueCommentReducer,
     issueUpdateReducer,
     geoImageReducer,
-    issueAssociationReducer,
-    issueTypeFieldsReducer,
-    issueTypeFieldValuesReducer,
-    issueTypeFieldsAttachmentReducer,
-    issueTypeFieldValuesAttachmentReducer,
-    assetTypeFieldsReducer,
-    assetTypeFieldValuesReducer,
-    assetTypeFieldsAttachmentReducer,
-    assetTypeFieldValuesAttachmentReducer
+    issueAssociationReducer
   };
   const overmapReducer = toolkit.combineReducers(overmapReducers);
   const resetStore = "RESET";
@@ -4091,6 +3846,9 @@ var __publicField = (obj, key, value) => {
         description: "Create Category",
         method: HttpMethod.POST,
         url: "/categories/",
+        queryParams: {
+          workspace_id: payload.workspace.toString()
+        },
         payload: offlineCategory,
         blockers: [payload.workspace],
         blocks: [offlineCategory.offline_id]
@@ -4303,10 +4061,7 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get assets",
         method: HttpMethod.GET,
-        url: "/assets/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/assets/`,
         blockers: [],
         blocks: []
       });
@@ -4327,7 +4082,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add asset stage completion",
         method: HttpMethod.POST,
-        url: "/asset-stage-completions/",
+        url: "/assets/completions/",
         payload: {
           offline_id: offlineStageCompletion.offline_id,
           submitted_at: submittedAt,
@@ -4354,7 +4109,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete asset stage completion",
         method: HttpMethod.DELETE,
-        url: `/asset-stage-completions/${id}/`,
+        url: `/assets/completions/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -4380,7 +4135,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Bulk create asset stage completions",
         method: HttpMethod.POST,
-        url: "/asset-stage-completions/bulk/",
+        url: "/assets/completions/bulk/",
         payload: {
           submitted_at: submittedAt,
           completions: payload
@@ -4402,7 +4157,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Deleting asset stage completions",
         method: HttpMethod.DELETE,
-        url: "/asset-stage-completions/bulk/",
+        url: "/assets/completions/bulk/",
         payload: {
           completion_ids: ids
         },
@@ -4418,10 +4173,7 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get asset stage completions",
         method: HttpMethod.GET,
-        url: "/asset-stage-completions/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/asset-stage-completions/`,
         blockers: [],
         blocks: []
       });
@@ -4442,7 +4194,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add asset stages",
         method: HttpMethod.POST,
-        url: "/asset-stages/bulk/",
+        url: "/assets/stages/bulk/",
         payload: {
           submitted_at: submittedAt,
           asset_type: assetTypeId,
@@ -4466,7 +4218,7 @@ var __publicField = (obj, key, value) => {
       return this.enqueueRequest({
         description: "Edit asset stages",
         method: HttpMethod.PATCH,
-        url: `/asset-types/${assetTypeId}/bulk-update-stages/`,
+        url: `/assets/types/${assetTypeId}/bulk-update-stages/`,
         payload: {
           stages: stagesToUpdate
         },
@@ -4484,7 +4236,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete asset stages",
         method: HttpMethod.DELETE,
-        url: "/asset-stages/bulk/",
+        url: "/assets/stages/bulk/",
         payload: {
           stage_ids: idsToDelete
         },
@@ -4509,7 +4261,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Update asset stage",
         method: HttpMethod.PATCH,
-        url: `/asset-stages/${assetStage.offline_id}/`,
+        url: `/assets/stages/${assetStage.offline_id}/`,
         payload: {
           name: payload.name,
           description: payload.description,
@@ -4537,7 +4289,7 @@ var __publicField = (obj, key, value) => {
         await this.enqueueRequest({
           description: "Link asset stage to form",
           method: HttpMethod.POST,
-          url: `/asset-stages/${stageId}/associate-with-form/`,
+          url: `/assets/stages/${stageId}/associate-with-form/`,
           payload: { form: formId },
           blockers: [stageId, formId],
           blocks: [stageId]
@@ -4558,7 +4310,7 @@ var __publicField = (obj, key, value) => {
         await this.enqueueRequest({
           description: "Unlink asset stage from form",
           method: HttpMethod.DELETE,
-          url: `/asset-stages/${stageId}/associate-with-form/`,
+          url: `/assets/stages/${stageId}/associate-with-form/`,
           blockers: [stageId, formId],
           blocks: [stageId]
         });
@@ -4571,10 +4323,7 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get asset stages",
         method: HttpMethod.GET,
-        url: "/asset-stages/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/asset-stages/`,
         blockers: [],
         blocks: []
       });
@@ -4591,12 +4340,7 @@ var __publicField = (obj, key, value) => {
         projectAttachmentReducer: projectAttachmentReducer2,
         formRevisionAttachmentReducer: formRevisionAttachmentReducer2,
         formSubmissionAttachmentReducer: formSubmissionAttachmentReducer2,
-        geoImageReducer: geoImageReducer2,
-        // fields
-        assetTypeFieldsAttachmentReducer: assetTypeFieldsAttachmentReducer2,
-        assetTypeFieldValuesAttachmentReducer: assetTypeFieldValuesAttachmentReducer2,
-        issueTypeFieldsAttachmentReducer: issueTypeFieldsAttachmentReducer2,
-        issueTypeFieldValuesAttachmentReducer: issueTypeFieldValuesAttachmentReducer2
+        geoImageReducer: geoImageReducer2
       } = this.client.store.getState();
       const objectsWithSha1 = [].concat(
         Object.values(issueAttachmentReducer2.instances),
@@ -4606,11 +4350,7 @@ var __publicField = (obj, key, value) => {
         Object.values(projectAttachmentReducer2.instances),
         Object.values(formRevisionAttachmentReducer2.instances),
         Object.values(formSubmissionAttachmentReducer2.instances),
-        Object.values(geoImageReducer2.instances),
-        Object.values(assetTypeFieldsAttachmentReducer2.instances),
-        Object.values(assetTypeFieldValuesAttachmentReducer2.instances),
-        Object.values(issueTypeFieldsAttachmentReducer2.instances),
-        Object.values(issueTypeFieldValuesAttachmentReducer2.instances)
+        Object.values(geoImageReducer2.instances)
       );
       return objectsWithSha1.filter((object) => object.file_sha1 === sha1).length;
     }
@@ -4632,20 +4372,41 @@ var __publicField = (obj, key, value) => {
       }
       return promisesBySha1;
     }
-    async getFilePayload(file) {
-      const sha1 = await hashFile(file);
-      const filePayload = {
-        sha1,
-        file_type: file.type,
-        extension: file.name.split(".").pop(),
-        size: file.size
-      };
-      await this.client.files.addCache(file, sha1);
-      return filePayload;
-    }
   }
+  const AttachmentModelMeta = {
+    [AttachmentModel.Issue]: {
+      name: "issue",
+      attachUrlPrefix: "/issues",
+      deleteUrlPrefix: "/issues",
+      fetchUrlPostfix: "/issue-attachments"
+    },
+    [AttachmentModel.Asset]: {
+      name: "asset",
+      attachUrlPrefix: "/assets",
+      deleteUrlPrefix: "/assets",
+      fetchUrlPostfix: "/asset-attachments"
+    },
+    [AttachmentModel.AssetType]: {
+      name: "asset type",
+      attachUrlPrefix: "/assets/types",
+      deleteUrlPrefix: "/assets/types",
+      fetchUrlPostfix: "/asset-type-attachments"
+    },
+    [AttachmentModel.Project]: {
+      name: "project",
+      attachUrlPrefix: "/projects",
+      deleteUrlPrefix: "/projects",
+      fetchUrlPostfix: "/attachments"
+    },
+    [AttachmentModel.Document]: {
+      name: "document",
+      attachUrlPrefix: "/documents",
+      deleteUrlPrefix: "/documents",
+      fetchUrlPostfix: "/document-attachments"
+    }
+  };
   class BaseAttachmentService extends BaseUploadService {
-    async _bulkAdd(payloads) {
+    async attachFiles(files, modelId, buildOfflineAttachment) {
       var _a2;
       const { store } = this.client;
       const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
@@ -4653,36 +4414,39 @@ var __publicField = (obj, key, value) => {
       const offlineAttachments = [];
       const attachmentPayloads = [];
       const filePayloads = {};
-      for (const payload of payloads) {
-        const { modelId, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
-        const offlineAttachment = this.buildOfflineAttachment({
+      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,
-          file_sha1: filePayload.sha1,
-          submitted_at: submittedAt,
-          created_by: createdBy,
+          sha1,
+          submittedAt,
+          createdBy,
           description: "",
           modelId
         });
         offlineAttachments.push(offlineAttachment);
-        attachmentPayloads.push(
-          this.buildAttachmentPayload({
-            offline_id: offlineAttachment.offline_id,
-            file_name: offlineAttachment.file_name,
-            file_sha1: offlineAttachment.file_sha1,
-            file_extension: filePayload.extension,
-            description: offlineAttachment.description,
-            modelId
-          })
-        );
+        attachmentPayloads.push({
+          offline_id: offlineAttachment.offline_id,
+          name: offlineAttachment.file_name,
+          sha1: offlineAttachment.file_sha1,
+          description: offlineAttachment.description
+        });
       }
       this.dispatch(this.addAttachments(offlineAttachments));
+      const meta = AttachmentModelMeta[this.attachmentModel];
       const promise = this.enqueueRequest({
-        description: `Add ${this.name}`,
+        description: `Attach files to ${meta.name}`,
         method: HttpMethod.POST,
-        url: `${this.url}/bulk/`,
+        url: `${meta.attachUrlPrefix}/${modelId}/attach/`,
         payload: {
           submitted_at: submittedAt,
           attachments: attachmentPayloads,
@@ -4699,7 +4463,7 @@ var __publicField = (obj, key, value) => {
       });
       return [offlineAttachments, promise.then(({ attachments }) => attachments)];
     }
-    async _delete(attachmendId) {
+    async deleteAttachment(attachmendId) {
       const { store } = this.client;
       const attachment = this.selectAttachment(attachmendId)(store.getState());
       if (!attachment) {
@@ -4708,10 +4472,11 @@ var __publicField = (obj, key, value) => {
         );
       }
       this.dispatch(this.removeAttachment(attachment.offline_id));
+      const meta = AttachmentModelMeta[this.attachmentModel];
       const promise = this.enqueueRequest({
-        description: `Delete ${this.name}`,
+        description: "Delete attachment",
         method: HttpMethod.DELETE,
-        url: `${this.url}/${attachmendId}/`,
+        url: `${meta.deleteUrlPrefix}/attachments/${attachmendId}/`,
         blockers: [attachmendId],
         blocks: []
       });
@@ -4724,12 +4489,24 @@ var __publicField = (obj, key, value) => {
       });
       return promise;
     }
+    // Note that currently the fetching of attachments for all models dependds on the active projectId. This may change in the future. And
+    //  so for some attachment model services, this method will have to be overridden.
+    async refreshStore(projectId, _organizationId) {
+      const meta = AttachmentModelMeta[this.attachmentModel];
+      const result = await this.enqueueRequest({
+        description: `Get ${meta.name} attachments`,
+        method: HttpMethod.GET,
+        url: `/projects/${projectId}${meta.fetchUrlPostfix}/`,
+        blocks: [],
+        blockers: []
+      });
+      this.dispatch(this.initializeAttachments(result));
+    }
   }
   class AssetAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "name", "Asset Attachment");
-      __publicField(this, "url", "/asset-attachments");
+      __publicField(this, "attachmentModel", AttachmentModel.Asset);
       __publicField(this, "initializeAttachments", initializeAssetAttachments);
       __publicField(this, "addAttachments", addAssetAttachments);
       __publicField(this, "updateAttachments", updateAssetAttachments);
@@ -4741,39 +4518,20 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.file_sha1,
-        created_by: data.created_by,
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submitted_at,
+        submitted_at: data.submittedAt,
         description: data.description,
         asset: data.modelId
       });
     }
-    buildAttachmentPayload(data) {
-      return {
-        ...data,
-        asset: data.modelId
-      };
-    }
-    async bulkAdd(payloads) {
-      return this._bulkAdd(payloads.map((p) => ({ modelId: p.assetId, file: p.file })));
-    }
-    async delete(id) {
-      return this._delete(id);
+    async attachFilesToAsset(files, assetId) {
+      return this.attachFiles(files, assetId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get asset attachments",
-        method: HttpMethod.GET,
-        url: `${this.url}/`,
-        queryParams: {
-          project: projectId.toString()
-        },
-        blocks: [],
-        blockers: []
-      });
-      this.dispatch(initializeAssetAttachments(result));
+    async deleteAssetAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class AssetTypeService extends BaseApiService {
@@ -4790,7 +4548,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Create asset type",
         method: HttpMethod.POST,
-        url: "/asset-types/",
+        url: `/projects/${payload.project}/asset-types/`,
         payload: { ...offlineAssetType },
         blockers: [],
         blocks: [offlineAssetType.offline_id]
@@ -4816,7 +4574,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Update asset type",
         method: HttpMethod.PATCH,
-        url: `/asset-types/${payload.offline_id}/`,
+        url: `/assets/types/${payload.offline_id}/`,
         payload: {
           icon: payload.icon,
           color: payload.color,
@@ -4850,7 +4608,7 @@ var __publicField = (obj, key, value) => {
       return this.enqueueRequest({
         description: "Delete asset type",
         method: HttpMethod.DELETE,
-        url: `/asset-types/${assetTypeId}/`,
+        url: `/assets/types/${assetTypeId}/`,
         blockers: [assetTypeId],
         blocks: []
       }).catch((e) => {
@@ -4865,10 +4623,7 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get asset types",
         method: HttpMethod.GET,
-        url: "/asset-types/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/asset-types/`,
         blockers: [],
         blocks: []
       });
@@ -4878,8 +4633,8 @@ var __publicField = (obj, key, value) => {
   class AssetTypeAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "name", "Asset Type Attachment");
-      __publicField(this, "url", "/asset-type-attachments");
+      __publicField(this, "attachmentModel", AttachmentModel.AssetType);
+      __publicField(this, "initializeAttachments", initializeAssetTypeAttachments);
       __publicField(this, "addAttachments", addAssetTypeAttachments);
       __publicField(this, "updateAttachments", updateAssetTypeAttachments);
       __publicField(this, "removeAttachments", deleteAssetTypeAttachments);
@@ -4890,39 +4645,20 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.file_sha1,
-        created_by: data.created_by,
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submitted_at,
+        submitted_at: data.submittedAt,
         description: data.description,
         asset_type: data.modelId
       });
     }
-    buildAttachmentPayload(data) {
-      return {
-        ...data,
-        asset_type: data.modelId
-      };
-    }
-    async bulkAdd(payloads) {
-      return this._bulkAdd(payloads.map((p) => ({ modelId: p.assetTypeId, file: p.file })));
+    async attachFilesToAssetType(files, assetTypeId) {
+      return this.attachFiles(files, assetTypeId, this.buildOfflineAttachment.bind(this));
     }
-    async delete(attachmentId) {
-      return this._delete(attachmentId);
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get asset type attachments",
-        method: HttpMethod.GET,
-        url: `${this.url}/`,
-        queryParams: {
-          project: projectId.toString()
-        },
-        blocks: [],
-        blockers: []
-      });
-      this.dispatch(initializeAssetTypeAttachments(result));
+    async deleteAssetTypeAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class IssueCommentService extends BaseApiService {
@@ -4938,7 +4674,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add issue comment",
         method: HttpMethod.POST,
-        url: "/issue-comments/",
+        url: `/issues/${payload.issue}/comment/`,
         payload: offlineComment,
         blockers: [payload.issue],
         blocks: [offlineComment.offline_id]
@@ -4962,7 +4698,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Edit issue comment",
         method: HttpMethod.PATCH,
-        url: `/issue-comments/${payload.offline_id}/`,
+        url: `/issues/comments/${payload.offline_id}/`,
         payload,
         blockers: [payload.offline_id],
         blocks: [payload.offline_id]
@@ -4981,7 +4717,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete comment",
         method: HttpMethod.DELETE,
-        url: `/issue-comments/${id}/`,
+        url: `/issues/comments/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -4994,10 +4730,7 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get comments",
         method: HttpMethod.GET,
-        url: "/issue-comments/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/comments/`,
         blockers: [],
         blocks: []
       });
@@ -5009,21 +4742,27 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get issue updates",
         method: HttpMethod.GET,
-        url: "/issue-updates/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/issues/updates/`,
         blockers: [],
         blocks: []
       });
-      this.dispatch(initializeIssueUpdates(result));
+      let filteredResult = result.filter(onlyUniqueOfflineIds);
+      filteredResult = filteredResult.map((comment) => {
+        return { ...comment };
+      });
+      if (result.length !== filteredResult.length) {
+        console.error(
+          `Received duplicate comments from the API (new length ${filteredResult.length}); filtered in browser.`
+        );
+      }
+      this.dispatch(initializeIssueUpdates(filteredResult));
     }
   }
   class IssueAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "name", "Issue Attachment");
-      __publicField(this, "url", "/issue-attachments");
+      __publicField(this, "attachmentModel", AttachmentModel.Issue);
+      __publicField(this, "initializeAttachments", initializeIssueAttachments);
       __publicField(this, "addAttachments", addIssueAttachments);
       __publicField(this, "updateAttachments", updateIssueAttachments);
       __publicField(this, "removeAttachments", deleteIssueAttachments);
@@ -5034,42 +4773,24 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.file_sha1,
-        created_by: data.created_by,
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submitted_at,
+        submitted_at: data.submittedAt,
         description: data.description,
         issue: data.modelId
       });
     }
-    buildAttachmentPayload(data) {
-      return {
-        ...data,
-        issue: data.modelId
-      };
-    }
-    async bulkAdd(payloads) {
-      return this._bulkAdd(payloads.map((p) => ({ modelId: p.issueId, file: p.file })));
-    }
-    async delete(id) {
-      return this._delete(id);
+    async attachFilesToIssue(files, issueId) {
+      return this.attachFiles(files, issueId, this.buildOfflineAttachment.bind(this));
     }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get issue attachments",
-        method: HttpMethod.GET,
-        url: `${this.url}/`,
-        queryParams: {
-          project: projectId.toString()
-        },
-        blocks: [],
-        blockers: []
-      });
-      this.dispatch(initializeIssueAttachments(result));
+    async deleteIssueAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class IssueService extends BaseApiService {
+    // Basic CRUD functions
     add(payload) {
       var _a2;
       const { store } = this.client;
@@ -5087,6 +4808,10 @@ var __publicField = (obj, key, value) => {
         description: "Create issue",
         method: HttpMethod.POST,
         url: "/issues/",
+        queryParams: {
+          workspace_id: payload.index_workspace,
+          ...payload.issue_type ? { issue_type: payload.issue_type } : {}
+        },
         payload: offlineIssue,
         blockers: ["add-issue", ...offlineIssue.index_workspace ? [offlineIssue.index_workspace] : []],
         blocks: [offlineIssue.offline_id]
@@ -5242,10 +4967,7 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get issues",
         method: HttpMethod.GET,
-        url: "/issues/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/issues/`,
         blockers: [],
         blocks: []
       });
@@ -5265,8 +4987,16 @@ var __publicField = (obj, key, value) => {
       this.dispatch(addIssueType(offlineIssueType));
       const promise = this.enqueueRequest({
         method: HttpMethod.POST,
-        url: "/issue-types/",
-        payload: offlineIssueType,
+        url: `/organizations/${payload.organization}/issue-types/`,
+        // Sending only whats needed here
+        payload: {
+          offline_id: offlineIssueType.offline_id,
+          submitted_at: offlineIssueType.submitted_at,
+          icon: offlineIssueType.icon,
+          color: offlineIssueType.color,
+          name: offlineIssueType.name,
+          description: offlineIssueType.description
+        },
         blockers: [],
         blocks: [offlineIssueType.offline_id]
       });
@@ -5291,7 +5021,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(updateIssueType(offlineUpdatedIssueType));
       const promise = this.enqueueRequest({
         method: HttpMethod.PATCH,
-        url: `/issue-types/${payload.offline_id}/`,
+        url: `/issues/types/${payload.offline_id}/`,
         payload,
         blockers: [payload.offline_id],
         blocks: [payload.offline_id]
@@ -5315,7 +5045,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(deleteIssues(issuesOfIssueType.map((issue) => issue.offline_id)));
       const promise = this.enqueueRequest({
         method: HttpMethod.DELETE,
-        url: `/issue-types/${id}/`,
+        url: `/issues/types/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -5328,10 +5058,7 @@ var __publicField = (obj, key, value) => {
     async refreshStore(organizationId) {
       const result = await this.enqueueRequest({
         method: HttpMethod.GET,
-        url: "/issue-types/",
-        queryParams: {
-          organization: organizationId.toString()
-        },
+        url: `/organizations/${organizationId}/issue-types/`,
         blockers: [],
         blocks: []
       });
@@ -5475,8 +5202,8 @@ var __publicField = (obj, key, value) => {
   class ProjectAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "name", "Project Attachment");
-      __publicField(this, "url", "/project-attachments");
+      __publicField(this, "attachmentModel", AttachmentModel.Project);
+      __publicField(this, "initializeAttachments", initializeProjectAttachments);
       __publicField(this, "addAttachments", addProjectAttachments);
       __publicField(this, "updateAttachments", updateProjectAttachments);
       __publicField(this, "removeAttachments", deleteProjectAttachments);
@@ -5487,39 +5214,20 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.file_sha1,
-        created_by: data.created_by,
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submitted_at,
+        submitted_at: data.submittedAt,
         description: data.description,
         project: data.modelId
       });
     }
-    buildAttachmentPayload(data) {
-      return {
-        ...data,
-        project: data.modelId
-      };
-    }
-    async bulkAdd(payloads) {
-      return this._bulkAdd(payloads.map((p) => ({ modelId: p.projectId, file: p.file })));
+    async attachFilesToProject(files, projectId) {
+      return this.attachFiles(files, projectId, this.buildOfflineAttachment.bind(this));
     }
-    async delete(attachmentId) {
-      return this._delete(attachmentId);
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get project attachments",
-        method: HttpMethod.GET,
-        url: `${this.url}/`,
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeProjectAttachments(result));
+    async deleteProjectAttachment(attachmentId) {
+      return this.deleteAttachment(attachmentId);
     }
   }
   class ProjectService extends BaseApiService {
@@ -5662,76 +5370,224 @@ var __publicField = (obj, key, value) => {
     return { fields: newFields, images };
   };
   class FormService extends BaseUploadService {
-    add(payload, initialRevision) {
+    async bulkAddRevisionAttachments(revisionId, files) {
       var _a2;
-      const { store } = this.client;
       const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const offlineForm = offline({
-        ...payload,
-        submitted_at: submittedAt,
-        created_by: createdBy
-      });
-      const offlineFormRevision = offline({
-        ...initialRevision,
-        form: offlineForm.offline_id,
-        revision: "Pending",
-        submitted_at: submittedAt,
-        created_by: createdBy
-      });
-      this.dispatch(addForm(offlineForm));
-      this.dispatch(addFormRevision(offlineFormRevision));
-      const formPromise = this.enqueueRequest({
-        description: "Create form",
+      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
+      const filePayloads = {};
+      const offlineFormRevisionAttachments = [];
+      const attachmentPayloads = [];
+      for (const [fieldIdentifier, file] of Object.entries(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 offlineFormRevisionAttachment = offline({
+          file: URL.createObjectURL(file),
+          file_type: file.type,
+          file_name: file.name,
+          file_sha1: sha1,
+          created_by: createdBy,
+          revision: revisionId,
+          submitted_at: submittedAt,
+          field_identifier: fieldIdentifier
+        });
+        offlineFormRevisionAttachments.push(offlineFormRevisionAttachment);
+        const attachmentPayload = {
+          offline_id: offlineFormRevisionAttachment.offline_id,
+          name: file.name,
+          field_identifier: fieldIdentifier,
+          sha1
+        };
+        attachmentPayloads.push(attachmentPayload);
+      }
+      this.dispatch(addFormRevisionAttachments(offlineFormRevisionAttachments));
+      const promise = this.enqueueRequest({
+        description: "Attach files to form revision",
         method: HttpMethod.POST,
-        url: "/forms/",
+        url: `/forms/revisions/${revisionId}/attachments/bulk/`,
         payload: {
-          // Sending exactly what is currently needed for the endpoint
-          offline_id: offlineForm.offline_id,
-          submitted_at: offlineForm.submitted_at,
-          initial_revision: {
-            offline_id: offlineFormRevision.offline_id,
-            submitted_at: offlineFormRevision.submitted_at,
-            title: offlineFormRevision.title,
-            description: offlineFormRevision.description,
-            fields: offlineFormRevision.fields
-          }
+          submitted_at: submittedAt,
+          attachments: attachmentPayloads,
+          files: Object.values(filePayloads)
         },
-        blockers: [
-          ...payload.project ? [payload.project.toString()] : [],
-          ...payload.organization ? [payload.organization.toString()] : []
-        ],
-        blocks: [offlineForm.offline_id, offlineFormRevision.offline_id]
+        blockers: [revisionId],
+        blocks: offlineFormRevisionAttachments.map((attachment) => attachment.offline_id)
+      });
+      promise.then((result) => {
+        this.processPresignedUrls(result.presigned_urls);
+        this.dispatch(updateFormRevisionAttachments(result.attachments));
+      }).catch(() => {
+        this.dispatch(
+          deleteFormRevisionAttachments(
+            offlineFormRevisionAttachments.map((attachment) => attachment.offline_id)
+          )
+        );
+      });
+      return [offlineFormRevisionAttachments, promise.then(({ attachments }) => attachments)];
+    }
+    async add(ownerId, form, initialRevision, urlPrefix) {
+      const { fields, images } = await separateImageFromFields(initialRevision.fields);
+      const offlineFormRevision = offline({
+        ...initialRevision,
+        fields,
+        created_by: form.created_by,
+        form: form.offline_id,
+        submitted_at: form.submitted_at,
+        revision: "Pending"
+      });
+      this.dispatch(addForm(form));
+      this.dispatch(addFormRevision(offlineFormRevision));
+      const formPromise = this.enqueueRequest({
+        description: "Create form",
+        method: HttpMethod.POST,
+        url: urlPrefix,
+        payload: {
+          // Sending exactly what is currently needed for the endpoint
+          offline_id: form.offline_id,
+          submitted_at: form.submitted_at,
+          initial_revision: {
+            offline_id: offlineFormRevision.offline_id,
+            submitted_at: offlineFormRevision.submitted_at,
+            title: offlineFormRevision.title,
+            description: offlineFormRevision.description,
+            fields: offlineFormRevision.fields
+          }
+        },
+        blockers: [ownerId],
+        blocks: [form.offline_id, offlineFormRevision.offline_id]
       });
+      const [offlineFormRevisionAttachments, attachmentsPromise] = await this.bulkAddRevisionAttachments(
+        offlineFormRevision.offline_id,
+        images
+      );
       void formPromise.catch((e) => {
-        this.dispatch(deleteForm(offlineForm.offline_id));
+        this.dispatch(deleteForm(form.offline_id));
         this.dispatch(deleteFormRevision(offlineFormRevision.offline_id));
         throw e;
       });
-      return [offlineForm, offlineFormRevision, formPromise];
+      return [form, offlineFormRevision, offlineFormRevisionAttachments, formPromise, attachmentsPromise];
     }
-    async delete(id) {
+    addForOrganization(organizationId, initialRevision) {
+      var _a2;
+      const state = this.client.store.getState();
+      const offlineForm = offline({
+        favorite: false,
+        created_by: (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id,
+        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        organization: organizationId
+      });
+      return this.add(
+        organizationId.toString(),
+        offlineForm,
+        initialRevision,
+        `/organizations/${organizationId}/create-form/`
+      );
+    }
+    addForProject(projectId, initialRevision) {
+      var _a2;
+      const state = this.client.store.getState();
+      const offlineForm = offline({
+        favorite: false,
+        created_by: (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id,
+        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        project: projectId
+      });
+      return this.add(projectId.toString(), offlineForm, initialRevision, `/projects/${projectId}/create-form/`);
+    }
+    addForIssueType(issueTypeId, initialRevision) {
+      var _a2;
+      const state = this.client.store.getState();
+      const offlineForm = offline({
+        favorite: false,
+        created_by: (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id,
+        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        issue_type: issueTypeId
+      });
+      return this.add(issueTypeId, offlineForm, initialRevision, `/issues/types/${issueTypeId}/create-form/`);
+    }
+    addForAssetType(assetTypeId, initialRevision) {
+      var _a2;
+      const state = this.client.store.getState();
+      const offlineForm = offline({
+        favorite: false,
+        created_by: (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id,
+        submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        asset_type: assetTypeId
+      });
+      return this.add(assetTypeId, offlineForm, initialRevision, `/assets/types/${assetTypeId}/create-form/`);
+    }
+    async createRevision(formId, revision) {
+      var _a2;
+      const offlineRevision = offline(revision);
+      const { store } = this.client;
+      const state = store.getState();
+      const createdBy = (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id;
+      const { fields, images } = await separateImageFromFields(offlineRevision.fields);
+      const fullRevision = {
+        ...offlineRevision,
+        fields,
+        created_by: createdBy,
+        revision: "Pending",
+        form: formId,
+        submitted_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.dispatch(addFormRevision(fullRevision));
+      const promise = this.enqueueRequest({
+        description: "Create form revision",
+        method: HttpMethod.PATCH,
+        url: `/forms/${formId}/`,
+        payload: {
+          initial_revision: {
+            offline_id: fullRevision.offline_id,
+            submitted_at: fullRevision.submitted_at,
+            title: fullRevision.title,
+            description: fullRevision.description,
+            fields: fullRevision.fields
+          }
+        },
+        blockers: [formId],
+        blocks: [offlineRevision.offline_id]
+      });
+      const [offlineFormRevisionAttachments, attachmentsPromise] = await this.bulkAddRevisionAttachments(
+        fullRevision.offline_id,
+        images
+      );
+      void promise.then((result) => {
+        this.dispatch(setFormRevision(result));
+      }).catch(() => {
+        this.dispatch(deleteFormRevision(fullRevision.offline_id));
+      });
+      return [fullRevision, offlineFormRevisionAttachments, promise, attachmentsPromise];
+    }
+    async delete(formId) {
       const { store } = this.client;
       const state = store.getState();
-      const form = selectFormById(id)(state);
+      const form = selectFormById(formId)(state);
       if (!form) {
         throw new Error("Expected form to exist");
       }
-      const formSubmissions = selectFormSubmissionsOfForm(id)(state);
+      const formSubmissions = selectFormSubmissionsOfForm(formId)(state);
       if (formSubmissions.length > 0) {
         this.dispatch(deleteFormSubmissions(formSubmissions.map(({ offline_id }) => offline_id)));
       }
-      const formRevisions = selectFormRevisionsOfForm(id)(state);
+      const formRevisions = selectFormRevisionsOfForm(formId)(state);
       if (formRevisions.length > 0) {
         this.dispatch(deleteFormRevisions(formRevisions.map(({ offline_id }) => offline_id)));
       }
-      this.dispatch(deleteForm(id));
+      this.dispatch(deleteForm(formId));
       try {
         return await this.enqueueRequest({
           description: "Delete form",
           method: HttpMethod.DELETE,
-          url: `/forms/${id}/`,
-          blockers: [id],
+          url: `/forms/${formId}/`,
+          blockers: [formId],
           blocks: []
         });
       } catch (e) {
@@ -5745,31 +5601,65 @@ var __publicField = (obj, key, value) => {
         throw e;
       }
     }
-    async refreshStore(projectId, organizationId) {
-      let forms = [];
-      const projectForms = await this.enqueueRequest({
+    async refreshStore(projectId) {
+      const forms = [];
+      const revisions = [];
+      const attachments = [];
+      const projectFormsResult = await this.enqueueRequest({
         description: "Fetch project forms",
         method: HttpMethod.GET,
-        url: "/forms/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/projects/${projectId}/forms/`,
         blockers: [projectId.toString()],
         blocks: []
       });
-      forms = forms.concat(projectForms);
-      const organizationForms = await this.enqueueRequest({
+      for (const form of projectFormsResult.forms)
+        forms.push(form);
+      for (const revision of projectFormsResult.revisions)
+        revisions.push(revision);
+      for (const attachment of projectFormsResult.attachments)
+        attachments.push(attachment);
+      const organizationFormsResult = await this.enqueueRequest({
         description: "Fetch organization forms",
         method: HttpMethod.GET,
-        url: "/forms/",
-        queryParams: {
-          organization: organizationId.toString()
-        },
-        blockers: [organizationId.toString()],
+        url: `/projects/${projectId}/organizations/forms/`,
+        blockers: [projectId.toString()],
+        blocks: []
+      });
+      for (const form of organizationFormsResult.forms)
+        forms.push(form);
+      for (const revision of organizationFormsResult.revisions)
+        revisions.push(revision);
+      for (const attachment of organizationFormsResult.attachments)
+        attachments.push(attachment);
+      const assetTypeFormsResult = await this.enqueueRequest({
+        description: "Fetch asset type forms",
+        method: HttpMethod.GET,
+        url: `/projects/${projectId}/asset-types/forms/`,
+        blockers: [projectId.toString()],
+        blocks: []
+      });
+      for (const form of assetTypeFormsResult.forms)
+        forms.push(form);
+      for (const revision of assetTypeFormsResult.revisions)
+        revisions.push(revision);
+      for (const attachment of assetTypeFormsResult.attachments)
+        attachments.push(attachment);
+      const issueTypeFormsResult = await this.enqueueRequest({
+        description: "Fetch issue type forms",
+        method: HttpMethod.GET,
+        url: `/projects/${projectId}/issue-types/forms/`,
+        blockers: [projectId.toString()],
         blocks: []
       });
-      forms = forms.concat(organizationForms);
+      for (const form of issueTypeFormsResult.forms)
+        forms.push(form);
+      for (const revision of issueTypeFormsResult.revisions)
+        revisions.push(revision);
+      for (const attachment of issueTypeFormsResult.attachments)
+        attachments.push(attachment);
       this.dispatch(initializeForms(forms));
+      this.dispatch(initializeFormRevisions(revisions));
+      this.dispatch(initializeFormRevisionAttachments(attachments));
     }
   }
   const isArrayOfFiles = (value) => {
@@ -5791,11 +5681,95 @@ var __publicField = (obj, key, value) => {
     return { values: newValues, files };
   };
   class FormSubmissionService extends BaseUploadService {
-    add(payload) {
+    async bulkAddSubmissionAttachments(submissionId, files) {
+      var _a2;
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
+      const filePayloads = {};
+      const offlineFormSubmissionAttachments = [];
+      const attachmentPayloads = [];
+      for (const [fieldIdentifier, filesArray] of Object.entries(files)) {
+        for (const file of filesArray) {
+          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 offlineFormSubmissionAttachment = offline({
+            file: URL.createObjectURL(file),
+            file_type: file.type,
+            file_name: file.name,
+            file_sha1: sha1,
+            created_by: createdBy,
+            submission: submissionId,
+            submitted_at: submittedAt,
+            field_identifier: fieldIdentifier
+          });
+          offlineFormSubmissionAttachments.push(offlineFormSubmissionAttachment);
+          const attachmentPayload = {
+            offline_id: offlineFormSubmissionAttachment.offline_id,
+            name: file.name,
+            sha1,
+            field_identifier: fieldIdentifier
+          };
+          attachmentPayloads.push(attachmentPayload);
+        }
+      }
+      this.dispatch(addFormSubmissionAttachments(offlineFormSubmissionAttachments));
+      const promise = this.enqueueRequest({
+        description: "Attach files to form submission",
+        method: HttpMethod.POST,
+        url: `/forms/submissions/${submissionId}/attachments/bulk/`,
+        payload: {
+          submitted_at: submittedAt,
+          attachments: attachmentPayloads,
+          files: Object.values(filePayloads)
+        },
+        blockers: [submissionId],
+        blocks: offlineFormSubmissionAttachments.map((attachment) => attachment.offline_id)
+      });
+      promise.then((result) => {
+        this.processPresignedUrls(result.presigned_urls);
+        this.dispatch(updateFormSubmissionAttachments(result.attachments));
+      }).catch(() => {
+        this.dispatch(
+          deleteFormSubmissionAttachments(
+            offlineFormSubmissionAttachments.map((attachment) => attachment.offline_id)
+          )
+        );
+      });
+      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) {
       var _a2;
       const { store } = this.client;
       const state = store.getState();
-      const { values } = separateFilesFromValues(payload.values);
+      const { values, files } = separateFilesFromValues(payload.values);
       const offlineSubmission = offline({
         ...payload,
         values,
@@ -5805,7 +5779,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Respond to form",
         method: HttpMethod.POST,
-        url: "/form-submissions/",
+        url: `/forms/revisions/${payload.form_revision}/respond/`,
         payload: offlineSubmission,
         blockers: [payload.issue, payload.asset, payload.asset_stage, "add-form-entry"].filter(
           (x) => x !== void 0
@@ -5813,6 +5787,10 @@ var __publicField = (obj, key, value) => {
         blocks: [offlineSubmission.offline_id]
       });
       this.dispatch(addFormSubmission(offlineSubmission));
+      const [offlineFormSubmissionAttachments, attachmentsPromise] = await this.bulkAddSubmissionAttachments(
+        offlineSubmission.offline_id,
+        files
+      );
       promise.then((result) => {
         this.dispatch(addActiveProjectFormSubmissionsCount(1));
         this.dispatch(setFormSubmission(result));
@@ -5821,16 +5799,115 @@ var __publicField = (obj, key, value) => {
         this.dispatch(deleteFormSubmission(offlineSubmission.offline_id));
         this.dispatch(addActiveProjectFormSubmissionsCount(-1));
       });
-      return [offlineSubmission, promise];
+      return [offlineSubmission, offlineFormSubmissionAttachments, promise, attachmentsPromise];
     }
-    update(payload) {
+    // Note currently the bulkAdd method is specific to form submissions for assets
+    // TODO: adapt the support bulk adding to any model type
+    async bulkAdd(args, batchSize) {
+      const { formRevision, commonFieldValues, fieldValuesByAsset } = args;
+      const { values: fileSeperatedCommonFieldValues, files: commonFiles } = separateFilesFromValues(commonFieldValues);
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const transactionId = uuid.v4();
+      const assetIdBatches = chunkArray(Object.keys(fieldValuesByAsset), batchSize);
+      const bulkAddBatches = await Promise.all(
+        assetIdBatches.map(async (assetIdBatch) => {
+          const batchId = uuid.v4();
+          const submissionPayloads = [];
+          const attachmentPayloads = [];
+          const files = { ...commonFiles };
+          for (const assetId of assetIdBatch) {
+            const { values: fileSeperatedSubmissionSpecificValues, files: submissionSpecificFiles } = separateFilesFromValues(fieldValuesByAsset[assetId] ?? {});
+            Object.assign(files, submissionSpecificFiles);
+            const submissionPayload = offline({
+              asset_id: assetId,
+              form_data: fileSeperatedSubmissionSpecificValues
+            });
+            submissionPayloads.push(submissionPayload);
+            for (const [fieldIdentifier, fileArray] of Object.entries(files)) {
+              for (const file of fileArray) {
+                const sha1 = await hashFile(file);
+                await this.client.files.addCache(file, sha1);
+                const attachmentPayload = offline({
+                  submission_id: submissionPayload.offline_id,
+                  sha1,
+                  name: file.name,
+                  field_identifier: fieldIdentifier
+                });
+                attachmentPayloads.push(attachmentPayload);
+              }
+            }
+          }
+          const filePaylods = [];
+          for (const file of Object.values(files).flat()) {
+            const sha1 = await hashFile(file);
+            const filePayload = {
+              sha1,
+              extension: file.name.split(".").pop() || "",
+              file_type: file.type,
+              size: file.size
+            };
+            filePaylods.push(filePayload);
+          }
+          return {
+            batchId,
+            payload: {
+              transaction_id: transactionId,
+              form_data: fileSeperatedCommonFieldValues,
+              submitted_at: submittedAt,
+              submissions: submissionPayloads,
+              attachments: attachmentPayloads,
+              files: filePaylods
+            }
+          };
+        })
+      );
+      const batchPromises = [];
+      let prevBatchId = null;
+      for (const batch of bulkAddBatches) {
+        const { payload, batchId } = batch;
+        const batchAssetIds = payload.submissions.map((x) => x.asset_id);
+        const batchSubmissionOfflineIds = payload.submissions.map((x) => x.offline_id);
+        const batchAttachmentsOfflineIds = payload.attachments.map((x) => x.offline_id);
+        const blockers = batchAssetIds;
+        if (prevBatchId)
+          blockers.push(prevBatchId);
+        const blocks2 = [...batchSubmissionOfflineIds, ...batchAttachmentsOfflineIds, batchId];
+        const promise = this.enqueueRequest({
+          description: "Bulk add form submissions",
+          method: HttpMethod.POST,
+          url: `/forms/revisions/${formRevision}/bulk-respond/`,
+          payload,
+          blockers,
+          blocks: blocks2
+        });
+        void promise.then(({ presigned_urls }) => {
+          this.processPresignedUrls(presigned_urls);
+        });
+        prevBatchId = batchId;
+        batchPromises.push(promise);
+      }
+      void Promise.all(batchPromises).then((results) => {
+        const createdSubmissions = [];
+        const createdAttachments = [];
+        for (const result of results) {
+          for (const createdSubmission of result.submissions)
+            createdSubmissions.push(createdSubmission);
+          for (const createdAttachment of result.attachments)
+            createdAttachments.push(createdAttachment);
+        }
+        this.dispatch(addFormSubmissions(createdSubmissions));
+        this.dispatch(addFormSubmissionAttachments(createdAttachments));
+      });
+      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 } = separateFilesFromValues(payload.values ?? {});
+      const { values, files } = separateFilesFromValues(payload.values ?? {});
       const updatedSubmission = {
         ...submissionToBeUpdated,
         ...payload,
@@ -5844,36 +5921,57 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete user form submissions",
         method: HttpMethod.PATCH,
-        url: `/form-submissions/${updatedSubmission.offline_id}/`,
+        url: `/forms/submissions/${updatedSubmission.offline_id}/`,
         // TODO: send just payload when FormSubmissionDeserializer is updated to handle partial updates
         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, promise];
+      return [
+        updatedSubmission,
+        offlineFormSubmissionAttachments,
+        promise,
+        attachmentsPromise,
+        deleteAttachmentsPromise
+      ];
     }
-    async delete(id) {
+    async delete(submissionId) {
       const { store } = this.client;
       const state = store.getState();
-      const submissionToBeDeleted = selectFormSubmissionById(id)(state);
+      const submissionToBeDeleted = selectFormSubmissionById(submissionId)(state);
       if (!submissionToBeDeleted) {
-        throw new Error(`Expected submission with offline_id ${id} to exist`);
+        throw new Error(`Expected submission with offline_id ${submissionId} to exist`);
       }
-      const submissionAttachments = selectAttachmentsOfFormSubmission(id)(state);
-      this.dispatch(deleteFormSubmission(id));
+      const submissionAttachments = selectAttachmentsOfFormSubmission(submissionId)(state);
+      this.dispatch(deleteFormSubmission(submissionId));
       this.dispatch(addActiveProjectFormSubmissionsCount(-1));
       this.dispatch(deleteFormSubmissionAttachments(submissionAttachments.map((x) => x.offline_id)));
       try {
         return await this.enqueueRequest({
           description: "Delete user form submissions",
           method: HttpMethod.DELETE,
-          url: `/form-submissions/${id}/`,
-          blockers: [id],
+          url: `/forms/submissions/${submissionId}/`,
+          blockers: [submissionId],
           blocks: []
         });
       } catch (e) {
@@ -5884,17 +5982,50 @@ var __publicField = (obj, key, value) => {
       }
     }
     async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Fetch form submissions",
+      const formSubmissions = {};
+      const modelSubmissions = await this.enqueueRequest({
+        description: "Fetch model submissions",
         method: HttpMethod.GET,
-        url: "/form-submissions/",
-        queryParams: {
-          project: projectId.toString()
-        },
+        url: `/forms/in-project/${projectId}/submissions/model/latest/`,
+        blockers: [],
+        blocks: []
+      });
+      for (const modelSubmission of modelSubmissions) {
+        formSubmissions[modelSubmission.offline_id] = modelSubmission;
+      }
+      const standaloneSubmissions = await this.enqueueRequest({
+        description: "Fetch standalone submissions",
+        method: HttpMethod.GET,
+        url: `/forms/in-project/${projectId}/submissions/standalone/`,
+        blockers: [],
+        blocks: []
+      });
+      for (const standaloneSubmission of standaloneSubmissions) {
+        formSubmissions[standaloneSubmission.offline_id] = standaloneSubmission;
+      }
+      this.dispatch(initializeFormSubmissions(Object.values(formSubmissions)));
+      const attachments = {};
+      const modelAttachments = await this.enqueueRequest({
+        description: "Fetch model submission attachments",
+        method: HttpMethod.GET,
+        url: `/forms/in-project/${projectId}/attachments/model/latest/`,
+        blockers: [],
+        blocks: []
+      });
+      for (const modelAttachment of modelAttachments) {
+        attachments[modelAttachment.offline_id] = modelAttachment;
+      }
+      const standaloneAttachments = await this.enqueueRequest({
+        description: "Fetch standalone submission attachments",
+        method: HttpMethod.GET,
+        url: `/forms/in-project/${projectId}/attachments/standalone/`,
         blockers: [],
         blocks: []
       });
-      this.dispatch(initializeFormSubmissions(result));
+      for (const standaloneAttachent of standaloneAttachments) {
+        attachments[standaloneAttachent.offline_id] = standaloneAttachent;
+      }
+      this.dispatch(initializeFormSubmissionAttachments(Object.values(attachments)));
     }
   }
   class WorkspaceService extends BaseApiService {
@@ -5946,22 +6077,22 @@ var __publicField = (obj, key, value) => {
       });
       return [workspace, promise];
     }
-    delete(id) {
+    delete(workspaceId) {
       const { store } = this.client;
-      const originalWorkspace = selectWorkspaceById(id)(store.getState());
-      if (!originalWorkspace) {
-        throw new Error(`Expected an existing workspace with id ${id}`);
-      }
-      this.dispatch(deleteWorkspace(id));
+      const originalWorkspace = selectWorkspaceById(workspaceId)(store.getState());
+      this.dispatch(deleteWorkspace(workspaceId));
       const promise = this.enqueueRequest({
         description: "Delete Workspace",
         method: HttpMethod.DELETE,
-        url: `/workspaces/${id}/`,
-        blockers: [id],
+        url: `/workspaces/${workspaceId}/`,
+        blockers: [workspaceId],
         blocks: []
       });
-      void promise.catch((reason) => {
-        this.dispatch(addWorkspace(originalWorkspace));
+      void promise.then(() => {
+      }).catch((reason) => {
+        if (originalWorkspace) {
+          this.dispatch(addWorkspace(originalWorkspace));
+        }
         throw reason;
       });
       return promise;
@@ -6596,8 +6727,8 @@ var __publicField = (obj, key, value) => {
   class DocumentAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "name", "Document Attachment");
-      __publicField(this, "url", "/document-attachments");
+      __publicField(this, "attachmentModel", AttachmentModel.Document);
+      __publicField(this, "initializeAttachments", initializeDocumentAttachments);
       __publicField(this, "addAttachments", addDocumentAttachments);
       __publicField(this, "updateAttachments", updateDocumentAttachments);
       __publicField(this, "removeAttachments", deleteDocumentAttachments);
@@ -6608,23 +6739,17 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.file_sha1,
-        created_by: data.created_by,
+        file_sha1: data.sha1,
+        created_by: data.createdBy,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submitted_at,
+        submitted_at: data.submittedAt,
         description: data.description,
         document: data.modelId
       });
     }
-    buildAttachmentPayload(data) {
-      return {
-        ...data,
-        document: data.modelId
-      };
-    }
     // NOTE: overriding the method from BaseAttachmentService since document attachments get vectorized
-    async bulkAdd(payloads) {
+    async attachFilesToDocument(files, documentId) {
       var _a2;
       const { store } = this.client;
       const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
@@ -6633,36 +6758,40 @@ var __publicField = (obj, key, value) => {
       const attachmentPayloads = [];
       const filePayloads = {};
       const sha1ToAttachmentIds = {};
-      for (const payload of payloads) {
-        const { documentId, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads)) {
-          filePayloads[filePayload.sha1] = filePayload;
-          sha1ToAttachmentIds[filePayload.sha1] = [];
+      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,
-          file_sha1: filePayload.sha1,
-          submitted_at: submittedAt,
-          created_by: createdBy,
+          sha1,
+          submittedAt,
+          createdBy,
           description: "",
           modelId: documentId
         });
         offlineAttachments.push(offlineAttachment);
         attachmentPayloads.push({
           offline_id: offlineAttachment.offline_id,
-          file_name: offlineAttachment.file_name,
-          file_sha1: offlineAttachment.file_sha1,
-          file_extension: filePayload.extension,
+          name: offlineAttachment.file_name,
+          sha1: offlineAttachment.file_sha1,
           description: offlineAttachment.description
         });
-        sha1ToAttachmentIds[filePayload.sha1].push(offlineAttachment.offline_id);
+        sha1ToAttachmentIds[sha1].push(offlineAttachment.offline_id);
       }
       this.dispatch(this.addAttachments(offlineAttachments));
       const promise = this.enqueueRequest({
         description: "Attach files to document",
         method: HttpMethod.POST,
-        url: "/document-attachments/bulk/",
+        url: `/documents/${documentId}/attach/`,
         payload: {
           submitted_at: submittedAt,
           attachments: attachmentPayloads,
@@ -6687,14 +6816,14 @@ var __publicField = (obj, key, value) => {
       });
       return [offlineAttachments, promise.then(({ attachments }) => attachments)];
     }
-    async delete(id) {
-      return this._delete(id);
+    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}/`,
+        url: `/documents/attachments/${attachmnentId}/`,
         payload: {
           readable_to_assistant: true
         },
@@ -6711,7 +6840,7 @@ var __publicField = (obj, key, value) => {
         blocks: [],
         blockers: []
       });
-      this.dispatch(initializeDocumentAttachments(projectDocumentAttachments));
+      this.dispatch(this.initializeAttachments(projectDocumentAttachments));
       const organizationDocumentAttachments = await this.enqueueRequest({
         description: "Get document attachments",
         method: HttpMethod.GET,
@@ -6846,21 +6975,21 @@ var __publicField = (obj, key, value) => {
       });
       return [offlineUpdatedTeam, promise];
     }
-    async delete(id) {
+    async delete(teamId) {
       const { store } = this.client;
       const state = store.getState();
-      const team = selectTeamById(id)(state);
+      const team = selectTeamById(teamId)(state);
       if (!team) {
-        throw new Error(`Expected team with id ${id} to exist`);
+        throw new Error(`Expected team with id ${teamId} to exist`);
       }
-      this.dispatch(deleteTeam(id));
+      this.dispatch(deleteTeam(teamId));
       try {
         return await this.enqueueRequest({
           description: "Delete team",
           method: HttpMethod.DELETE,
-          url: `/organizations/teams/${id}/`,
-          blockers: [id],
-          blocks: [id]
+          url: `/organizations/teams/${teamId}/`,
+          blockers: [teamId],
+          blocks: [teamId]
         });
       } catch (e) {
         this.dispatch(setTeam(team));
@@ -6955,11 +7084,17 @@ var __publicField = (obj, key, value) => {
       const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
       const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
       const projectId = payloadWithoutFile.project;
-      const filePayload = await this.getFilePayload(file);
+      const sha1 = await hashFile(file);
+      const filePayload = {
+        sha1,
+        file_type: file.type,
+        extension: file.name.split(".").pop(),
+        size: file.size
+      };
       const offlineMapImage = offline({
         ...payloadWithoutFile,
         file_name: file.name,
-        file_sha1: filePayload.sha1,
+        file_sha1: sha1,
         file: URL.createObjectURL(file),
         submitted_at: submittedAt,
         created_by: createdBy
@@ -7002,16 +7137,23 @@ var __publicField = (obj, key, value) => {
       const offlineGeoImages = [];
       const offlineIds = [];
       const geoImagePayloads = [];
-      const filePayloads = {};
+      const filePayloadRecord = {};
       for (const payloadAndFile of payloads) {
         const { file, ...payload } = payloadAndFile;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
+        const sha1 = await hashFile(file);
+        if (!(sha1 in filePayloadRecord)) {
+          filePayloadRecord[sha1] = {
+            sha1,
+            file_type: file.type,
+            extension: file.name.split(".").pop(),
+            size: file.size
+          };
+          await this.client.files.addCache(file, sha1);
+        }
         const offlineMapImage = offline({
           ...payload,
           file_name: file.name,
-          file_sha1: filePayload.sha1,
+          file_sha1: sha1,
           file: URL.createObjectURL(file),
           submitted_at: submittedAt,
           created_by: createdBy,
@@ -7040,7 +7182,7 @@ var __publicField = (obj, key, value) => {
           submitted_at: submittedAt,
           project: projectId,
           geo_images: geoImagePayloads,
-          files: Object.values(filePayloads)
+          files: Object.values(filePayloadRecord)
         },
         blocks: [projectId.toString()],
         blockers: offlineIds
@@ -7077,20 +7219,20 @@ var __publicField = (obj, key, value) => {
       });
       return [updatedGeoImage, promise];
     }
-    async delete(id) {
+    async delete(geoImageId) {
       const { store } = this.client;
       const state = store.getState();
-      const geoImageToDelete = selectGeoImageById(id)(state);
+      const geoImageToDelete = selectGeoImageById(geoImageId)(state);
       if (!geoImageToDelete) {
-        throw new Error(`Map image with offline_id ${id} does not exist in the store`);
+        throw new Error(`Map image with offline_id ${geoImageId} does not exist in the store`);
       }
-      this.dispatch(deleteGeoImage(id));
+      this.dispatch(deleteGeoImage(geoImageId));
       const promise = this.enqueueRequest({
         description: "Delete geo image",
         method: HttpMethod.DELETE,
-        url: `/geo-images/${id}/`,
-        blocks: [id],
-        blockers: [id]
+        url: `/geo-images/${geoImageId}/`,
+        blocks: [geoImageId],
+        blockers: [geoImageId]
       });
       promise.catch(() => {
         this.dispatch(setGeoImage(geoImageToDelete));
@@ -7108,7 +7250,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(initializeGeoImages(result));
     }
   }
-  class IssueAssociationService extends BaseApiService {
+  class IssueAssociationService extends BaseUploadService {
     add(payload) {
       var _a2;
       const { store } = this.client;
@@ -7123,7 +7265,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add issue association",
         method: HttpMethod.POST,
-        url: "/issue-associations/",
+        url: "/issues/associations/",
         payload: {
           offline_id: offlineIssueAssociation.offline_id,
           submitted_at: submittedAt,
@@ -7153,7 +7295,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete issue association",
         method: HttpMethod.DELETE,
-        url: `/issue-associations/${id}/`,
+        url: `/issues/associations/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -7166,938 +7308,14 @@ var __publicField = (obj, key, value) => {
       const issueAssociations = await this.enqueueRequest({
         description: "Fetch issue associations",
         method: HttpMethod.GET,
-        url: "/issue-associations/",
-        queryParams: { project: projectId.toString() },
+        url: "/issues/associations/",
+        queryParams: { project_id: projectId.toString() },
         blockers: [],
         blocks: []
       });
       this.dispatch(initializeIssueAssociations(issueAssociations));
     }
   }
-  class FormRevisionAttachmentService extends BaseUploadService {
-    async bulkAdd(payloads) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const filePayloads = {};
-      const offlineFormRevisionAttachments = [];
-      const attachmentPayloads = [];
-      for (const payload of payloads) {
-        const { revisionId, fieldIdentifier, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
-        const offlineFormRevisionAttachment = offline({
-          file: URL.createObjectURL(file),
-          file_type: file.type,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          created_by: createdBy,
-          form_revision: revisionId,
-          submitted_at: submittedAt,
-          field_identifier: fieldIdentifier
-        });
-        offlineFormRevisionAttachments.push(offlineFormRevisionAttachment);
-        const attachmentPayload = {
-          offline_id: offlineFormRevisionAttachment.offline_id,
-          file_name: file.name,
-          field_identifier: fieldIdentifier,
-          file_extension: filePayload.extension,
-          file_sha1: filePayload.sha1,
-          form_revision: revisionId
-        };
-        attachmentPayloads.push(attachmentPayload);
-      }
-      this.dispatch(addFormRevisionAttachments(offlineFormRevisionAttachments));
-      const promise = this.enqueueRequest({
-        description: "Attach files to form revision",
-        method: HttpMethod.POST,
-        url: "/form-revision-attachments/bulk/",
-        payload: {
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        },
-        blockers: offlineFormRevisionAttachments.map((attachment) => attachment.form_revision),
-        blocks: offlineFormRevisionAttachments.map((attachment) => attachment.offline_id)
-      });
-      promise.then((result) => {
-        this.processPresignedUrls(result.presigned_urls);
-        this.dispatch(updateFormRevisionAttachments(result.attachments));
-      }).catch(() => {
-        this.dispatch(
-          deleteFormRevisionAttachments(
-            offlineFormRevisionAttachments.map((attachment) => attachment.offline_id)
-          )
-        );
-      });
-      return [offlineFormRevisionAttachments, promise.then(({ attachments }) => attachments)];
-    }
-    async refreshStore(projectId, organizationId) {
-      let attachments = [];
-      const projectFormRevisions = await this.enqueueRequest({
-        description: "Fetch project form revision attachments",
-        method: HttpMethod.GET,
-        url: "/form-revision-attachments/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [projectId.toString()],
-        blocks: []
-      });
-      attachments = attachments.concat(projectFormRevisions);
-      const organizationFormRevisions = await this.enqueueRequest({
-        description: "Fetch organization form revision attachments",
-        method: HttpMethod.GET,
-        url: "/form-revision-attachments/",
-        queryParams: {
-          organization: organizationId.toString()
-        },
-        blockers: [organizationId.toString()],
-        blocks: []
-      });
-      attachments = attachments.concat(organizationFormRevisions);
-      this.dispatch(initializeFormRevisionAttachments(attachments));
-    }
-  }
-  class FormSubmissionAttachmentService extends BaseUploadService {
-    async bulkAdd(payloads) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const filePayloads = {};
-      const offlineFormSubmissionAttachments = [];
-      const attachmentPayloads = [];
-      for (const payload of payloads) {
-        const { submissionId, fieldIdentifier, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
-        const offlineFormSubmissionAttachment = offline({
-          file: URL.createObjectURL(file),
-          file_type: file.type,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          created_by: createdBy,
-          form_submission: submissionId,
-          submitted_at: submittedAt,
-          field_identifier: fieldIdentifier
-        });
-        offlineFormSubmissionAttachments.push(offlineFormSubmissionAttachment);
-        const attachmentPayload = {
-          offline_id: offlineFormSubmissionAttachment.offline_id,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          file_extension: filePayload.extension,
-          field_identifier: fieldIdentifier,
-          form_submission: submissionId
-        };
-        attachmentPayloads.push(attachmentPayload);
-      }
-      this.dispatch(addFormSubmissionAttachments(offlineFormSubmissionAttachments));
-      const promise = this.enqueueRequest({
-        description: "Attach files to form submission",
-        method: HttpMethod.POST,
-        url: "/form-submission-attachments/bulk/",
-        payload: {
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        },
-        blockers: offlineFormSubmissionAttachments.map((attachment) => attachment.form_submission),
-        blocks: offlineFormSubmissionAttachments.map((attachment) => attachment.offline_id)
-      });
-      promise.then((result) => {
-        this.processPresignedUrls(result.presigned_urls);
-        this.dispatch(updateFormSubmissionAttachments(result.attachments));
-      }).catch((error) => {
-        this.dispatch(
-          deleteFormSubmissionAttachments(
-            offlineFormSubmissionAttachments.map((attachment) => attachment.offline_id)
-          )
-        );
-        throw error;
-      });
-      return [offlineFormSubmissionAttachments, promise.then(({ attachments }) => attachments)];
-    }
-    async bulkDelete(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: "/form-submission-attachments/bulk/",
-          payload: { attachment_ids: attachmentsIds },
-          blockers: attachmentsIds,
-          blocks: []
-        });
-      } catch (e) {
-        this.dispatch(addFormSubmissionAttachments(formSubmissionAttachments));
-        throw e;
-      }
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get form submission attachments",
-        method: HttpMethod.GET,
-        url: "/form-submission-attachments/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeFormSubmissionAttachments(result));
-    }
-  }
-  class FormRevisionService extends BaseUploadService {
-    add(payload) {
-      var _a2;
-      const { store } = this.client;
-      const state = store.getState();
-      const createdBy = (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id;
-      const offlineFormRevision = offline({
-        ...payload,
-        created_by: createdBy,
-        revision: "Pending",
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      this.dispatch(addFormRevision(offlineFormRevision));
-      const promise = this.enqueueRequest({
-        description: "Create form revision",
-        method: HttpMethod.POST,
-        url: "/form-revisions/",
-        payload: offlineFormRevision,
-        blockers: [payload.form],
-        blocks: [offlineFormRevision.offline_id]
-      });
-      void promise.then((result) => {
-        this.dispatch(setFormRevision(result));
-      }).catch(() => {
-        this.dispatch(deleteFormRevision(offlineFormRevision.offline_id));
-      });
-      return [offlineFormRevision, promise];
-    }
-    async refreshStore(projectId, organizationId) {
-      let formRevisions = [];
-      const projectFormRevisions = await this.enqueueRequest({
-        description: "Fetch project form revisions",
-        method: HttpMethod.GET,
-        url: "/form-revisions/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [projectId.toString()],
-        blocks: []
-      });
-      formRevisions = formRevisions.concat(projectFormRevisions);
-      const organizationFormRevisions = await this.enqueueRequest({
-        description: "Fetch organization form revisions",
-        method: HttpMethod.GET,
-        url: "/form-revisions/",
-        queryParams: {
-          organization: organizationId.toString()
-        },
-        blockers: [organizationId.toString()],
-        blocks: []
-      });
-      formRevisions = formRevisions.concat(organizationFormRevisions);
-      this.dispatch(initializeFormRevisions(formRevisions));
-    }
-  }
-  class AssetTypeFieldsAttachmentService extends BaseUploadService {
-    async bulkAdd(payloads) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const filePayloads = {};
-      const offlineAssetTypeFieldsAttachments = [];
-      const attachmentPayloads = [];
-      for (const payload of payloads) {
-        const { fieldsRevisionId, fieldIdentifier, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
-        const offlineAssetTypeFieldsAttachment = offline({
-          file: URL.createObjectURL(file),
-          file_type: file.type,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          created_by: createdBy,
-          fields_revision: fieldsRevisionId,
-          submitted_at: submittedAt,
-          field_identifier: fieldIdentifier
-        });
-        offlineAssetTypeFieldsAttachments.push(offlineAssetTypeFieldsAttachment);
-        const attachmentPayload = {
-          offline_id: offlineAssetTypeFieldsAttachment.offline_id,
-          file_name: file.name,
-          field_identifier: fieldIdentifier,
-          file_extension: filePayload.extension,
-          file_sha1: filePayload.sha1,
-          fields_revision: fieldsRevisionId
-        };
-        attachmentPayloads.push(attachmentPayload);
-      }
-      this.dispatch(addAssetTypeFieldsAttachments(offlineAssetTypeFieldsAttachments));
-      const promise = this.enqueueRequest({
-        description: "Add asset type fields attachments",
-        method: HttpMethod.POST,
-        url: "/asset-type-fields-attachments/bulk/",
-        payload: {
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        },
-        blockers: offlineAssetTypeFieldsAttachments.map((attachment) => attachment.fields_revision),
-        blocks: offlineAssetTypeFieldsAttachments.map((attachment) => attachment.offline_id)
-      });
-      promise.then((result) => {
-        this.processPresignedUrls(result.presigned_urls);
-        this.dispatch(updateAssetTypeFieldsAttachments(result.attachments));
-      }).catch(() => {
-        this.dispatch(
-          deleteAssetTypeFieldsAttachments(
-            offlineAssetTypeFieldsAttachments.map((attachment) => attachment.offline_id)
-          )
-        );
-      });
-      return [offlineAssetTypeFieldsAttachments, promise.then(({ attachments }) => attachments)];
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "get asset type fields attachments",
-        method: HttpMethod.GET,
-        url: "/asset-type-fields-attachments/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [projectId.toString()],
-        blocks: []
-      });
-      this.dispatch(initializeAssetTypeFieldsAttachments(result));
-    }
-  }
-  class AssetTypeFieldsService extends BaseApiService {
-    add(payload) {
-      var _a2;
-      const { store } = this.client;
-      const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const offlineAssetTypeFields = offline({
-        ...payload,
-        created_by: createdBy,
-        submitted_at: submittedAt
-      });
-      this.dispatch(addAssetTypeFields(offlineAssetTypeFields));
-      const promise = this.enqueueRequest({
-        description: "Add Asset Type Fields",
-        method: HttpMethod.POST,
-        url: "/asset-type-fields/",
-        payload: offlineAssetTypeFields,
-        blockers: [offlineAssetTypeFields.asset_type],
-        blocks: [offlineAssetTypeFields.offline_id]
-      });
-      promise.then((response) => {
-        this.dispatch(updateAssetTypeFields(response));
-      }).catch((error) => {
-        this.dispatch(deleteAssetTypeFields(offlineAssetTypeFields.offline_id));
-        throw error;
-      });
-      return [offlineAssetTypeFields, promise];
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get Asset Type Fields",
-        method: HttpMethod.GET,
-        url: "/asset-type-fields/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeAssetTypeFields(result));
-    }
-  }
-  class AssetTypeFieldValuesService extends BaseApiService {
-    add(payload) {
-      var _a2;
-      const { store } = this.client;
-      const state = store.getState();
-      const { values } = separateFilesFromValues(payload.values);
-      const offlineAssetTypeFieldValues = offline({
-        ...payload,
-        values,
-        created_by: (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id,
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      const promise = this.enqueueRequest({
-        description: "Add asset type field values",
-        method: HttpMethod.POST,
-        url: "/asset-type-field-values/",
-        payload: offlineAssetTypeFieldValues,
-        blockers: [payload.asset, payload.fields_revision],
-        blocks: [offlineAssetTypeFieldValues.offline_id]
-      });
-      this.dispatch(addAssetTypeFieldValues(offlineAssetTypeFieldValues));
-      promise.then((result) => {
-        this.dispatch(updateAssetTypeFieldValues(result));
-        return result;
-      }).catch(() => {
-        this.dispatch(deleteAssetTypeFieldValues(offlineAssetTypeFieldValues.offline_id));
-      });
-      return [offlineAssetTypeFieldValues, promise];
-    }
-    bulkAdd(payload, batchSize) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const { values } = separateFilesFromValues(payload.values);
-      const offlineAssetTypeFieldValuesMany = [];
-      const batches = chunkArray(payload.payloads, batchSize ?? payload.payloads.length);
-      const batchPayloads = [];
-      for (const batch of batches) {
-        const assetTypeFieldValuesPayloads = [];
-        for (const payload2 of batch) {
-          const offlineAssetTypeFieldValues = offline({
-            ...payload2,
-            values: separateFilesFromValues(payload2.values).values,
-            created_by: (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id,
-            submitted_at: submittedAt
-          });
-          offlineAssetTypeFieldValuesMany.push(offlineAssetTypeFieldValues);
-          assetTypeFieldValuesPayloads.push({
-            offline_id: offlineAssetTypeFieldValues.offline_id,
-            asset: payload2.asset,
-            fields_revision: payload2.fields_revision,
-            published_at: payload2.published_at,
-            values: offlineAssetTypeFieldValues.values
-          });
-        }
-        batchPayloads.push({
-          submitted_at: submittedAt,
-          values,
-          field_values: assetTypeFieldValuesPayloads
-        });
-      }
-      this.dispatch(addAssetTypeFieldValuesMany(offlineAssetTypeFieldValuesMany));
-      const promises = [];
-      for (const payload2 of batchPayloads) {
-        const assetIds = payload2.field_values.map((x) => x.asset);
-        const assetTypeFieldsIds = payload2.field_values.map((x) => x.fields_revision);
-        const assetTypeFieldValuesIds = payload2.field_values.map((x) => x.offline_id);
-        const promise = this.enqueueRequest({
-          description: "Bulk add asset type field values",
-          method: HttpMethod.POST,
-          url: "/asset-type-field-values/bulk/",
-          payload: payload2,
-          blockers: [...assetIds, ...assetTypeFieldsIds],
-          blocks: assetTypeFieldValuesIds
-        });
-        promises.push(promise);
-      }
-      void Promise.all(promises).then((results) => {
-        this.dispatch(updateAssetTypeFieldValuesMany(results.flat()));
-      }).catch(() => {
-        this.dispatch(deleteAssetTypeFieldValuesMany(offlineAssetTypeFieldValuesMany.map((x) => x.offline_id)));
-      });
-      return [offlineAssetTypeFieldValuesMany, promises];
-    }
-    update(payload) {
-      const { store } = this.client;
-      const state = store.getState();
-      const assetTypeFieldValues = selectAssetTypeFieldValuesById(payload.offline_id)(state);
-      if (!assetTypeFieldValues) {
-        throw new Error(`Expected AssetTypeFieldValues with offline_id ${payload.offline_id} to exist`);
-      }
-      const { values } = separateFilesFromValues(payload.values ?? {});
-      const updatedAssetTypeFieldValues = {
-        ...assetTypeFieldValues,
-        ...payload,
-        // values could also have a partial update
-        values: {
-          ...assetTypeFieldValues.values,
-          ...values
-        }
-      };
-      this.dispatch(updateAssetTypeFieldValues(updatedAssetTypeFieldValues));
-      const promise = this.enqueueRequest({
-        description: "Delete asset type field values",
-        method: HttpMethod.PATCH,
-        url: `/asset-type-field-values/${payload.offline_id}/`,
-        payload,
-        blockers: [
-          updatedAssetTypeFieldValues.offline_id,
-          updatedAssetTypeFieldValues.fields_revision,
-          updatedAssetTypeFieldValues.asset
-        ],
-        blocks: [updatedAssetTypeFieldValues.offline_id]
-      });
-      promise.then((result) => {
-        this.dispatch(updateAssetTypeFieldValues(result));
-      }).catch(() => {
-        this.dispatch(updateAssetTypeFieldValues(assetTypeFieldValues));
-      });
-      return [updatedAssetTypeFieldValues, promise];
-    }
-    async delete(id) {
-      const { store } = this.client;
-      const state = store.getState();
-      const assetTypeFieldValues = selectAssetTypeFieldValuesById(id)(state);
-      if (!assetTypeFieldValues) {
-        throw new Error(`Expected submission with offline_id ${id} to exist`);
-      }
-      const assetTypeFieldValuesAttachments = selectAttachmentsOfAssetTypeFieldValues(id)(state);
-      this.dispatch(deleteAssetTypeFieldValues(id));
-      this.dispatch(deleteAssetTypeFieldValuesAttachments(assetTypeFieldValuesAttachments.map((x) => x.offline_id)));
-      try {
-        await this.enqueueRequest({
-          description: "Delete asset type field values",
-          method: HttpMethod.DELETE,
-          url: `/asset-type-field-values/${id}/`,
-          blockers: [id],
-          blocks: []
-        });
-      } catch (e) {
-        this.dispatch(addAssetTypeFieldValues(assetTypeFieldValues));
-        this.dispatch(addAssetTypeFieldValuesAttachments(assetTypeFieldValuesAttachments));
-        throw e;
-      }
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get asset type field values",
-        method: HttpMethod.GET,
-        url: "/asset-type-field-values/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeAssetTypeFieldValues(result));
-    }
-  }
-  class AssetTypeFieldValuesAttachmentService extends BaseUploadService {
-    async bulkAdd(payloads, batchSize) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const batches = chunkArray(payloads, batchSize ?? payloads.length);
-      const offlineAssetTypeFieldValuesAttachments = [];
-      const batchPayloads = [];
-      for (const batch of batches) {
-        const filePayloads = {};
-        const attachmentPayloads = [];
-        for (const payload of batch) {
-          const { fieldValuesId, fieldIdentifier, file } = payload;
-          const filePayload = await this.getFilePayload(file);
-          if (!(filePayload.sha1 in filePayloads))
-            filePayloads[filePayload.sha1] = filePayload;
-          const offlineAssetTypeFieldValuesAttachment = offline({
-            file: URL.createObjectURL(file),
-            file_type: file.type,
-            file_name: file.name,
-            file_sha1: filePayload.sha1,
-            created_by: createdBy,
-            field_values: fieldValuesId,
-            submitted_at: submittedAt,
-            field_identifier: fieldIdentifier
-          });
-          offlineAssetTypeFieldValuesAttachments.push(offlineAssetTypeFieldValuesAttachment);
-          const attachmentPayload = {
-            offline_id: offlineAssetTypeFieldValuesAttachment.offline_id,
-            file_name: file.name,
-            file_sha1: filePayload.sha1,
-            file_extension: filePayload.extension,
-            field_identifier: fieldIdentifier,
-            field_values: fieldValuesId
-          };
-          attachmentPayloads.push(attachmentPayload);
-        }
-        batchPayloads.push({
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        });
-      }
-      this.dispatch(addAssetTypeFieldValuesAttachments(offlineAssetTypeFieldValuesAttachments));
-      const promises = batchPayloads.map((payload) => {
-        return this.enqueueRequest({
-          description: "Add asset type field values attachments",
-          method: HttpMethod.POST,
-          url: "/asset-type-field-values-attachments/bulk/",
-          payload,
-          blockers: payload.attachments.map((payload2) => payload2.field_values),
-          blocks: payload.attachments.map((payload2) => payload2.offline_id)
-        });
-      });
-      Promise.all(promises).then((result) => {
-        for (const res of result)
-          this.processPresignedUrls(res.presigned_urls);
-        const attachments = result.flatMap((res) => res.attachments);
-        this.dispatch(updateAssetTypeFieldValuesAttachments(attachments));
-      }).catch((error) => {
-        this.dispatch(
-          deleteAssetTypeFieldValuesAttachments(
-            offlineAssetTypeFieldValuesAttachments.map((attachment) => attachment.offline_id)
-          )
-        );
-        throw error;
-      });
-      return [
-        offlineAssetTypeFieldValuesAttachments,
-        promises.map((promise) => promise.then(({ attachments }) => attachments))
-      ];
-    }
-    async bulkDelete(ids) {
-      const { store } = this.client;
-      const state = store.getState();
-      const formSubmissionAttachments = selectFormSubmissionAttachemntsByIds(ids)(state);
-      this.dispatch(deleteFormSubmissionAttachments(ids));
-      try {
-        await this.enqueueRequest({
-          description: "Delete asset type field values attachments",
-          method: HttpMethod.DELETE,
-          url: "/asset-type-field-values-attachments/bulk/",
-          payload: { attachment_ids: ids },
-          blockers: ids,
-          blocks: []
-        });
-      } catch (e) {
-        this.dispatch(addFormSubmissionAttachments(formSubmissionAttachments));
-        throw e;
-      }
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get asset type field values attachments",
-        method: HttpMethod.GET,
-        url: "/asset-type-field-values-attachments/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeAssetTypeFieldValuesAttachments(result));
-    }
-  }
-  class IssueTypeFieldsAttachmentService extends BaseUploadService {
-    async bulkAdd(payloads) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const filePayloads = {};
-      const offlineIssueTypeFieldsAttachments = [];
-      const attachmentPayloads = [];
-      for (const payload of payloads) {
-        const { fieldsRevisionId, fieldIdentifier, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
-        const offlineIssueTypeFieldsAttachment = offline({
-          file: URL.createObjectURL(file),
-          file_type: file.type,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          created_by: createdBy,
-          fields_revision: fieldsRevisionId,
-          submitted_at: submittedAt,
-          field_identifier: fieldIdentifier
-        });
-        offlineIssueTypeFieldsAttachments.push(offlineIssueTypeFieldsAttachment);
-        const attachmentPayload = {
-          offline_id: offlineIssueTypeFieldsAttachment.offline_id,
-          file_name: file.name,
-          file_extension: filePayload.extension,
-          field_identifier: fieldIdentifier,
-          file_sha1: filePayload.sha1,
-          fields_revision: fieldsRevisionId
-        };
-        attachmentPayloads.push(attachmentPayload);
-      }
-      this.dispatch(addIssueTypeFieldsAttachments(offlineIssueTypeFieldsAttachments));
-      const promise = this.enqueueRequest({
-        description: "Add issue type fields attachments",
-        method: HttpMethod.POST,
-        url: "/issue-type-fields-attachments/bulk/",
-        payload: {
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        },
-        blockers: offlineIssueTypeFieldsAttachments.map((attachment) => attachment.fields_revision),
-        blocks: offlineIssueTypeFieldsAttachments.map((attachment) => attachment.offline_id)
-      });
-      promise.then((result) => {
-        this.processPresignedUrls(result.presigned_urls);
-        this.dispatch(updateIssueTypeFieldsAttachments(result.attachments));
-      }).catch(() => {
-        this.dispatch(
-          deleteIssueTypeFieldsAttachments(
-            offlineIssueTypeFieldsAttachments.map((attachment) => attachment.offline_id)
-          )
-        );
-      });
-      return [offlineIssueTypeFieldsAttachments, promise.then(({ attachments }) => attachments)];
-    }
-    async refreshStore(organizationId) {
-      const result = await this.enqueueRequest({
-        description: "get issue type fields attachments",
-        method: HttpMethod.GET,
-        url: "/issue-type-fields-attachments/",
-        queryParams: {
-          organization: organizationId.toString()
-        },
-        blockers: [organizationId.toString()],
-        blocks: []
-      });
-      this.dispatch(initializeIssueTypeFieldsAttachments(result));
-    }
-  }
-  class IssueTypeFieldsService extends BaseApiService {
-    add(payload) {
-      var _a2;
-      const { store } = this.client;
-      const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const offlineIssueTypeFields = offline({
-        ...payload,
-        created_by: createdBy,
-        submitted_at: submittedAt
-      });
-      this.dispatch(addIssueTypeFields(offlineIssueTypeFields));
-      const promise = this.enqueueRequest({
-        description: "Add Issue Type Fields",
-        method: HttpMethod.POST,
-        url: "/issue-type-fields/",
-        payload: offlineIssueTypeFields,
-        blockers: [offlineIssueTypeFields.issue_type],
-        blocks: [offlineIssueTypeFields.offline_id]
-      });
-      promise.then((response) => {
-        this.dispatch(updateIssueTypeFields(response));
-      }).catch((error) => {
-        this.dispatch(deleteIssueTypeFields(offlineIssueTypeFields.offline_id));
-        throw error;
-      });
-      return [offlineIssueTypeFields, promise];
-    }
-    async refreshStore(organizationId) {
-      const result = await this.enqueueRequest({
-        description: "Get Issue Type Fields",
-        method: HttpMethod.GET,
-        url: "/issue-type-fields/",
-        queryParams: {
-          organization: organizationId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeIssueTypeFields(result));
-    }
-  }
-  class IssueTypeFieldValuesAttachmentService extends BaseUploadService {
-    async bulkAdd(payloads) {
-      var _a2;
-      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const createdBy = (_a2 = this.client.store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
-      const filePayloads = {};
-      const offlineIssueTypeFieldValuesAttachments = [];
-      const attachmentPayloads = [];
-      for (const payload of payloads) {
-        const { fieldValuesId, fieldIdentifier, file } = payload;
-        const filePayload = await this.getFilePayload(file);
-        if (!(filePayload.sha1 in filePayloads))
-          filePayloads[filePayload.sha1] = filePayload;
-        const offlineIssueTypeFieldValuesAttachment = offline({
-          file: URL.createObjectURL(file),
-          file_type: file.type,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          created_by: createdBy,
-          field_values: fieldValuesId,
-          submitted_at: submittedAt,
-          field_identifier: fieldIdentifier
-        });
-        offlineIssueTypeFieldValuesAttachments.push(offlineIssueTypeFieldValuesAttachment);
-        const attachmentPayload = {
-          offline_id: offlineIssueTypeFieldValuesAttachment.offline_id,
-          file_name: file.name,
-          file_sha1: filePayload.sha1,
-          file_extension: filePayload.extension,
-          field_identifier: fieldIdentifier,
-          field_values: fieldValuesId
-        };
-        attachmentPayloads.push(attachmentPayload);
-      }
-      this.dispatch(addIssueTypeFieldValuesAttachments(offlineIssueTypeFieldValuesAttachments));
-      const promise = this.enqueueRequest({
-        description: "Add issue type field values attachments",
-        method: HttpMethod.POST,
-        url: "/issue-type-field-values-attachments/bulk/",
-        payload: {
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        },
-        blockers: offlineIssueTypeFieldValuesAttachments.map((attachment) => attachment.field_values),
-        blocks: offlineIssueTypeFieldValuesAttachments.map((attachment) => attachment.offline_id)
-      });
-      promise.then(({ presigned_urls, attachments }) => {
-        this.processPresignedUrls(presigned_urls);
-        this.dispatch(updateIssueTypeFieldValuesAttachments(attachments));
-      }).catch((error) => {
-        this.dispatch(
-          deleteIssueTypeFieldValuesAttachments(
-            offlineIssueTypeFieldValuesAttachments.map((attachment) => attachment.offline_id)
-          )
-        );
-        throw error;
-      });
-      return [offlineIssueTypeFieldValuesAttachments, promise.then(({ attachments }) => attachments)];
-    }
-    async bulkDelete(attachmentsIds) {
-      const { store } = this.client;
-      const state = store.getState();
-      const formSubmissionAttachments = selectFormSubmissionAttachemntsByIds(attachmentsIds)(state);
-      this.dispatch(deleteFormSubmissionAttachments(attachmentsIds));
-      try {
-        await this.enqueueRequest({
-          description: "Delete issue type field values attachments",
-          method: HttpMethod.DELETE,
-          url: "/issue-type-field-values-attachments/bulk/",
-          payload: { attachment_ids: attachmentsIds },
-          blockers: attachmentsIds,
-          blocks: []
-        });
-      } catch (e) {
-        this.dispatch(addFormSubmissionAttachments(formSubmissionAttachments));
-        throw e;
-      }
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get issue type field values attachments",
-        method: HttpMethod.GET,
-        url: "/issue-type-field-values-attachments/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeIssueTypeFieldValuesAttachments(result));
-    }
-  }
-  class IssueTypeFieldValuesService extends BaseApiService {
-    add(payload) {
-      var _a2;
-      const { store } = this.client;
-      const state = store.getState();
-      const { values } = separateFilesFromValues(payload.values);
-      const offlineIssueTypeFieldValues = offline({
-        ...payload,
-        values,
-        created_by: (_a2 = state.userReducer.currentUser) == null ? void 0 : _a2.id,
-        submitted_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      const promise = this.enqueueRequest({
-        description: "Add issue type field values",
-        method: HttpMethod.POST,
-        url: "/issue-type-field-values/",
-        payload: offlineIssueTypeFieldValues,
-        blockers: [payload.issue, payload.fields_revision],
-        blocks: [offlineIssueTypeFieldValues.offline_id]
-      });
-      this.dispatch(addIssueTypeFieldValues(offlineIssueTypeFieldValues));
-      promise.then((result) => {
-        this.dispatch(updateIssueTypeFieldValues(result));
-        return result;
-      }).catch(() => {
-        this.dispatch(deleteIssueTypeFieldValues(offlineIssueTypeFieldValues.offline_id));
-      });
-      return [offlineIssueTypeFieldValues, promise];
-    }
-    update(payload) {
-      const { store } = this.client;
-      const state = store.getState();
-      const issueTypeFieldValues = selectIssueTypeFieldValuesById(payload.offline_id)(state);
-      if (!issueTypeFieldValues) {
-        throw new Error(`Expected IssueTypeFieldValues with offline_id ${payload.offline_id} to exist`);
-      }
-      const { values } = separateFilesFromValues(payload.values ?? {});
-      const updatedIssueTypeFieldValues = {
-        ...issueTypeFieldValues,
-        ...payload,
-        // values could also have a partial update
-        values: {
-          ...issueTypeFieldValues.values,
-          ...values
-        }
-      };
-      this.dispatch(updateIssueTypeFieldValues(updatedIssueTypeFieldValues));
-      const promise = this.enqueueRequest({
-        description: "Update issue type field values",
-        method: HttpMethod.PATCH,
-        url: `/issue-type-field-values/${payload.offline_id}/`,
-        payload,
-        blockers: [
-          updatedIssueTypeFieldValues.offline_id,
-          updatedIssueTypeFieldValues.fields_revision,
-          updatedIssueTypeFieldValues.issue
-        ],
-        blocks: [updatedIssueTypeFieldValues.offline_id]
-      });
-      promise.then((result) => {
-        this.dispatch(updateIssueTypeFieldValues(result));
-      }).catch(() => {
-        this.dispatch(updateIssueTypeFieldValues(issueTypeFieldValues));
-      });
-      return [updatedIssueTypeFieldValues, promise];
-    }
-    async delete(id) {
-      const { store } = this.client;
-      const state = store.getState();
-      const issueTypeFieldValues = selectIssueTypeFieldValuesById(id)(state);
-      if (!issueTypeFieldValues) {
-        throw new Error(`Expected submission with offline_id ${id} to exist`);
-      }
-      const issueTypeFieldValuesAttachments = selectAttachmentsOfIssueTypeFieldValues(id)(state);
-      this.dispatch(deleteIssueTypeFieldValues(id));
-      this.dispatch(deleteIssueTypeFieldValuesAttachments(issueTypeFieldValuesAttachments.map((x) => x.offline_id)));
-      try {
-        await this.enqueueRequest({
-          description: "Delete issue type field values",
-          method: HttpMethod.DELETE,
-          url: `/issue-type-field-values/${id}/`,
-          blockers: [id],
-          blocks: []
-        });
-      } catch (e) {
-        this.dispatch(addIssueTypeFieldValues(issueTypeFieldValues));
-        this.dispatch(addIssueTypeFieldValuesAttachments(issueTypeFieldValuesAttachments));
-        throw e;
-      }
-    }
-    async refreshStore(projectId) {
-      const result = await this.enqueueRequest({
-        description: "Get issue type field values",
-        method: HttpMethod.GET,
-        url: "/issue-type-field-values/",
-        queryParams: {
-          project: projectId.toString()
-        },
-        blockers: [],
-        blocks: []
-      });
-      this.dispatch(initializeIssueTypeFieldValues(result));
-    }
-  }
   var VerificationCodeType = /* @__PURE__ */ ((VerificationCodeType2) => {
     VerificationCodeType2[VerificationCodeType2["USER_REGISTRATION"] = 0] = "USER_REGISTRATION";
     VerificationCodeType2[VerificationCodeType2["APPLICATION_INVITE"] = 2] = "APPLICATION_INVITE";
@@ -8114,10 +7332,6 @@ var __publicField = (obj, key, value) => {
   exports2.AssetStageCompletionService = AssetStageCompletionService;
   exports2.AssetStageService = AssetStageService;
   exports2.AssetTypeAttachmentService = AssetTypeAttachmentService;
-  exports2.AssetTypeFieldValuesAttachmentService = AssetTypeFieldValuesAttachmentService;
-  exports2.AssetTypeFieldValuesService = AssetTypeFieldValuesService;
-  exports2.AssetTypeFieldsAttachmentService = AssetTypeFieldsAttachmentService;
-  exports2.AssetTypeFieldsService = AssetTypeFieldsService;
   exports2.AssetTypeService = AssetTypeService;
   exports2.AttachmentModel = AttachmentModel;
   exports2.BaseApiService = BaseApiService;
@@ -8133,10 +7347,7 @@ var __publicField = (obj, key, value) => {
   exports2.EmailDomainsService = EmailDomainsService;
   exports2.EmailVerificationService = EmailVerificationService;
   exports2.FileService = FileService;
-  exports2.FormRevisionAttachmentService = FormRevisionAttachmentService;
-  exports2.FormRevisionService = FormRevisionService;
   exports2.FormService = FormService;
-  exports2.FormSubmissionAttachmentService = FormSubmissionAttachmentService;
   exports2.FormSubmissionService = FormSubmissionService;
   exports2.GREEN = GREEN;
   exports2.GeoImageService = GeoImageService;
@@ -8147,10 +7358,6 @@ var __publicField = (obj, key, value) => {
   exports2.IssuePriority = IssuePriority;
   exports2.IssueService = IssueService;
   exports2.IssueStatus = IssueStatus;
-  exports2.IssueTypeFieldValuesAttachmentService = IssueTypeFieldValuesAttachmentService;
-  exports2.IssueTypeFieldValuesService = IssueTypeFieldValuesService;
-  exports2.IssueTypeFieldsAttachmentService = IssueTypeFieldsAttachmentService;
-  exports2.IssueTypeFieldsService = IssueTypeFieldsService;
   exports2.IssueTypeService = IssueTypeService;
   exports2.IssueUpdateChange = IssueUpdateChange;
   exports2.IssueUpdateService = IssueUpdateService;
@@ -8190,14 +7397,6 @@ var __publicField = (obj, key, value) => {
   exports2.addAssetType = addAssetType;
   exports2.addAssetTypeAttachment = addAssetTypeAttachment;
   exports2.addAssetTypeAttachments = addAssetTypeAttachments;
-  exports2.addAssetTypeFieldValues = addAssetTypeFieldValues;
-  exports2.addAssetTypeFieldValuesAttachment = addAssetTypeFieldValuesAttachment;
-  exports2.addAssetTypeFieldValuesAttachments = addAssetTypeFieldValuesAttachments;
-  exports2.addAssetTypeFieldValuesMany = addAssetTypeFieldValuesMany;
-  exports2.addAssetTypeFields = addAssetTypeFields;
-  exports2.addAssetTypeFieldsAttachment = addAssetTypeFieldsAttachment;
-  exports2.addAssetTypeFieldsAttachments = addAssetTypeFieldsAttachments;
-  exports2.addAssetTypeFieldsMany = addAssetTypeFieldsMany;
   exports2.addAssetTypes = addAssetTypes;
   exports2.addAssets = addAssets;
   exports2.addCategory = addCategory;
@@ -8226,14 +7425,6 @@ var __publicField = (obj, key, value) => {
   exports2.addIssueComment = addIssueComment;
   exports2.addIssueComments = addIssueComments;
   exports2.addIssueType = addIssueType;
-  exports2.addIssueTypeFieldValues = addIssueTypeFieldValues;
-  exports2.addIssueTypeFieldValuesAttachment = addIssueTypeFieldValuesAttachment;
-  exports2.addIssueTypeFieldValuesAttachments = addIssueTypeFieldValuesAttachments;
-  exports2.addIssueTypeFieldValuesMany = addIssueTypeFieldValuesMany;
-  exports2.addIssueTypeFields = addIssueTypeFields;
-  exports2.addIssueTypeFieldsAttachment = addIssueTypeFieldsAttachment;
-  exports2.addIssueTypeFieldsAttachments = addIssueTypeFieldsAttachments;
-  exports2.addIssueTypeFieldsMany = addIssueTypeFieldsMany;
   exports2.addIssueUpdate = addIssueUpdate;
   exports2.addIssueUpdates = addIssueUpdates;
   exports2.addIssues = addIssues;
@@ -8259,14 +7450,6 @@ var __publicField = (obj, key, value) => {
   exports2.assetStageSlice = assetStageSlice;
   exports2.assetTypeAttachmentReducer = assetTypeAttachmentReducer;
   exports2.assetTypeAttachmentSlice = assetTypeAttachmentSlice;
-  exports2.assetTypeFieldValuesAttachmentReducer = assetTypeFieldValuesAttachmentReducer;
-  exports2.assetTypeFieldValuesAttachmentSlice = assetTypeFieldValuesAttachmentSlice;
-  exports2.assetTypeFieldValuesReducer = assetTypeFieldValuesReducer;
-  exports2.assetTypeFieldValuesSlice = assetTypeFieldValuesSlice;
-  exports2.assetTypeFieldsAttachmentReducer = assetTypeFieldsAttachmentReducer;
-  exports2.assetTypeFieldsAttachmentSlice = assetTypeFieldsAttachmentSlice;
-  exports2.assetTypeFieldsReducer = assetTypeFieldsReducer;
-  exports2.assetTypeFieldsSlice = assetTypeFieldsSlice;
   exports2.assetTypeReducer = assetTypeReducer;
   exports2.assetTypeSlice = assetTypeSlice;
   exports2.authReducer = authReducer;
@@ -8295,14 +7478,6 @@ var __publicField = (obj, key, value) => {
   exports2.deleteAssetType = deleteAssetType;
   exports2.deleteAssetTypeAttachment = deleteAssetTypeAttachment;
   exports2.deleteAssetTypeAttachments = deleteAssetTypeAttachments;
-  exports2.deleteAssetTypeFieldValues = deleteAssetTypeFieldValues;
-  exports2.deleteAssetTypeFieldValuesAttachment = deleteAssetTypeFieldValuesAttachment;
-  exports2.deleteAssetTypeFieldValuesAttachments = deleteAssetTypeFieldValuesAttachments;
-  exports2.deleteAssetTypeFieldValuesMany = deleteAssetTypeFieldValuesMany;
-  exports2.deleteAssetTypeFields = deleteAssetTypeFields;
-  exports2.deleteAssetTypeFieldsAttachment = deleteAssetTypeFieldsAttachment;
-  exports2.deleteAssetTypeFieldsAttachments = deleteAssetTypeFieldsAttachments;
-  exports2.deleteAssetTypeFieldsMany = deleteAssetTypeFieldsMany;
   exports2.deleteAssetTypes = deleteAssetTypes;
   exports2.deleteAssets = deleteAssets;
   exports2.deleteCategory = deleteCategory;
@@ -8327,14 +7502,6 @@ var __publicField = (obj, key, value) => {
   exports2.deleteIssueAttachments = deleteIssueAttachments;
   exports2.deleteIssueComment = deleteIssueComment;
   exports2.deleteIssueComments = deleteIssueComments;
-  exports2.deleteIssueTypeFieldValues = deleteIssueTypeFieldValues;
-  exports2.deleteIssueTypeFieldValuesAttachment = deleteIssueTypeFieldValuesAttachment;
-  exports2.deleteIssueTypeFieldValuesAttachments = deleteIssueTypeFieldValuesAttachments;
-  exports2.deleteIssueTypeFieldValuesMany = deleteIssueTypeFieldValuesMany;
-  exports2.deleteIssueTypeFields = deleteIssueTypeFields;
-  exports2.deleteIssueTypeFieldsAttachment = deleteIssueTypeFieldsAttachment;
-  exports2.deleteIssueTypeFieldsAttachments = deleteIssueTypeFieldsAttachments;
-  exports2.deleteIssueTypeFieldsMany = deleteIssueTypeFieldsMany;
   exports2.deleteIssueUpdate = deleteIssueUpdate;
   exports2.deleteIssueUpdates = deleteIssueUpdates;
   exports2.deleteIssues = deleteIssues;
@@ -8391,10 +7558,6 @@ var __publicField = (obj, key, value) => {
   exports2.initializeAssetStageCompletions = initializeAssetStageCompletions;
   exports2.initializeAssetStages = initializeAssetStages;
   exports2.initializeAssetTypeAttachments = initializeAssetTypeAttachments;
-  exports2.initializeAssetTypeFieldValues = initializeAssetTypeFieldValues;
-  exports2.initializeAssetTypeFieldValuesAttachments = initializeAssetTypeFieldValuesAttachments;
-  exports2.initializeAssetTypeFields = initializeAssetTypeFields;
-  exports2.initializeAssetTypeFieldsAttachments = initializeAssetTypeFieldsAttachments;
   exports2.initializeAssetTypes = initializeAssetTypes;
   exports2.initializeAssets = initializeAssets;
   exports2.initializeCategories = initializeCategories;
@@ -8409,10 +7572,6 @@ var __publicField = (obj, key, value) => {
   exports2.initializeGeoImages = initializeGeoImages;
   exports2.initializeIssueAssociations = initializeIssueAssociations;
   exports2.initializeIssueAttachments = initializeIssueAttachments;
-  exports2.initializeIssueTypeFieldValues = initializeIssueTypeFieldValues;
-  exports2.initializeIssueTypeFieldValuesAttachments = initializeIssueTypeFieldValuesAttachments;
-  exports2.initializeIssueTypeFields = initializeIssueTypeFields;
-  exports2.initializeIssueTypeFieldsAttachments = initializeIssueTypeFieldsAttachments;
   exports2.initializeIssueTypes = initializeIssueTypes;
   exports2.initializeIssueUpdates = initializeIssueUpdates;
   exports2.initializeIssues = initializeIssues;
@@ -8431,14 +7590,6 @@ var __publicField = (obj, key, value) => {
   exports2.issueCommentSlice = issueCommentSlice;
   exports2.issueReducer = issueReducer;
   exports2.issueSlice = issueSlice;
-  exports2.issueTypeFieldValuesAttachmentReducer = issueTypeFieldValuesAttachmentReducer;
-  exports2.issueTypeFieldValuesAttachmentSlice = issueTypeFieldValuesAttachmentSlice;
-  exports2.issueTypeFieldValuesReducer = issueTypeFieldValuesReducer;
-  exports2.issueTypeFieldValuesSlice = issueTypeFieldValuesSlice;
-  exports2.issueTypeFieldsAttachmentReducer = issueTypeFieldsAttachmentReducer;
-  exports2.issueTypeFieldsAttachmentSlice = issueTypeFieldsAttachmentSlice;
-  exports2.issueTypeFieldsReducer = issueTypeFieldsReducer;
-  exports2.issueTypeFieldsSlice = issueTypeFieldsSlice;
   exports2.issueTypeReducer = issueTypeReducer;
   exports2.issueTypeSlice = issueTypeSlice;
   exports2.issueUpdateReducer = issueUpdateReducer;
@@ -8511,22 +7662,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectAssetTypeAttachmentMapping = selectAssetTypeAttachmentMapping;
   exports2.selectAssetTypeAttachments = selectAssetTypeAttachments;
   exports2.selectAssetTypeById = selectAssetTypeById;
-  exports2.selectAssetTypeFieldValues = selectAssetTypeFieldValues;
-  exports2.selectAssetTypeFieldValuesAttachmentById = selectAssetTypeFieldValuesAttachmentById;
-  exports2.selectAssetTypeFieldValuesAttachments = selectAssetTypeFieldValuesAttachments;
-  exports2.selectAssetTypeFieldValuesAttachmentsMapping = selectAssetTypeFieldValuesAttachmentsMapping;
-  exports2.selectAssetTypeFieldValuesById = selectAssetTypeFieldValuesById;
-  exports2.selectAssetTypeFieldValuesMapping = selectAssetTypeFieldValuesMapping;
-  exports2.selectAssetTypeFieldValuesOfAsset = selectAssetTypeFieldValuesOfAsset;
-  exports2.selectAssetTypeFields = selectAssetTypeFields;
-  exports2.selectAssetTypeFieldsAttachmentById = selectAssetTypeFieldsAttachmentById;
-  exports2.selectAssetTypeFieldsAttachments = selectAssetTypeFieldsAttachments;
-  exports2.selectAssetTypeFieldsAttachmentsMapping = selectAssetTypeFieldsAttachmentsMapping;
-  exports2.selectAssetTypeFieldsById = selectAssetTypeFieldsById;
-  exports2.selectAssetTypeFieldsMapping = selectAssetTypeFieldsMapping;
-  exports2.selectAssetTypeFieldsOfAssetType = selectAssetTypeFieldsOfAssetType;
   exports2.selectAssetTypeStagesMapping = selectAssetTypeStagesMapping;
-  exports2.selectAssetTypeValuesOfAssetType = selectAssetTypeValuesOfAssetType;
   exports2.selectAssetTypes = selectAssetTypes;
   exports2.selectAssetTypesByIds = selectAssetTypesByIds;
   exports2.selectAssetTypesMapping = selectAssetTypesMapping;
@@ -8534,20 +7670,18 @@ var __publicField = (obj, key, value) => {
   exports2.selectAssetsByIds = selectAssetsByIds;
   exports2.selectAssetsMapping = selectAssetsMapping;
   exports2.selectAssetsOfAssetType = selectAssetsOfAssetType;
+  exports2.selectAttachedFormSubmissionsOfAsset = selectAttachedFormSubmissionsOfAsset;
+  exports2.selectAttachedFormSubmissionsOfIssue = selectAttachedFormSubmissionsOfIssue;
   exports2.selectAttachmentsOfAsset = selectAttachmentsOfAsset;
   exports2.selectAttachmentsOfAssetByType = selectAttachmentsOfAssetByType;
   exports2.selectAttachmentsOfAssetType = selectAttachmentsOfAssetType;
   exports2.selectAttachmentsOfAssetTypeByType = selectAttachmentsOfAssetTypeByType;
-  exports2.selectAttachmentsOfAssetTypeFieldValues = selectAttachmentsOfAssetTypeFieldValues;
-  exports2.selectAttachmentsOfAssetTypeFields = selectAttachmentsOfAssetTypeFields;
   exports2.selectAttachmentsOfDocument = selectAttachmentsOfDocument;
   exports2.selectAttachmentsOfDocumentByType = selectAttachmentsOfDocumentByType;
   exports2.selectAttachmentsOfFormRevision = selectAttachmentsOfFormRevision;
   exports2.selectAttachmentsOfFormSubmission = selectAttachmentsOfFormSubmission;
   exports2.selectAttachmentsOfIssue = selectAttachmentsOfIssue;
   exports2.selectAttachmentsOfIssueByType = selectAttachmentsOfIssueByType;
-  exports2.selectAttachmentsOfIssueTypeFieldValues = selectAttachmentsOfIssueTypeFieldValues;
-  exports2.selectAttachmentsOfIssueTypeFields = selectAttachmentsOfIssueTypeFields;
   exports2.selectAttachmentsOfProject = selectAttachmentsOfProject;
   exports2.selectAttachmentsOfProjectByType = selectAttachmentsOfProjectByType;
   exports2.selectCategories = selectCategories;
@@ -8575,6 +7709,8 @@ var __publicField = (obj, key, value) => {
   exports2.selectFilteredForms = selectFilteredForms;
   exports2.selectFormById = selectFormById;
   exports2.selectFormMapping = selectFormMapping;
+  exports2.selectFormOfAssetType = selectFormOfAssetType;
+  exports2.selectFormOfIssueType = selectFormOfIssueType;
   exports2.selectFormRevisionAttachmentsMapping = selectFormRevisionAttachmentsMapping;
   exports2.selectFormRevisionById = selectFormRevisionById;
   exports2.selectFormRevisionMapping = selectFormRevisionMapping;
@@ -8584,11 +7720,16 @@ var __publicField = (obj, key, value) => {
   exports2.selectFormSubmissionAttachmentsMapping = selectFormSubmissionAttachmentsMapping;
   exports2.selectFormSubmissionById = selectFormSubmissionById;
   exports2.selectFormSubmissions = selectFormSubmissions;
+  exports2.selectFormSubmissionsByAssets = selectFormSubmissionsByAssets;
+  exports2.selectFormSubmissionsByFormRevisions = selectFormSubmissionsByFormRevisions;
+  exports2.selectFormSubmissionsByIssues = selectFormSubmissionsByIssues;
   exports2.selectFormSubmissionsMapping = selectFormSubmissionsMapping;
   exports2.selectFormSubmissionsOfAsset = selectFormSubmissionsOfAsset;
   exports2.selectFormSubmissionsOfForm = selectFormSubmissionsOfForm;
   exports2.selectFormSubmissionsOfIssue = selectFormSubmissionsOfIssue;
   exports2.selectForms = selectForms;
+  exports2.selectFormsCount = selectFormsCount;
+  exports2.selectGeneralFormCount = selectGeneralFormCount;
   exports2.selectGeoImageById = selectGeoImageById;
   exports2.selectGeoImageMapping = selectGeoImageMapping;
   exports2.selectGeoImages = selectGeoImages;
@@ -8610,22 +7751,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectIssueCountOfCategory = selectIssueCountOfCategory;
   exports2.selectIssueMapping = selectIssueMapping;
   exports2.selectIssueTypeById = selectIssueTypeById;
-  exports2.selectIssueTypeFieldValues = selectIssueTypeFieldValues;
-  exports2.selectIssueTypeFieldValuesAttachmentById = selectIssueTypeFieldValuesAttachmentById;
-  exports2.selectIssueTypeFieldValuesAttachments = selectIssueTypeFieldValuesAttachments;
-  exports2.selectIssueTypeFieldValuesAttachmentsMapping = selectIssueTypeFieldValuesAttachmentsMapping;
-  exports2.selectIssueTypeFieldValuesById = selectIssueTypeFieldValuesById;
-  exports2.selectIssueTypeFieldValuesMapping = selectIssueTypeFieldValuesMapping;
-  exports2.selectIssueTypeFieldValuesOfIssue = selectIssueTypeFieldValuesOfIssue;
-  exports2.selectIssueTypeFields = selectIssueTypeFields;
-  exports2.selectIssueTypeFieldsAttachmentById = selectIssueTypeFieldsAttachmentById;
-  exports2.selectIssueTypeFieldsAttachments = selectIssueTypeFieldsAttachments;
-  exports2.selectIssueTypeFieldsAttachmentsMapping = selectIssueTypeFieldsAttachmentsMapping;
-  exports2.selectIssueTypeFieldsById = selectIssueTypeFieldsById;
-  exports2.selectIssueTypeFieldsMapping = selectIssueTypeFieldsMapping;
-  exports2.selectIssueTypeFieldsOfIssueType = selectIssueTypeFieldsOfIssueType;
   exports2.selectIssueTypeMapping = selectIssueTypeMapping;
-  exports2.selectIssueTypeValuesOfIssueType = selectIssueTypeValuesOfIssueType;
   exports2.selectIssueTypes = selectIssueTypes;
   exports2.selectIssueTypesByIds = selectIssueTypesByIds;
   exports2.selectIssueTypesOfOrganization = selectIssueTypesOfOrganization;
@@ -8634,9 +7760,8 @@ var __publicField = (obj, key, value) => {
   exports2.selectIssuesByIds = selectIssuesByIds;
   exports2.selectIssuesOfIssueType = selectIssuesOfIssueType;
   exports2.selectIssuesOfIssueTypeCount = selectIssuesOfIssueTypeCount;
-  exports2.selectLatestAssetTypeFieldsOfAssetType = selectLatestAssetTypeFieldsOfAssetType;
+  exports2.selectLatestFormRevisionByForm = selectLatestFormRevisionByForm;
   exports2.selectLatestFormRevisionOfForm = selectLatestFormRevisionOfForm;
-  exports2.selectLatestIssueTypeFieldsOfIssueType = selectLatestIssueTypeFieldsOfIssueType;
   exports2.selectLatestRetryTime = selectLatestRetryTime;
   exports2.selectLicense = selectLicense;
   exports2.selectLicenseForProject = selectLicenseForProject;
@@ -8673,6 +7798,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectProjectsOfOrganization = selectProjectsOfOrganization;
   exports2.selectRehydrated = selectRehydrated;
   exports2.selectRootDocuments = selectRootDocuments;
+  exports2.selectSortedFormSubmissionsOfForm = selectSortedFormSubmissionsOfForm;
   exports2.selectSortedOrganizationUsers = selectSortedOrganizationUsers;
   exports2.selectSortedProjectUsers = selectSortedProjectUsers;
   exports2.selectStageFormIdsFromStageIds = selectStageFormIdsFromStageIds;
@@ -8691,8 +7817,6 @@ var __publicField = (obj, key, value) => {
   exports2.selectWorkspaceById = selectWorkspaceById;
   exports2.selectWorkspaceMapping = selectWorkspaceMapping;
   exports2.selectWorkspaces = selectWorkspaces;
-  exports2.separateFilesFromValues = separateFilesFromValues;
-  exports2.separateImageFromFields = separateImageFromFields;
   exports2.setActiveProjectFileId = setActiveProjectFileId;
   exports2.setActiveProjectId = setActiveProjectId;
   exports2.setAsset = setAsset;
@@ -8703,14 +7827,6 @@ var __publicField = (obj, key, value) => {
   exports2.setAssetType = setAssetType;
   exports2.setAssetTypeAttachment = setAssetTypeAttachment;
   exports2.setAssetTypeAttachments = setAssetTypeAttachments;
-  exports2.setAssetTypeFieldValues = setAssetTypeFieldValues;
-  exports2.setAssetTypeFieldValuesAttachment = setAssetTypeFieldValuesAttachment;
-  exports2.setAssetTypeFieldValuesAttachments = setAssetTypeFieldValuesAttachments;
-  exports2.setAssetTypeFieldValuesMany = setAssetTypeFieldValuesMany;
-  exports2.setAssetTypeFields = setAssetTypeFields;
-  exports2.setAssetTypeFieldsAttachment = setAssetTypeFieldsAttachment;
-  exports2.setAssetTypeFieldsAttachments = setAssetTypeFieldsAttachments;
-  exports2.setAssetTypeFieldsMany = setAssetTypeFieldsMany;
   exports2.setAssetTypes = setAssetTypes;
   exports2.setAssets = setAssets;
   exports2.setConversation = setConversation;
@@ -8736,14 +7852,6 @@ var __publicField = (obj, key, value) => {
   exports2.setIssueComment = setIssueComment;
   exports2.setIssueComments = setIssueComments;
   exports2.setIssueType = setIssueType;
-  exports2.setIssueTypeFieldValues = setIssueTypeFieldValues;
-  exports2.setIssueTypeFieldValuesAttachment = setIssueTypeFieldValuesAttachment;
-  exports2.setIssueTypeFieldValuesAttachments = setIssueTypeFieldValuesAttachments;
-  exports2.setIssueTypeFieldValuesMany = setIssueTypeFieldValuesMany;
-  exports2.setIssueTypeFields = setIssueTypeFields;
-  exports2.setIssueTypeFieldsAttachment = setIssueTypeFieldsAttachment;
-  exports2.setIssueTypeFieldsAttachments = setIssueTypeFieldsAttachments;
-  exports2.setIssueTypeFieldsMany = setIssueTypeFieldsMany;
   exports2.setIssueUpdate = setIssueUpdate;
   exports2.setLoggedIn = setLoggedIn;
   exports2.setOrganizations = setOrganizations;
@@ -8776,14 +7884,6 @@ var __publicField = (obj, key, value) => {
   exports2.updateAssetType = updateAssetType;
   exports2.updateAssetTypeAttachment = updateAssetTypeAttachment;
   exports2.updateAssetTypeAttachments = updateAssetTypeAttachments;
-  exports2.updateAssetTypeFieldValues = updateAssetTypeFieldValues;
-  exports2.updateAssetTypeFieldValuesAttachment = updateAssetTypeFieldValuesAttachment;
-  exports2.updateAssetTypeFieldValuesAttachments = updateAssetTypeFieldValuesAttachments;
-  exports2.updateAssetTypeFieldValuesMany = updateAssetTypeFieldValuesMany;
-  exports2.updateAssetTypeFields = updateAssetTypeFields;
-  exports2.updateAssetTypeFieldsAttachment = updateAssetTypeFieldsAttachment;
-  exports2.updateAssetTypeFieldsAttachments = updateAssetTypeFieldsAttachments;
-  exports2.updateAssetTypeFieldsMany = updateAssetTypeFieldsMany;
   exports2.updateAssetTypes = updateAssetTypes;
   exports2.updateAssets = updateAssets;
   exports2.updateCategory = updateCategory;
@@ -8806,14 +7906,6 @@ var __publicField = (obj, key, value) => {
   exports2.updateIssueAttachment = updateIssueAttachment;
   exports2.updateIssueAttachments = updateIssueAttachments;
   exports2.updateIssueType = updateIssueType;
-  exports2.updateIssueTypeFieldValues = updateIssueTypeFieldValues;
-  exports2.updateIssueTypeFieldValuesAttachment = updateIssueTypeFieldValuesAttachment;
-  exports2.updateIssueTypeFieldValuesAttachments = updateIssueTypeFieldValuesAttachments;
-  exports2.updateIssueTypeFieldValuesMany = updateIssueTypeFieldValuesMany;
-  exports2.updateIssueTypeFields = updateIssueTypeFields;
-  exports2.updateIssueTypeFieldsAttachment = updateIssueTypeFieldsAttachment;
-  exports2.updateIssueTypeFieldsAttachments = updateIssueTypeFieldsAttachments;
-  exports2.updateIssueTypeFieldsMany = updateIssueTypeFieldsMany;
   exports2.updateLicense = updateLicense;
   exports2.updateOrCreateProject = updateOrCreateProject;
   exports2.updateOrganizationAccess = updateOrganizationAccess;