@overmap-ai/core 1.0.71-depend-on-forms.0 → 1.0.71-fields.0

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$B = {
+  const initialState$J = {
     accessToken: "",
     refreshToken: "",
     isLoggedIn: false
   };
   const authSlice = toolkit.createSlice({
     name: "auth",
-    initialState: initialState$B,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$B)),
+    initialState: initialState$J,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$J)),
     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$A = categoryAdapter.getInitialState({});
+  const initialState$I = categoryAdapter.getInitialState({});
   const categorySlice = toolkit.createSlice({
     name: "categories",
-    initialState: initialState$A,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$A)),
+    initialState: initialState$I,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$I)),
     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$z = assetAdapter.getInitialState({});
+  const initialState$H = assetAdapter.getInitialState({});
   const assetSlice = toolkit.createSlice({
     name: "assets",
-    initialState: initialState$z,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
+    initialState: initialState$H,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$H)),
     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$y = assetAttachmentAdapter.getInitialState({});
+  const initialState$G = assetAttachmentAdapter.getInitialState({});
   const assetAttachmentSlice = toolkit.createSlice({
     name: "assetAttachments",
-    initialState: initialState$y,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
+    initialState: initialState$G,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$G)),
     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$x = assetStageCompletionAdapter.getInitialState({});
+  const initialState$F = assetStageCompletionAdapter.getInitialState({});
   const assetStageCompletionSlice = toolkit.createSlice({
     name: "assetStageCompletions",
-    initialState: initialState$x,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
+    initialState: initialState$F,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$F)),
     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$w = assetStageAdapter.getInitialState({});
+  const initialState$E = assetStageAdapter.getInitialState({});
   const assetStageSlice = toolkit.createSlice({
     name: "assetStages",
-    initialState: initialState$w,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
+    initialState: initialState$E,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$E)),
     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$v = assetTypeAdapter.getInitialState({});
+  const initialState$D = assetTypeAdapter.getInitialState({});
   const assetTypeSlice = toolkit.createSlice({
     name: "assetTypes",
-    initialState: initialState$v,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
+    initialState: initialState$D,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$D)),
     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$u = assetTypeAttachmentAdapter.getInitialState({});
+  const initialState$C = assetTypeAttachmentAdapter.getInitialState({});
   const assetTypeAttachmentSlice = toolkit.createSlice({
     name: "assetTypeAttachments",
-    initialState: initialState$u,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$u)),
+    initialState: initialState$C,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$C)),
     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$t = issueAdapter.getInitialState({});
+  const initialState$B = issueAdapter.getInitialState({});
   const issueSlice = toolkit.createSlice({
     name: "issues",
-    initialState: initialState$t,
+    initialState: initialState$B,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$t);
+      Object.assign(state, initialState$B);
     }),
     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$s = issueTypeAdapter.getInitialState({});
+  const initialState$A = issueTypeAdapter.getInitialState({});
   const issueTypeSlice = toolkit.createSlice({
     name: "issueTypes",
-    initialState: initialState$s,
+    initialState: initialState$A,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$s);
+      Object.assign(state, initialState$A);
     }),
     reducers: {
       initializeIssueTypes: issueTypeAdapter.initialize,
@@ -1381,15 +1381,15 @@ var __publicField = (obj, key, value) => {
     return selectIssuesOfIssueType(issueTypeId)(state).length;
   };
   const issueTypeReducer = issueTypeSlice.reducer;
-  const initialState$r = {
+  const initialState$z = {
     s3Urls: {}
   };
   const msPerHour = 1e3 * 60 * 60;
   const msPerWeek = msPerHour * 24 * 7;
   const fileSlice = toolkit.createSlice({
     name: "file",
-    initialState: initialState$r,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
+    initialState: initialState$z,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$z)),
     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$q = {
+  const initialState$y = {
     users: {},
     currentUser: null
   };
   const userSlice = toolkit.createSlice({
     name: "users",
-    initialState: initialState$q,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
+    initialState: initialState$y,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$y)),
     reducers: {
       setUsers: (state, action) => {
         const usersMapping = {};
@@ -1481,11 +1481,11 @@ var __publicField = (obj, key, value) => {
   const organizationAccessAdapter = createModelAdapter(
     (organizationAccess) => organizationAccess.offline_id
   );
-  const initialState$p = organizationAccessAdapter.getInitialState({});
+  const initialState$x = organizationAccessAdapter.getInitialState({});
   const organizationAccessSlice = toolkit.createSlice({
     name: "organizationAccess",
-    initialState: initialState$p,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
+    initialState: initialState$x,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$x)),
     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$o = licenseAdapter.getInitialState({});
+  const initialState$w = licenseAdapter.getInitialState({});
   const licenseSlice = toolkit.createSlice({
     name: "license",
-    initialState: initialState$o,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
+    initialState: initialState$w,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$w)),
     reducers: {
       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$n = projectAccessAdapter.getInitialState({});
+  const initialState$v = projectAccessAdapter.getInitialState({});
   const projectAccessSlice = toolkit.createSlice({
     name: "projectAccess",
-    initialState: initialState$n,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
+    initialState: initialState$v,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$v)),
     reducers: {
       initializeProjectAccesses: projectAccessAdapter.initialize,
       updateProjectAccess: projectAccessAdapter.updateOne,
@@ -1596,14 +1596,14 @@ var __publicField = (obj, key, value) => {
     return projectAccesses;
   };
   const projectAccessReducer = projectAccessSlice.reducer;
-  const initialState$m = {
+  const initialState$u = {
     projects: {},
     activeProjectId: null
   };
   const projectSlice = toolkit.createSlice({
     name: "projects",
-    initialState: initialState$m,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
+    initialState: initialState$u,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$u)),
     reducers: {
       setProjects: (state, action) => {
         const projectsMap = {};
@@ -1710,13 +1710,13 @@ var __publicField = (obj, key, value) => {
       });
     }
   );
-  const initialState$l = {
+  const initialState$t = {
     organizations: {}
   };
   const organizationSlice = toolkit.createSlice({
     name: "organizations",
-    initialState: initialState$l,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
+    initialState: initialState$t,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$t)),
     reducers: {
       setOrganizations: (state, action) => {
         for (const org of action.payload) {
@@ -1807,14 +1807,14 @@ var __publicField = (obj, key, value) => {
       }
     };
   };
-  const initialState$k = {
+  const initialState$s = {
     deletedRequests: [],
     latestRetryTime: 0
   };
   const outboxSlice = toolkit.createSlice({
     name: "outbox",
-    initialState: initialState$k,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$k)),
+    initialState: initialState$s,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$s)),
     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$j = {
+  const initialState$r = {
     projectFiles: {},
     activeProjectFileId: null,
     isImportingProjectFile: false
   };
   const projectFileSlice = toolkit.createSlice({
     name: "projectFiles",
-    initialState: initialState$j,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
+    initialState: initialState$r,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
     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$i = projectAttachmentAdapter.getInitialState({});
+  const initialState$q = projectAttachmentAdapter.getInitialState({});
   const projectAttachmentSlice = toolkit.createSlice({
     name: "projectAttachments",
-    initialState: initialState$i,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
+    initialState: initialState$q,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
     reducers: {
       initializeProjectAttachments: projectAttachmentAdapter.initialize,
       addProjectAttachment: projectAttachmentAdapter.addOne,
@@ -2000,12 +2000,12 @@ var __publicField = (obj, key, value) => {
     )
   );
   const projectAttachmentReducer = projectAttachmentSlice.reducer;
-  const initialState$h = {
+  const initialState$p = {
     isRehydrated: false
   };
   const rehydratedSlice = toolkit.createSlice({
     name: "rehydrated",
-    initialState: initialState$h,
+    initialState: initialState$p,
     // 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$g = formRevisionAdapter.getInitialState({});
+  const initialState$o = formRevisionAdapter.getInitialState({});
   const formRevisionsSlice = toolkit.createSlice({
     name: "formRevisions",
-    initialState: initialState$g,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
+    initialState: initialState$o,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
     reducers: {
       initializeFormRevisions: formRevisionAdapter.initialize,
       setFormRevision: formRevisionAdapter.setOne,
@@ -2106,11 +2106,11 @@ var __publicField = (obj, key, value) => {
   });
   const formRevisionReducer = formRevisionsSlice.reducer;
   const formAdapter = createModelAdapter((form) => form.offline_id);
-  const initialState$f = formAdapter.getInitialState({});
+  const initialState$n = formAdapter.getInitialState({});
   const formSlice = toolkit.createSlice({
     name: "forms",
-    initialState: initialState$f,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
+    initialState: initialState$n,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
     reducers: {
       initializeForms: formAdapter.initialize,
       setForm: formAdapter.setOne,
@@ -2156,34 +2156,18 @@ var __publicField = (obj, key, value) => {
   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;
+    return Object.values(formsMapping).length;
   });
   const submissionAdapter = createModelAdapter((submission) => submission.offline_id);
-  const initialState$e = submissionAdapter.getInitialState({});
+  const initialState$m = submissionAdapter.getInitialState({});
   const formSubmissionSlice = toolkit.createSlice({
     name: "formSubmissions",
-    initialState: initialState$e,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
+    initialState: initialState$m,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
     reducers: {
       initializeFormSubmissions: submissionAdapter.initialize,
       setFormSubmission: submissionAdapter.setOne,
@@ -2286,54 +2270,6 @@ 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],
@@ -2344,62 +2280,15 @@ 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$d = formSubmissionAttachmentAdapter.getInitialState({});
+  const initialState$l = formSubmissionAttachmentAdapter.getInitialState({});
   const formSubmissionAttachmentSlice = toolkit.createSlice({
     name: "formSubmissionAttachments",
-    initialState: initialState$d,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
+    initialState: initialState$l,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$l)),
     reducers: {
       initializeFormSubmissionAttachments: formSubmissionAttachmentAdapter.initialize,
       addFormSubmissionAttachment: formSubmissionAttachmentAdapter.addOne,
@@ -2442,7 +2331,9 @@ var __publicField = (obj, key, value) => {
       [selectFormSubmissionAttachmentsMapping, (_state, submissionId) => submissionId],
       (attachmentsMapping, submissionId) => {
         return fallbackToEmptyArray(
-          Object.values(attachmentsMapping).filter((attachment) => attachment.submission === submissionId)
+          Object.values(attachmentsMapping).filter(
+            (attachment) => attachment.form_submission === submissionId
+          )
         );
       }
     )
@@ -2451,11 +2342,11 @@ var __publicField = (obj, key, value) => {
   const formRevisionAttachmentAdapter = createModelAdapter(
     (attachment) => attachment.offline_id
   );
-  const initialState$c = formRevisionAttachmentAdapter.getInitialState({});
+  const initialState$k = formRevisionAttachmentAdapter.getInitialState({});
   const formRevisionAttachmentSlice = toolkit.createSlice({
     name: "formRevisionAttachments",
-    initialState: initialState$c,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
+    initialState: initialState$k,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$k)),
     reducers: {
       initializeFormRevisionAttachments: formRevisionAttachmentAdapter.initialize,
       addFormRevisionAttachment: formRevisionAttachmentAdapter.addOne,
@@ -2487,17 +2378,17 @@ var __publicField = (obj, key, value) => {
       [selectFormRevisionAttachmentsMapping, (_state, revisionId) => revisionId],
       (attachments, revisionId) => {
         return fallbackToEmptyArray(
-          Object.values(attachments).filter((attachment) => attachment.revision === revisionId)
+          Object.values(attachments).filter((attachment) => attachment.form_revision === revisionId)
         );
       }
     )
   );
   const formRevisionAttachmentReducer = formRevisionAttachmentSlice.reducer;
   const workspaceAdapter = createModelAdapter((workspace) => workspace.offline_id);
-  const initialState$b = workspaceAdapter.getInitialState({});
+  const initialState$j = workspaceAdapter.getInitialState({});
   const workspaceSlice = toolkit.createSlice({
     name: "workspace",
-    initialState: initialState$b,
+    initialState: initialState$j,
     reducers: {
       initializeWorkspaces: workspaceAdapter.initialize,
       setWorkspaces: workspaceAdapter.setMany,
@@ -2528,10 +2419,10 @@ var __publicField = (obj, key, value) => {
   );
   const workspaceReducer = workspaceSlice.reducer;
   const emailDomainAdapter = createModelAdapter((emailDomain) => emailDomain.offline_id);
-  const initialState$a = emailDomainAdapter.getInitialState({});
+  const initialState$i = emailDomainAdapter.getInitialState({});
   const emailDomainsSlice = toolkit.createSlice({
     name: "emailDomains",
-    initialState: initialState$a,
+    initialState: initialState$i,
     reducers: {
       initializeEmailDomains: emailDomainAdapter.initialize,
       addEmailDomain: emailDomainAdapter.addOne,
@@ -2552,14 +2443,14 @@ var __publicField = (obj, key, value) => {
     )
   );
   const emailDomainsReducer = emailDomainsSlice.reducer;
-  const initialState$9 = {
+  const initialState$h = {
     documents: {}
   };
   const documentSlice = toolkit.createSlice({
     name: "documents",
-    initialState: initialState$9,
+    initialState: initialState$h,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$9);
+      Object.assign(state, initialState$h);
     }),
     reducers: {
       setDocuments: (state, action) => {
@@ -2748,11 +2639,11 @@ var __publicField = (obj, key, value) => {
   );
   const documentsReducer = documentSlice.reducer;
   const documentAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$8 = documentAttachmentAdapter.getInitialState({});
+  const initialState$g = documentAttachmentAdapter.getInitialState({});
   const documentAttachmentSlice = toolkit.createSlice({
     name: "documentAttachments",
-    initialState: initialState$8,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
+    initialState: initialState$g,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
     reducers: {
       initializeDocumentAttachments: documentAttachmentAdapter.initialize,
       addDocumentAttachment: documentAttachmentAdapter.addOne,
@@ -2811,11 +2702,11 @@ var __publicField = (obj, key, value) => {
   );
   const documentAttachmentReducer = documentAttachmentSlice.reducer;
   const teamAdapter = createModelAdapter((team) => team.offline_id);
-  const initialState$7 = teamAdapter.getInitialState({});
+  const initialState$f = teamAdapter.getInitialState({});
   const teamSlice = toolkit.createSlice({
     name: "teams",
-    initialState: initialState$7,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
+    initialState: initialState$f,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
     reducers: {
       setTeam: teamAdapter.setOne,
       initializeTeams: teamAdapter.initialize,
@@ -2866,11 +2757,11 @@ var __publicField = (obj, key, value) => {
   const agentUserConversationAdapter = createModelAdapter(
     (conversation) => conversation.offline_id
   );
-  const initialState$6 = agentUserConversationAdapter.getInitialState({});
+  const initialState$e = agentUserConversationAdapter.getInitialState({});
   const agentsSlice = toolkit.createSlice({
     name: "agents",
-    initialState: initialState$6,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
+    initialState: initialState$e,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
     reducers: {
       initializeConversations: agentUserConversationAdapter.initialize,
       addConversation: agentUserConversationAdapter.addOne,
@@ -2892,11 +2783,11 @@ var __publicField = (obj, key, value) => {
   );
   const agentsReducer = agentsSlice.reducer;
   const issueCommentAdapter = createModelAdapter((comment) => comment.offline_id);
-  const initialState$5 = issueCommentAdapter.getInitialState({});
+  const initialState$d = issueCommentAdapter.getInitialState({});
   const issueCommentSlice = toolkit.createSlice({
     name: "issueComments",
-    initialState: initialState$5,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
+    initialState: initialState$d,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
     reducers: {
       addIssueComment: issueCommentAdapter.addOne,
       addIssueComments: issueCommentAdapter.addMany,
@@ -2925,11 +2816,11 @@ var __publicField = (obj, key, value) => {
   );
   const issueCommentReducer = issueCommentSlice.reducer;
   const issueUpdateAdapter = createModelAdapter((issueUpdate) => issueUpdate.offline_id);
-  const initialState$4 = issueUpdateAdapter.getInitialState({});
+  const initialState$c = issueUpdateAdapter.getInitialState({});
   const issueUpdateSlice = toolkit.createSlice({
     name: "issueUpdates",
-    initialState: initialState$4,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
+    initialState: initialState$c,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
     reducers: {
       initializeIssueUpdates: issueUpdateAdapter.setMany,
       setIssueUpdate: issueUpdateAdapter.setOne,
@@ -2958,11 +2849,11 @@ var __publicField = (obj, key, value) => {
   );
   const issueUpdateReducer = issueUpdateSlice.reducer;
   const issueAttachmentAdapter = createModelAdapter((attachment) => attachment.offline_id);
-  const initialState$3 = issueAttachmentAdapter.getInitialState({});
+  const initialState$b = issueAttachmentAdapter.getInitialState({});
   const issueAttachmentSlice = toolkit.createSlice({
     name: "issueAttachments",
-    initialState: initialState$3,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$3)),
+    initialState: initialState$b,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
     reducers: {
       initializeIssueAttachments: issueAttachmentAdapter.initialize,
       addIssueAttachment: issueAttachmentAdapter.addOne,
@@ -3020,23 +2911,23 @@ var __publicField = (obj, key, value) => {
     )
   );
   const issueAttachmentReducer = issueAttachmentSlice.reducer;
-  const initialState$2 = {
+  const initialState$a = {
     version: 0
   };
   const versioningSlice = toolkit.createSlice({
     name: "versioning",
-    initialState: initialState$2,
+    initialState: initialState$a,
     reducers: {}
   });
   const versioningReducer = versioningSlice.reducer;
   const geoImageAdapter = createModelAdapter((model) => model.offline_id);
-  const initialState$1 = geoImageAdapter.getInitialState({});
+  const initialState$9 = geoImageAdapter.getInitialState({});
   const geoImageSlice = toolkit.createSlice({
     name: "geoImages",
-    initialState: initialState$1,
+    initialState: initialState$9,
     extraReducers: (builder) => {
       builder.addCase("RESET", (state) => {
-        Object.assign(state, initialState$1);
+        Object.assign(state, initialState$9);
       });
     },
     reducers: {
@@ -3074,11 +2965,11 @@ var __publicField = (obj, key, value) => {
   );
   const geoImageReducer = geoImageSlice.reducer;
   const issueAssociationAdapter = createModelAdapter((assoc) => assoc.offline_id);
-  const initialState = issueAssociationAdapter.getInitialState({});
+  const initialState$8 = issueAssociationAdapter.getInitialState({});
   const issueAssociationSlice = toolkit.createSlice({
     name: "issueAssociations",
-    initialState,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState)),
+    initialState: initialState$8,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
     reducers: {
       initializeIssueAssociations: issueAssociationAdapter.initialize,
       addIssueAssociation: issueAssociationAdapter.addOne,
@@ -3136,86 +3027,462 @@ var __publicField = (obj, key, value) => {
     )
   );
   const issueAssociationReducer = issueAssociationSlice.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);
+  const issueTypeFieldsAdapter = createModelAdapter((fields) => fields.offline_id);
+  const initialState$7 = issueTypeFieldsAdapter.getInitialState({});
+  const issueTypeFieldsSlice = toolkit.createSlice({
+    name: "issueTypeFields",
+    initialState: initialState$7,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
+    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
     }
-  }
-  const VERSION_REDUCER_KEY = "versioning";
-  const overmapReducers = {
-    // TODO: attachmentReducer,
-    [VERSION_REDUCER_KEY]: versioningReducer,
-    fileReducer,
-    authReducer,
-    categoryReducer,
-    assetReducer,
-    assetAttachmentReducer,
-    assetStageCompletionReducer,
-    assetStageReducer,
-    assetTypeReducer,
-    assetTypeAttachmentReducer,
-    issueReducer,
-    issueAttachmentReducer,
-    issueTypeReducer,
-    organizationReducer,
-    outboxReducer,
-    projectReducer,
-    projectAttachmentReducer,
-    projectAccessReducer,
-    organizationAccessReducer,
-    projectFileReducer,
-    rehydratedReducer,
-    formReducer,
-    formRevisionReducer,
-    formRevisionAttachmentReducer,
-    formSubmissionAttachmentReducer,
-    formSubmissionReducer,
-    userReducer,
-    workspaceReducer,
-    emailDomainsReducer,
-    licenseReducer,
-    documentsReducer,
-    documentAttachmentReducer,
-    teamReducer,
-    agentsReducer,
-    issueCommentReducer,
-    issueUpdateReducer,
-    geoImageReducer,
-    issueAssociationReducer
+  });
+  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 selectIssueTypeFieldsById = (fieldsId) => (state) => {
+    return state.issueTypeFieldsReducer.instances[fieldsId];
   };
-  const overmapReducer = toolkit.combineReducers(overmapReducers);
-  const resetStore = "RESET";
-  const overmapRootReducer = (state, action) => {
-    if (action.type === "auth/setLoggedIn" && !action.payload) {
-      return overmapReducer(void 0, action);
+  const issueTypeFieldsReducer = issueTypeFieldsSlice.reducer;
+  const issueTypeFieldValuesAdapter = createModelAdapter(
+    (fieldValues) => fieldValues.offline_id
+  );
+  const initialState$6 = issueTypeFieldValuesAdapter.getInitialState({});
+  const issueTypeFieldValuesSlice = toolkit.createSlice({
+    name: "issueTypeFieldValues",
+    initialState: initialState$6,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
+    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
     }
-    return overmapReducer(state, action);
+  });
+  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];
   };
-  let __OUTBOX_COORDINATOR = null;
-  function getOutboxCoordinator() {
+  const issueTypeFieldValuesReducer = issueTypeFieldValuesSlice.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
+    }
+  });
+  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 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 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);
+    }
+  }
+  const VERSION_REDUCER_KEY = "versioning";
+  const overmapReducers = {
+    // TODO: attachmentReducer,
+    [VERSION_REDUCER_KEY]: versioningReducer,
+    fileReducer,
+    authReducer,
+    categoryReducer,
+    assetReducer,
+    assetAttachmentReducer,
+    assetStageCompletionReducer,
+    assetStageReducer,
+    assetTypeReducer,
+    assetTypeAttachmentReducer,
+    issueReducer,
+    issueAttachmentReducer,
+    issueTypeReducer,
+    organizationReducer,
+    outboxReducer,
+    projectReducer,
+    projectAttachmentReducer,
+    projectAccessReducer,
+    organizationAccessReducer,
+    projectFileReducer,
+    rehydratedReducer,
+    formReducer,
+    formRevisionReducer,
+    formRevisionAttachmentReducer,
+    formSubmissionAttachmentReducer,
+    formSubmissionReducer,
+    userReducer,
+    workspaceReducer,
+    emailDomainsReducer,
+    licenseReducer,
+    documentsReducer,
+    documentAttachmentReducer,
+    teamReducer,
+    agentsReducer,
+    issueCommentReducer,
+    issueUpdateReducer,
+    geoImageReducer,
+    issueAssociationReducer,
+    issueTypeFieldsReducer,
+    issueTypeFieldValuesReducer,
+    issueTypeFieldsAttachmentReducer,
+    issueTypeFieldValuesAttachmentReducer,
+    assetTypeFieldsReducer,
+    assetTypeFieldValuesReducer,
+    assetTypeFieldsAttachmentReducer,
+    assetTypeFieldValuesAttachmentReducer
+  };
+  const overmapReducer = toolkit.combineReducers(overmapReducers);
+  const resetStore = "RESET";
+  const overmapRootReducer = (state, action) => {
+    if (action.type === "auth/setLoggedIn" && !action.payload) {
+      return overmapReducer(void 0, action);
+    }
+    return overmapReducer(state, action);
+  };
+  let __OUTBOX_COORDINATOR = null;
+  function getOutboxCoordinator() {
     const clientStore2 = getClientStore();
     if (!clientStore2) {
       console.warn("Client store not set; cannot get outbox coordinator yet.");
@@ -3846,9 +4113,6 @@ 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]
@@ -4061,7 +4325,10 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get assets",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/assets/`,
+        url: "/assets/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -4082,7 +4349,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add asset stage completion",
         method: HttpMethod.POST,
-        url: "/assets/completions/",
+        url: "/asset-stage-completions/",
         payload: {
           offline_id: offlineStageCompletion.offline_id,
           submitted_at: submittedAt,
@@ -4109,7 +4376,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete asset stage completion",
         method: HttpMethod.DELETE,
-        url: `/assets/completions/${id}/`,
+        url: `/asset-stage-completions/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -4135,7 +4402,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Bulk create asset stage completions",
         method: HttpMethod.POST,
-        url: "/assets/completions/bulk/",
+        url: "/asset-stage-completions/bulk/",
         payload: {
           submitted_at: submittedAt,
           completions: payload
@@ -4157,7 +4424,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Deleting asset stage completions",
         method: HttpMethod.DELETE,
-        url: "/assets/completions/bulk/",
+        url: "/asset-stage-completions/bulk/",
         payload: {
           completion_ids: ids
         },
@@ -4173,7 +4440,10 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get asset stage completions",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/asset-stage-completions/`,
+        url: "/asset-stage-completions/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -4194,7 +4464,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add asset stages",
         method: HttpMethod.POST,
-        url: "/assets/stages/bulk/",
+        url: "/asset-stages/bulk/",
         payload: {
           submitted_at: submittedAt,
           asset_type: assetTypeId,
@@ -4218,7 +4488,7 @@ var __publicField = (obj, key, value) => {
       return this.enqueueRequest({
         description: "Edit asset stages",
         method: HttpMethod.PATCH,
-        url: `/assets/types/${assetTypeId}/bulk-update-stages/`,
+        url: `/asset-types/${assetTypeId}/bulk-update-stages/`,
         payload: {
           stages: stagesToUpdate
         },
@@ -4236,7 +4506,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete asset stages",
         method: HttpMethod.DELETE,
-        url: "/assets/stages/bulk/",
+        url: "/asset-stages/bulk/",
         payload: {
           stage_ids: idsToDelete
         },
@@ -4261,7 +4531,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Update asset stage",
         method: HttpMethod.PATCH,
-        url: `/assets/stages/${assetStage.offline_id}/`,
+        url: `/asset-stages/${assetStage.offline_id}/`,
         payload: {
           name: payload.name,
           description: payload.description,
@@ -4289,7 +4559,7 @@ var __publicField = (obj, key, value) => {
         await this.enqueueRequest({
           description: "Link asset stage to form",
           method: HttpMethod.POST,
-          url: `/assets/stages/${stageId}/associate-with-form/`,
+          url: `/asset-stages/${stageId}/associate-with-form/`,
           payload: { form: formId },
           blockers: [stageId, formId],
           blocks: [stageId]
@@ -4310,7 +4580,7 @@ var __publicField = (obj, key, value) => {
         await this.enqueueRequest({
           description: "Unlink asset stage from form",
           method: HttpMethod.DELETE,
-          url: `/assets/stages/${stageId}/associate-with-form/`,
+          url: `/asset-stages/${stageId}/associate-with-form/`,
           blockers: [stageId, formId],
           blocks: [stageId]
         });
@@ -4323,7 +4593,10 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get asset stages",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/asset-stages/`,
+        url: "/asset-stages/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -4340,7 +4613,12 @@ var __publicField = (obj, key, value) => {
         projectAttachmentReducer: projectAttachmentReducer2,
         formRevisionAttachmentReducer: formRevisionAttachmentReducer2,
         formSubmissionAttachmentReducer: formSubmissionAttachmentReducer2,
-        geoImageReducer: geoImageReducer2
+        geoImageReducer: geoImageReducer2,
+        // fields
+        assetTypeFieldsAttachmentReducer: assetTypeFieldsAttachmentReducer2,
+        assetTypeFieldValuesAttachmentReducer: assetTypeFieldValuesAttachmentReducer2,
+        issueTypeFieldsAttachmentReducer: issueTypeFieldsAttachmentReducer2,
+        issueTypeFieldValuesAttachmentReducer: issueTypeFieldValuesAttachmentReducer2
       } = this.client.store.getState();
       const objectsWithSha1 = [].concat(
         Object.values(issueAttachmentReducer2.instances),
@@ -4350,7 +4628,11 @@ var __publicField = (obj, key, value) => {
         Object.values(projectAttachmentReducer2.instances),
         Object.values(formRevisionAttachmentReducer2.instances),
         Object.values(formSubmissionAttachmentReducer2.instances),
-        Object.values(geoImageReducer2.instances)
+        Object.values(geoImageReducer2.instances),
+        Object.values(assetTypeFieldsAttachmentReducer2.instances),
+        Object.values(assetTypeFieldValuesAttachmentReducer2.instances),
+        Object.values(issueTypeFieldsAttachmentReducer2.instances),
+        Object.values(issueTypeFieldValuesAttachmentReducer2.instances)
       );
       return objectsWithSha1.filter((object) => object.file_sha1 === sha1).length;
     }
@@ -4372,41 +4654,20 @@ var __publicField = (obj, key, value) => {
       }
       return promisesBySha1;
     }
-  }
-  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"
+    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;
     }
-  };
+  }
   class BaseAttachmentService extends BaseUploadService {
-    async attachFiles(files, modelId, buildOfflineAttachment) {
+    async _bulkAdd(payloads) {
       var _a2;
       const { store } = this.client;
       const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
@@ -4414,39 +4675,36 @@ var __publicField = (obj, key, value) => {
       const offlineAttachments = [];
       const attachmentPayloads = [];
       const filePayloads = {};
-      for (const file of files) {
-        const sha1 = await hashFile(file);
-        if (!(sha1 in filePayloads)) {
-          filePayloads[sha1] = {
-            sha1,
-            file_type: file.type,
-            extension: file.name.split(".").pop(),
-            size: file.size
-          };
-          await this.client.files.addCache(file, sha1);
-        }
-        const offlineAttachment = buildOfflineAttachment({
+      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({
           file,
-          sha1,
-          submittedAt,
-          createdBy,
+          file_sha1: filePayload.sha1,
+          submitted_at: submittedAt,
+          created_by: createdBy,
           description: "",
           modelId
         });
         offlineAttachments.push(offlineAttachment);
-        attachmentPayloads.push({
-          offline_id: offlineAttachment.offline_id,
-          name: offlineAttachment.file_name,
-          sha1: offlineAttachment.file_sha1,
-          description: offlineAttachment.description
-        });
+        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
+          })
+        );
       }
       this.dispatch(this.addAttachments(offlineAttachments));
-      const meta = AttachmentModelMeta[this.attachmentModel];
       const promise = this.enqueueRequest({
-        description: `Attach files to ${meta.name}`,
+        description: `Add ${this.name}`,
         method: HttpMethod.POST,
-        url: `${meta.attachUrlPrefix}/${modelId}/attach/`,
+        url: `${this.url}/bulk/`,
         payload: {
           submitted_at: submittedAt,
           attachments: attachmentPayloads,
@@ -4463,7 +4721,7 @@ var __publicField = (obj, key, value) => {
       });
       return [offlineAttachments, promise.then(({ attachments }) => attachments)];
     }
-    async deleteAttachment(attachmendId) {
+    async _delete(attachmendId) {
       const { store } = this.client;
       const attachment = this.selectAttachment(attachmendId)(store.getState());
       if (!attachment) {
@@ -4472,11 +4730,10 @@ var __publicField = (obj, key, value) => {
         );
       }
       this.dispatch(this.removeAttachment(attachment.offline_id));
-      const meta = AttachmentModelMeta[this.attachmentModel];
       const promise = this.enqueueRequest({
-        description: "Delete attachment",
+        description: `Delete ${this.name}`,
         method: HttpMethod.DELETE,
-        url: `${meta.deleteUrlPrefix}/attachments/${attachmendId}/`,
+        url: `${this.url}/${attachmendId}/`,
         blockers: [attachmendId],
         blocks: []
       });
@@ -4489,24 +4746,12 @@ 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, "attachmentModel", AttachmentModel.Asset);
+      __publicField(this, "name", "Asset Attachment");
+      __publicField(this, "url", "/asset-attachments");
       __publicField(this, "initializeAttachments", initializeAssetAttachments);
       __publicField(this, "addAttachments", addAssetAttachments);
       __publicField(this, "updateAttachments", updateAssetAttachments);
@@ -4518,20 +4763,39 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.sha1,
-        created_by: data.createdBy,
+        file_sha1: data.file_sha1,
+        created_by: data.created_by,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submittedAt,
+        submitted_at: data.submitted_at,
         description: data.description,
         asset: data.modelId
       });
     }
-    async attachFilesToAsset(files, assetId) {
-      return this.attachFiles(files, assetId, this.buildOfflineAttachment.bind(this));
+    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 deleteAssetAttachment(attachmentId) {
-      return this.deleteAttachment(attachmentId);
+    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));
     }
   }
   class AssetTypeService extends BaseApiService {
@@ -4548,7 +4812,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Create asset type",
         method: HttpMethod.POST,
-        url: `/projects/${payload.project}/asset-types/`,
+        url: "/asset-types/",
         payload: { ...offlineAssetType },
         blockers: [],
         blocks: [offlineAssetType.offline_id]
@@ -4574,7 +4838,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Update asset type",
         method: HttpMethod.PATCH,
-        url: `/assets/types/${payload.offline_id}/`,
+        url: `/asset-types/${payload.offline_id}/`,
         payload: {
           icon: payload.icon,
           color: payload.color,
@@ -4608,7 +4872,7 @@ var __publicField = (obj, key, value) => {
       return this.enqueueRequest({
         description: "Delete asset type",
         method: HttpMethod.DELETE,
-        url: `/assets/types/${assetTypeId}/`,
+        url: `/asset-types/${assetTypeId}/`,
         blockers: [assetTypeId],
         blocks: []
       }).catch((e) => {
@@ -4623,7 +4887,10 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get asset types",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/asset-types/`,
+        url: "/asset-types/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -4633,8 +4900,8 @@ var __publicField = (obj, key, value) => {
   class AssetTypeAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "attachmentModel", AttachmentModel.AssetType);
-      __publicField(this, "initializeAttachments", initializeAssetTypeAttachments);
+      __publicField(this, "name", "Asset Type Attachment");
+      __publicField(this, "url", "/asset-type-attachments");
       __publicField(this, "addAttachments", addAssetTypeAttachments);
       __publicField(this, "updateAttachments", updateAssetTypeAttachments);
       __publicField(this, "removeAttachments", deleteAssetTypeAttachments);
@@ -4645,20 +4912,39 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.sha1,
-        created_by: data.createdBy,
+        file_sha1: data.file_sha1,
+        created_by: data.created_by,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submittedAt,
+        submitted_at: data.submitted_at,
         description: data.description,
         asset_type: data.modelId
       });
     }
-    async attachFilesToAssetType(files, assetTypeId) {
-      return this.attachFiles(files, assetTypeId, this.buildOfflineAttachment.bind(this));
+    buildAttachmentPayload(data) {
+      return {
+        ...data,
+        asset_type: data.modelId
+      };
+    }
+    async bulkAdd(payloads) {
+      return this._bulkAdd(payloads.map((p) => ({ modelId: p.assetTypeId, file: p.file })));
+    }
+    async delete(attachmentId) {
+      return this._delete(attachmentId);
     }
-    async deleteAssetTypeAttachment(attachmentId) {
-      return this.deleteAttachment(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));
     }
   }
   class IssueCommentService extends BaseApiService {
@@ -4674,7 +4960,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add issue comment",
         method: HttpMethod.POST,
-        url: `/issues/${payload.issue}/comment/`,
+        url: "/issue-comments/",
         payload: offlineComment,
         blockers: [payload.issue],
         blocks: [offlineComment.offline_id]
@@ -4698,7 +4984,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Edit issue comment",
         method: HttpMethod.PATCH,
-        url: `/issues/comments/${payload.offline_id}/`,
+        url: `/issue-comments/${payload.offline_id}/`,
         payload,
         blockers: [payload.offline_id],
         blocks: [payload.offline_id]
@@ -4717,7 +5003,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete comment",
         method: HttpMethod.DELETE,
-        url: `/issues/comments/${id}/`,
+        url: `/issue-comments/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -4730,7 +5016,10 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get comments",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/comments/`,
+        url: "/issue-comments/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -4742,27 +5031,21 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get issue updates",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/issues/updates/`,
+        url: "/issue-updates/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
-      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));
+      this.dispatch(initializeIssueUpdates(result));
     }
   }
   class IssueAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "attachmentModel", AttachmentModel.Issue);
-      __publicField(this, "initializeAttachments", initializeIssueAttachments);
+      __publicField(this, "name", "Issue Attachment");
+      __publicField(this, "url", "/issue-attachments");
       __publicField(this, "addAttachments", addIssueAttachments);
       __publicField(this, "updateAttachments", updateIssueAttachments);
       __publicField(this, "removeAttachments", deleteIssueAttachments);
@@ -4773,24 +5056,42 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.sha1,
-        created_by: data.createdBy,
+        file_sha1: data.file_sha1,
+        created_by: data.created_by,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submittedAt,
+        submitted_at: data.submitted_at,
         description: data.description,
         issue: data.modelId
       });
     }
-    async attachFilesToIssue(files, issueId) {
-      return this.attachFiles(files, issueId, this.buildOfflineAttachment.bind(this));
+    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 deleteIssueAttachment(attachmentId) {
-      return this.deleteAttachment(attachmentId);
+    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));
     }
   }
   class IssueService extends BaseApiService {
-    // Basic CRUD functions
     add(payload) {
       var _a2;
       const { store } = this.client;
@@ -4808,10 +5109,6 @@ 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]
@@ -4967,7 +5264,10 @@ var __publicField = (obj, key, value) => {
       const result = await this.enqueueRequest({
         description: "Get issues",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/issues/`,
+        url: "/issues/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -4987,7 +5287,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(addIssueType(offlineIssueType));
       const promise = this.enqueueRequest({
         method: HttpMethod.POST,
-        url: `/organizations/${payload.organization}/issue-types/`,
+        url: "/issue-types/",
         // Sending only whats needed here
         payload: {
           offline_id: offlineIssueType.offline_id,
@@ -5021,7 +5321,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(updateIssueType(offlineUpdatedIssueType));
       const promise = this.enqueueRequest({
         method: HttpMethod.PATCH,
-        url: `/issues/types/${payload.offline_id}/`,
+        url: `/issue-types/${payload.offline_id}/`,
         payload,
         blockers: [payload.offline_id],
         blocks: [payload.offline_id]
@@ -5045,7 +5345,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(deleteIssues(issuesOfIssueType.map((issue) => issue.offline_id)));
       const promise = this.enqueueRequest({
         method: HttpMethod.DELETE,
-        url: `/issues/types/${id}/`,
+        url: `/issue-types/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -5058,7 +5358,10 @@ var __publicField = (obj, key, value) => {
     async refreshStore(organizationId) {
       const result = await this.enqueueRequest({
         method: HttpMethod.GET,
-        url: `/organizations/${organizationId}/issue-types/`,
+        url: "/issue-types/",
+        queryParams: {
+          organization: organizationId.toString()
+        },
         blockers: [],
         blocks: []
       });
@@ -5202,8 +5505,8 @@ var __publicField = (obj, key, value) => {
   class ProjectAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "attachmentModel", AttachmentModel.Project);
-      __publicField(this, "initializeAttachments", initializeProjectAttachments);
+      __publicField(this, "name", "Project Attachment");
+      __publicField(this, "url", "/project-attachments");
       __publicField(this, "addAttachments", addProjectAttachments);
       __publicField(this, "updateAttachments", updateProjectAttachments);
       __publicField(this, "removeAttachments", deleteProjectAttachments);
@@ -5214,20 +5517,39 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.sha1,
-        created_by: data.createdBy,
+        file_sha1: data.file_sha1,
+        created_by: data.created_by,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submittedAt,
+        submitted_at: data.submitted_at,
         description: data.description,
         project: data.modelId
       });
     }
-    async attachFilesToProject(files, projectId) {
-      return this.attachFiles(files, projectId, this.buildOfflineAttachment.bind(this));
+    buildAttachmentPayload(data) {
+      return {
+        ...data,
+        project: data.modelId
+      };
     }
-    async deleteProjectAttachment(attachmentId) {
-      return this.deleteAttachment(attachmentId);
+    async bulkAdd(payloads) {
+      return this._bulkAdd(payloads.map((p) => ({ modelId: p.projectId, file: p.file })));
+    }
+    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));
     }
   }
   class ProjectService extends BaseApiService {
@@ -5370,88 +5692,33 @@ var __publicField = (obj, key, value) => {
     return { fields: newFields, images };
   };
   class FormService extends BaseUploadService {
-    async bulkAddRevisionAttachments(revisionId, files) {
+    add(payload, initialRevision) {
       var _a2;
+      const { store } = this.client;
       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 [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/revisions/${revisionId}/attachments/bulk/`,
-        payload: {
-          submitted_at: submittedAt,
-          attachments: attachmentPayloads,
-          files: Object.values(filePayloads)
-        },
-        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)
-          )
-        );
+      const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
+      const offlineForm = offline({
+        ...payload,
+        submitted_at: submittedAt,
+        created_by: createdBy
       });
-      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"
+        form: offlineForm.offline_id,
+        revision: "Pending",
+        submitted_at: submittedAt,
+        created_by: createdBy
       });
-      this.dispatch(addForm(form));
+      this.dispatch(addForm(offlineForm));
       this.dispatch(addFormRevision(offlineFormRevision));
       const formPromise = this.enqueueRequest({
         description: "Create form",
         method: HttpMethod.POST,
-        url: urlPrefix,
+        url: "/forms/",
         payload: {
           // Sending exactly what is currently needed for the endpoint
-          offline_id: form.offline_id,
-          submitted_at: form.submitted_at,
+          offline_id: offlineForm.offline_id,
+          submitted_at: offlineForm.submitted_at,
           initial_revision: {
             offline_id: offlineFormRevision.offline_id,
             submitted_at: offlineFormRevision.submitted_at,
@@ -5460,111 +5727,18 @@ var __publicField = (obj, key, value) => {
             fields: offlineFormRevision.fields
           }
         },
-        blockers: [ownerId],
-        blocks: [form.offline_id, offlineFormRevision.offline_id]
+        blockers: [
+          ...payload.project ? [payload.project.toString()] : [],
+          ...payload.organization ? [payload.organization.toString()] : []
+        ],
+        blocks: [offlineForm.offline_id, offlineFormRevision.offline_id]
       });
-      const [offlineFormRevisionAttachments, attachmentsPromise] = await this.bulkAddRevisionAttachments(
-        offlineFormRevision.offline_id,
-        images
-      );
       void formPromise.catch((e) => {
-        this.dispatch(deleteForm(form.offline_id));
+        this.dispatch(deleteForm(offlineForm.offline_id));
         this.dispatch(deleteFormRevision(offlineFormRevision.offline_id));
         throw e;
       });
-      return [form, offlineFormRevision, offlineFormRevisionAttachments, formPromise, attachmentsPromise];
-    }
-    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];
+      return [offlineForm, offlineFormRevision, formPromise];
     }
     async delete(id) {
       const { store } = this.client;
@@ -5601,65 +5775,31 @@ var __publicField = (obj, key, value) => {
         throw e;
       }
     }
-    async refreshStore(projectId) {
-      const forms = [];
-      const revisions = [];
-      const attachments = [];
-      const projectFormsResult = await this.enqueueRequest({
+    async refreshStore(projectId, organizationId) {
+      let forms = [];
+      const projectForms = await this.enqueueRequest({
         description: "Fetch project forms",
         method: HttpMethod.GET,
-        url: `/projects/${projectId}/forms/`,
+        url: "/forms/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [projectId.toString()],
         blocks: []
       });
-      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({
+      forms = forms.concat(projectForms);
+      const organizationForms = await this.enqueueRequest({
         description: "Fetch organization forms",
         method: HttpMethod.GET,
-        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()],
+        url: "/forms/",
+        queryParams: {
+          organization: organizationId.toString()
+        },
+        blockers: [organizationId.toString()],
         blocks: []
       });
-      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);
+      forms = forms.concat(organizationForms);
       this.dispatch(initializeForms(forms));
-      this.dispatch(initializeFormRevisions(revisions));
-      this.dispatch(initializeFormRevisionAttachments(attachments));
     }
   }
   const isArrayOfFiles = (value) => {
@@ -5681,95 +5821,11 @@ var __publicField = (obj, key, value) => {
     return { values: newValues, files };
   };
   class FormSubmissionService extends BaseUploadService {
-    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) {
+    add(payload) {
       var _a2;
       const { store } = this.client;
       const state = store.getState();
-      const { values, files } = separateFilesFromValues(payload.values);
+      const { values } = separateFilesFromValues(payload.values);
       const offlineSubmission = offline({
         ...payload,
         values,
@@ -5779,7 +5835,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Respond to form",
         method: HttpMethod.POST,
-        url: `/forms/revisions/${payload.form_revision}/respond/`,
+        url: "/form-submissions/",
         payload: offlineSubmission,
         blockers: [payload.issue, payload.asset, payload.asset_stage, "add-form-entry"].filter(
           (x) => x !== void 0
@@ -5787,10 +5843,6 @@ 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));
@@ -5799,115 +5851,16 @@ var __publicField = (obj, key, value) => {
         this.dispatch(deleteFormSubmission(offlineSubmission.offline_id));
         this.dispatch(addActiveProjectFormSubmissionsCount(-1));
       });
-      return [offlineSubmission, offlineFormSubmissionAttachments, promise, attachmentsPromise];
-    }
-    // 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;
+      return [offlineSubmission, promise];
     }
-    async update(payload) {
+    update(payload) {
       const { store } = this.client;
       const state = store.getState();
       const submissionToBeUpdated = selectFormSubmissionById(payload.offline_id)(state);
       if (!submissionToBeUpdated) {
         throw new Error(`Expected submission with offline_id ${payload.offline_id} to exist`);
       }
-      const { values, files } = separateFilesFromValues(payload.values ?? {});
+      const { values } = separateFilesFromValues(payload.values ?? {});
       const updatedSubmission = {
         ...submissionToBeUpdated,
         ...payload,
@@ -5921,39 +5874,18 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete user form submissions",
         method: HttpMethod.PATCH,
-        url: `/forms/submissions/${updatedSubmission.offline_id}/`,
+        url: `/form-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,
-        offlineFormSubmissionAttachments,
-        promise,
-        attachmentsPromise,
-        deleteAttachmentsPromise
-      ];
+      return [updatedSubmission, promise];
     }
     async delete(id) {
       const { store } = this.client;
@@ -5970,7 +5902,7 @@ var __publicField = (obj, key, value) => {
         return await this.enqueueRequest({
           description: "Delete user form submissions",
           method: HttpMethod.DELETE,
-          url: `/forms/submissions/${id}/`,
+          url: `/form-submissions/${id}/`,
           blockers: [id],
           blocks: []
         });
@@ -5982,50 +5914,17 @@ var __publicField = (obj, key, value) => {
       }
     }
     async refreshStore(projectId) {
-      const formSubmissions = {};
-      const modelSubmissions = await this.enqueueRequest({
-        description: "Fetch model submissions",
-        method: HttpMethod.GET,
-        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",
+      const result = await this.enqueueRequest({
+        description: "Fetch form submissions",
         method: HttpMethod.GET,
-        url: `/forms/in-project/${projectId}/attachments/standalone/`,
+        url: "/form-submissions/",
+        queryParams: {
+          project: projectId.toString()
+        },
         blockers: [],
         blocks: []
       });
-      for (const standaloneAttachent of standaloneAttachments) {
-        attachments[standaloneAttachent.offline_id] = standaloneAttachent;
-      }
-      this.dispatch(initializeFormSubmissionAttachments(Object.values(attachments)));
+      this.dispatch(initializeFormSubmissions(result));
     }
   }
   class WorkspaceService extends BaseApiService {
@@ -6727,8 +6626,8 @@ var __publicField = (obj, key, value) => {
   class DocumentAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "attachmentModel", AttachmentModel.Document);
-      __publicField(this, "initializeAttachments", initializeDocumentAttachments);
+      __publicField(this, "name", "Document Attachment");
+      __publicField(this, "url", "/document-attachments");
       __publicField(this, "addAttachments", addDocumentAttachments);
       __publicField(this, "updateAttachments", updateDocumentAttachments);
       __publicField(this, "removeAttachments", deleteDocumentAttachments);
@@ -6739,17 +6638,23 @@ var __publicField = (obj, key, value) => {
     buildOfflineAttachment(data) {
       return offline({
         file: URL.createObjectURL(data.file),
-        file_sha1: data.sha1,
-        created_by: data.createdBy,
+        file_sha1: data.file_sha1,
+        created_by: data.created_by,
         file_name: data.file.name,
         file_type: data.file.type,
-        submitted_at: data.submittedAt,
+        submitted_at: data.submitted_at,
         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 attachFilesToDocument(files, documentId) {
+    async bulkAdd(payloads) {
       var _a2;
       const { store } = this.client;
       const createdBy = (_a2 = store.getState().userReducer.currentUser) == null ? void 0 : _a2.id;
@@ -6758,40 +6663,36 @@ var __publicField = (obj, key, value) => {
       const attachmentPayloads = [];
       const filePayloads = {};
       const sha1ToAttachmentIds = {};
-      for (const file of files) {
-        const sha1 = await hashFile(file);
-        if (!(sha1 in filePayloads)) {
-          filePayloads[sha1] = {
-            sha1,
-            file_type: file.type,
-            extension: file.name.split(".").pop(),
-            size: file.size
-          };
-          sha1ToAttachmentIds[sha1] = [];
-          await this.client.files.addCache(file, sha1);
+      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] = [];
         }
         const offlineAttachment = this.buildOfflineAttachment({
           file,
-          sha1,
-          submittedAt,
-          createdBy,
+          file_sha1: filePayload.sha1,
+          submitted_at: submittedAt,
+          created_by: createdBy,
           description: "",
           modelId: documentId
         });
         offlineAttachments.push(offlineAttachment);
         attachmentPayloads.push({
           offline_id: offlineAttachment.offline_id,
-          name: offlineAttachment.file_name,
-          sha1: offlineAttachment.file_sha1,
+          file_name: offlineAttachment.file_name,
+          file_sha1: offlineAttachment.file_sha1,
+          file_extension: filePayload.extension,
           description: offlineAttachment.description
         });
-        sha1ToAttachmentIds[sha1].push(offlineAttachment.offline_id);
+        sha1ToAttachmentIds[filePayload.sha1].push(offlineAttachment.offline_id);
       }
       this.dispatch(this.addAttachments(offlineAttachments));
       const promise = this.enqueueRequest({
         description: "Attach files to document",
         method: HttpMethod.POST,
-        url: `/documents/${documentId}/attach/`,
+        url: "/document-attachments/bulk/",
         payload: {
           submitted_at: submittedAt,
           attachments: attachmentPayloads,
@@ -6816,14 +6717,14 @@ var __publicField = (obj, key, value) => {
       });
       return [offlineAttachments, promise.then(({ attachments }) => attachments)];
     }
-    async deleteDocumentAttachment(attachmentId) {
-      return this.deleteAttachment(attachmentId);
+    async delete(id) {
+      return this._delete(id);
     }
     makeReadable(attachmnentId) {
       void this.enqueueRequest({
         description: "Add attachment to AI assistant",
         method: HttpMethod.PATCH,
-        url: `/documents/attachments/${attachmnentId}/`,
+        url: `/document-attachments/${attachmnentId}/`,
         payload: {
           readable_to_assistant: true
         },
@@ -6840,7 +6741,7 @@ var __publicField = (obj, key, value) => {
         blocks: [],
         blockers: []
       });
-      this.dispatch(this.initializeAttachments(projectDocumentAttachments));
+      this.dispatch(initializeDocumentAttachments(projectDocumentAttachments));
       const organizationDocumentAttachments = await this.enqueueRequest({
         description: "Get document attachments",
         method: HttpMethod.GET,
@@ -7084,17 +6985,11 @@ 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 sha1 = await hashFile(file);
-      const filePayload = {
-        sha1,
-        file_type: file.type,
-        extension: file.name.split(".").pop(),
-        size: file.size
-      };
+      const filePayload = await this.getFilePayload(file);
       const offlineMapImage = offline({
         ...payloadWithoutFile,
         file_name: file.name,
-        file_sha1: sha1,
+        file_sha1: filePayload.sha1,
         file: URL.createObjectURL(file),
         submitted_at: submittedAt,
         created_by: createdBy
@@ -7137,23 +7032,16 @@ var __publicField = (obj, key, value) => {
       const offlineGeoImages = [];
       const offlineIds = [];
       const geoImagePayloads = [];
-      const filePayloadRecord = {};
+      const filePayloads = {};
       for (const payloadAndFile of payloads) {
         const { file, ...payload } = payloadAndFile;
-        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 filePayload = await this.getFilePayload(file);
+        if (!(filePayload.sha1 in filePayloads))
+          filePayloads[filePayload.sha1] = filePayload;
         const offlineMapImage = offline({
           ...payload,
           file_name: file.name,
-          file_sha1: sha1,
+          file_sha1: filePayload.sha1,
           file: URL.createObjectURL(file),
           submitted_at: submittedAt,
           created_by: createdBy,
@@ -7182,7 +7070,7 @@ var __publicField = (obj, key, value) => {
           submitted_at: submittedAt,
           project: projectId,
           geo_images: geoImagePayloads,
-          files: Object.values(filePayloadRecord)
+          files: Object.values(filePayloads)
         },
         blocks: [projectId.toString()],
         blockers: offlineIds
@@ -7250,7 +7138,7 @@ var __publicField = (obj, key, value) => {
       this.dispatch(initializeGeoImages(result));
     }
   }
-  class IssueAssociationService extends BaseUploadService {
+  class IssueAssociationService extends BaseApiService {
     add(payload) {
       var _a2;
       const { store } = this.client;
@@ -7265,7 +7153,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Add issue association",
         method: HttpMethod.POST,
-        url: "/issues/associations/",
+        url: "/issue-associations/",
         payload: {
           offline_id: offlineIssueAssociation.offline_id,
           submitted_at: submittedAt,
@@ -7295,7 +7183,7 @@ var __publicField = (obj, key, value) => {
       const promise = this.enqueueRequest({
         description: "Delete issue association",
         method: HttpMethod.DELETE,
-        url: `/issues/associations/${id}/`,
+        url: `/issue-associations/${id}/`,
         blockers: [id],
         blocks: []
       });
@@ -7308,14 +7196,854 @@ var __publicField = (obj, key, value) => {
       const issueAssociations = await this.enqueueRequest({
         description: "Fetch issue associations",
         method: HttpMethod.GET,
-        url: "/issues/associations/",
-        queryParams: { project_id: projectId.toString() },
+        url: "/issue-associations/",
+        queryParams: { project: 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 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) {
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const { values } = separateFilesFromValues(payload.values);
+      const payloadsBatches = chunkArray(payload.payloads, batchSize);
+      const bulkAddPayloads = payloadsBatches.map((batch) => {
+        return {
+          submitted_at: submittedAt,
+          values,
+          field_values: batch.map((payload2) => {
+            const { values: values2 } = separateFilesFromValues(payload2.values);
+            return offline({
+              ...payload2,
+              values: values2
+            });
+          })
+        };
+      });
+      const promises = [];
+      for (const payload2 of bulkAddPayloads) {
+        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(addAssetTypeFieldValuesMany(results.flat()));
+      });
+      return 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) {
+      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 offlineAssetTypeFieldValuesAttachments = [];
+      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 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);
+      }
+      this.dispatch(addAssetTypeFieldValuesAttachments(offlineAssetTypeFieldValuesAttachments));
+      const promise = this.enqueueRequest({
+        description: "Add asset type field values attachments",
+        method: HttpMethod.POST,
+        url: "/asset-type-field-values-attachments/bulk/",
+        payload: {
+          submitted_at: submittedAt,
+          attachments: attachmentPayloads,
+          files: Object.values(filePayloads)
+        },
+        blockers: offlineAssetTypeFieldValuesAttachments.map((attachment) => attachment.field_values),
+        blocks: offlineAssetTypeFieldValuesAttachments.map((attachment) => attachment.offline_id)
+      });
+      promise.then(({ presigned_urls, attachments }) => {
+        this.processPresignedUrls(presigned_urls);
+        this.dispatch(updateAssetTypeFieldValuesAttachments(attachments));
+      }).catch((error) => {
+        this.dispatch(
+          deleteAssetTypeFieldValuesAttachments(
+            offlineAssetTypeFieldValuesAttachments.map((attachment) => attachment.offline_id)
+          )
+        );
+        throw error;
+      });
+      return [offlineAssetTypeFieldValuesAttachments, 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: "Gfet 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";
@@ -7332,6 +8060,10 @@ 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;
@@ -7347,7 +8079,9 @@ var __publicField = (obj, key, value) => {
   exports2.EmailDomainsService = EmailDomainsService;
   exports2.EmailVerificationService = EmailVerificationService;
   exports2.FileService = FileService;
+  exports2.FormRevisionAttachmentService = FormRevisionAttachmentService;
   exports2.FormService = FormService;
+  exports2.FormSubmissionAttachmentService = FormSubmissionAttachmentService;
   exports2.FormSubmissionService = FormSubmissionService;
   exports2.GREEN = GREEN;
   exports2.GeoImageService = GeoImageService;
@@ -7358,6 +8092,10 @@ 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;
@@ -7397,6 +8135,14 @@ 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;
@@ -7425,6 +8171,14 @@ 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;
@@ -7450,6 +8204,14 @@ 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;
@@ -7478,6 +8240,14 @@ 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;
@@ -7502,6 +8272,14 @@ 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;
@@ -7558,6 +8336,10 @@ 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;
@@ -7572,6 +8354,10 @@ 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;
@@ -7590,6 +8376,14 @@ 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;
@@ -7662,6 +8456,20 @@ 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.selectAssetTypes = selectAssetTypes;
   exports2.selectAssetTypesByIds = selectAssetTypesByIds;
@@ -7670,18 +8478,20 @@ 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;
@@ -7709,8 +8519,6 @@ 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;
@@ -7720,9 +8528,7 @@ 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;
@@ -7751,6 +8557,20 @@ 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.selectIssueTypes = selectIssueTypes;
   exports2.selectIssueTypesByIds = selectIssueTypesByIds;
@@ -7817,6 +8637,8 @@ 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;
@@ -7827,6 +8649,14 @@ 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;
@@ -7852,6 +8682,14 @@ 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;
@@ -7884,6 +8722,14 @@ 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;
@@ -7906,6 +8752,14 @@ 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;