@overmap-ai/core 1.0.53-attachment-creation-flows.1 → 1.0.53-component-asset-renames.0

package/dist/overmap-core.umd.cjs

@@ -668,15 +668,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$r = {
+  const initialState$s = {
     accessToken: "",
     refreshToken: "",
     isLoggedIn: false
   };
   const authSlice = toolkit.createSlice({
     name: "auth",
-    initialState: initialState$r,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
+    initialState: initialState$s,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$s)),
     reducers: {
       setTokens: (state, action) => {
         state.accessToken = action.payload.accessToken;
@@ -1374,7 +1374,7 @@ var __publicField = (obj, key, value) => {
     [mint.mint9]: "mint",
     [sky.sky9]: "sky"
   };
-  const ComponentStageColors = {
+  const AssetStageColors = {
     indigo: indigo.indigo9,
     red: red.red9,
     violet: violet.violet9,
@@ -1396,7 +1396,7 @@ var __publicField = (obj, key, value) => {
     return { backgroundColor, textColor };
   };
   function getStageColor(index2) {
-    return Object.values(ComponentStageColors)[index2 % Object.keys(ComponentStageColors).length];
+    return Object.values(AssetStageColors)[index2 % Object.keys(AssetStageColors).length];
   }
   const getLocalDateString = memoize((date) => {
     if (!date)
@@ -1420,7 +1420,7 @@ var __publicField = (obj, key, value) => {
       return getLocalDateString(date);
     return relative.format(days, "days");
   });
-  const initialState$q = {
+  const initialState$r = {
     categories: {},
     usedCategoryColors: [],
     categoryVisibility: {
@@ -1430,8 +1430,8 @@ var __publicField = (obj, key, value) => {
   };
   const categorySlice = toolkit.createSlice({
     name: "categories",
-    initialState: initialState$q,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
+    initialState: initialState$r,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$r)),
     reducers: {
       setCategories: (state, action) => {
         if (!Array.isArray(action.payload))
@@ -1615,167 +1615,274 @@ var __publicField = (obj, key, value) => {
       delete state.attachments[attachmentId];
     }
   }
+  const initialState$q = {
+    assetTypes: {},
+    hiddenAssetTypeIds: {},
+    attachments: {}
+  };
+  const assetTypeSlice = toolkit.createSlice({
+    name: "assetTypes",
+    initialState: initialState$q,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
+    reducers: {
+      addAssetType: (state, action) => {
+        state.assetTypes[action.payload.offline_id] = action.payload;
+      },
+      setAssetTypes: (state, action) => {
+        state.assetTypes = toOfflineIdRecord(action.payload);
+      },
+      toggleAssetTypeVisibility: (state, action) => {
+        state.hiddenAssetTypeIds[action.payload] = !state.hiddenAssetTypeIds[action.payload];
+      },
+      deleteAssetType: (state, action) => {
+        delete state.assetTypes[action.payload];
+      },
+      // Attachments
+      setAssetTypeAttachment: setAttachment,
+      setAssetTypeAttachments: setAttachments,
+      addAssetTypeAttachment: addAttachment,
+      addAssetTypeAttachments: addAttachments,
+      updateAssetTypeAttachment: updateAttachment,
+      updateAssetTypeAttachments: updateAttachments,
+      removeAssetTypeAttachment: removeAttachment,
+      removeAssetTypeAttachments: removeAttachments
+    }
+  });
+  const {
+    addAssetType,
+    setAssetTypes,
+    toggleAssetTypeVisibility,
+    deleteAssetType,
+    // Attachmet
+    setAssetTypeAttachment,
+    setAssetTypeAttachments,
+    addAssetTypeAttachment,
+    addAssetTypeAttachments,
+    updateAssetTypeAttachment,
+    updateAssetTypeAttachments,
+    removeAssetTypeAttachment,
+    removeAssetTypeAttachments
+  } = assetTypeSlice.actions;
+  const selectAssetTypesMapping = (state) => state.assetTypeReducer.assetTypes;
+  const selectAssetTypes = toolkit.createSelector(
+    [selectAssetTypesMapping],
+    (mapping) => Object.values(mapping)
+  );
+  const selectAssetType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAssetTypesMapping, (_state, assetTypeId) => assetTypeId],
+      (mapping, assetTypeId) => mapping[assetTypeId]
+    )
+  );
+  const selectNumberOfAssetTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAssetTypesMapping, (_state, args) => args],
+      (mapping, args) => {
+        var _a2;
+        const name = ((_a2 = args.name) == null ? void 0 : _a2.toLowerCase()) ?? null;
+        return Object.values(mapping).filter(
+          (assetType) => {
+            var _a3;
+            return (((_a3 = assetType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && assetType.offline_id !== args.assetTypeId;
+          }
+        ).length;
+      }
+    )
+  );
+  const selectAssetTypesByName = restructureCreateSelectorWithArgs(
+    toolkit.createSelector([selectAssetTypesMapping, (_state, name) => name], (mapping, name) => {
+      name = (name == null ? void 0 : name.toLowerCase()) ?? null;
+      return Object.values(mapping).filter((assetType) => {
+        var _a2;
+        return (((_a2 = assetType.name) == null ? void 0 : _a2.toLowerCase()) ?? null) === name;
+      });
+    })
+  );
+  const selectHiddenAssetTypeIds = (state) => state.assetTypeReducer.hiddenAssetTypeIds;
+  const selectAssetTypeAttachmentMapping = (state) => state.assetTypeReducer.attachments;
+  const selectAssetTypeAttachments = toolkit.createSelector(
+    [selectAssetTypeAttachmentMapping],
+    (mapping) => Object.values(mapping)
+  );
+  const selectAssetTypeAttachment = (attachmentId) => (state) => {
+    return state.assetTypeReducer.attachments[attachmentId];
+  };
+  const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+      (attachments, assetTypeId) => {
+        return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
+      }
+    )
+  );
+  const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+      (attachments, assetTypeId) => {
+        const attachmentsOfAssetType = attachments.filter(({ asset_type }) => asset_type === assetTypeId);
+        const fileAttachments = attachmentsOfAssetType.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => !file_type || !file_type.startsWith("image/")
+        );
+        const imageAttachments = attachmentsOfAssetType.filter(
+          // this null check here is necessary, there are cases where file_type is null or undefined
+          ({ file_type }) => file_type && file_type.startsWith("image/")
+        );
+        return { fileAttachments, imageAttachments };
+      }
+    )
+  );
+  const assetTypeReducer = assetTypeSlice.reducer;
   const initialState$p = {
-    components: {},
+    assets: {},
     attachments: {}
   };
-  const componentSlice = toolkit.createSlice({
-    name: "components",
+  const assetSlice = toolkit.createSlice({
+    name: "assets",
     initialState: initialState$p,
     extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$p)),
     reducers: {
-      addComponent: (state, action) => {
-        state.components[action.payload.offline_id] = action.payload;
-        prevComponents = null;
+      addAsset: (state, action) => {
+        state.assets[action.payload.offline_id] = action.payload;
+        prevAssets = null;
       },
-      addComponentsInBatches: (state, action) => {
-        Object.assign(state.components, toOfflineIdRecord(action.payload));
-        prevComponents = null;
+      addAssetsInBatches: (state, action) => {
+        Object.assign(state.assets, toOfflineIdRecord(action.payload));
+        prevAssets = null;
       },
-      setComponents: (state, action) => {
-        state.components = toOfflineIdRecord(action.payload);
-        prevComponents = null;
+      setAssets: (state, action) => {
+        state.assets = toOfflineIdRecord(action.payload);
+        prevAssets = null;
       },
-      updateComponent: (state, action) => {
-        if (action.payload.offline_id in state.components) {
-          state.components[action.payload.offline_id] = action.payload;
+      updateAsset: (state, action) => {
+        if (action.payload.offline_id in state.assets) {
+          state.assets[action.payload.offline_id] = action.payload;
         } else {
-          throw new Error(`Tried to update component with ID that doesn't exist: ${action.payload.offline_id}`);
+          throw new Error(`Tried to update asset with ID that doesn't exist: ${action.payload.offline_id}`);
         }
-        prevComponents = null;
+        prevAssets = null;
       },
-      removeComponent: (state, action) => {
-        if (action.payload in state.components) {
-          delete state.components[action.payload];
+      removeAsset: (state, action) => {
+        if (action.payload in state.assets) {
+          delete state.assets[action.payload];
         } else {
-          throw new Error(`Failed to remove component because ID doesn't exist: ${action.payload}`);
+          throw new Error(`Failed to remove asset because ID doesn't exist: ${action.payload}`);
         }
-        prevComponents = null;
+        prevAssets = null;
       },
-      removeAllComponentsOfType: (state, action) => {
+      removeAllAssetsOfType: (state, action) => {
         var _a2;
-        for (const componentId in state.components) {
-          if (((_a2 = state.components[componentId]) == null ? void 0 : _a2.component_type) === action.payload) {
-            delete state.components[componentId];
+        for (const componentId in state.assets) {
+          if (((_a2 = state.assets[componentId]) == null ? void 0 : _a2.asset_type) === action.payload) {
+            delete state.assets[componentId];
           }
         }
-        prevComponents = null;
+        prevAssets = null;
       },
       // Attachments
-      setComponentAttachment: setAttachment,
-      setComponentAttachments: setAttachments,
-      addComponentAttachment: addAttachment,
-      addComponentAttachments: addAttachments,
-      updateComponentAttachment: updateAttachment,
-      updateComponentAttachments: updateAttachments,
-      removeComponentAttachment: removeAttachment,
-      removeComponentAttachments: removeAttachments
+      setAssetAttachment: setAttachment,
+      setAssetAttachments: setAttachments,
+      addAssetAttachment: addAttachment,
+      addAssetAttachments: addAttachments,
+      updateAssetAttachment: updateAttachment,
+      updateAssetAttachments: updateAttachments,
+      removeAssetAttachment: removeAttachment,
+      removeAssetAttachments: removeAttachments
     }
   });
   const {
-    addComponent,
-    updateComponent,
-    removeComponent,
-    addComponentsInBatches,
-    setComponents,
-    removeAllComponentsOfType,
+    addAsset,
+    updateAsset,
+    removeAsset,
+    addAssetsInBatches,
+    setAssets,
+    removeAllAssetsOfType,
     // Attachments
-    setComponentAttachment,
-    setComponentAttachments,
-    addComponentAttachment,
-    addComponentAttachments,
-    updateComponentAttachment,
-    updateComponentAttachments,
-    removeComponentAttachment,
-    removeComponentAttachments
-  } = componentSlice.actions;
-  let prevComponents = null;
-  const selectComponents = (state) => {
-    if (!prevComponents) {
-      prevComponents = Object.values(state.componentReducer.components);
-    }
-    return prevComponents;
+    setAssetAttachment,
+    setAssetAttachments,
+    addAssetAttachment,
+    addAssetAttachments,
+    updateAssetAttachment,
+    updateAssetAttachments,
+    removeAssetAttachment,
+    removeAssetAttachments
+  } = assetSlice.actions;
+  let prevAssets = null;
+  const selectAssets = (state) => {
+    if (!prevAssets) {
+      prevAssets = Object.values(state.assetReducer.assets);
+    }
+    return prevAssets;
   };
-  const selectComponentsMapping = (state) => state.componentReducer.components;
-  const selectComponentsFromComponentType = (componentTypeId) => (state) => {
-    if (!componentTypeId)
-      return [];
-    const components = selectComponents(state);
-    return components.filter((component) => component.component_type === componentTypeId);
-  };
-  const selectComponent = (componentId) => (state) => {
-    return state.componentReducer.components[componentId];
-  };
-  const selectComponentTypeFromComponent = (componentTypeId) => (state) => {
-    return state.componentTypeReducer.componentTypes[componentTypeId];
+  const selectAssetsMapping = (state) => state.assetReducer.assets;
+  const selectAssetsOfAssetType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector([selectAssets, (_state, assetTypeId) => assetTypeId], (components, assetTypeId) => {
+      return components.filter((asset) => asset.asset_type === assetTypeId);
+    })
+  );
+  const selectAsset = (assetId) => (state) => {
+    return state.assetReducer.assets[assetId];
   };
-  const selectComponentTypeFromComponents = (state) => {
-    const ret = {};
-    const componentTypes = state.componentTypeReducer.componentTypes;
-    const components = state.componentReducer.components;
-    for (const [componentId, component] of Object.entries(components)) {
-      const componentType = componentTypes[component.component_type];
-      if (!componentType) {
-        console.error(
-          `Component type with ID ${component.component_type} not found.
-				Expected all referenced component types to be populated.
+  const selectAssetToAssetTypeMapping = toolkit.createSelector(
+    [selectAssets, selectAssetTypesMapping],
+    (assets, assetTypeMapping) => {
+      const ret = {};
+      for (const asset of assets) {
+        const assetType = assetTypeMapping[asset.asset_type];
+        if (!assetType) {
+          console.error(
+            `Asset type with ID ${asset.asset_type} not found.
+				Expected all referenced asset types to be populated.
 				Returning empty object to avoid fatal errors.`
-        );
-        return {};
+          );
+          return {};
+        }
+        ret[asset.offline_id] = assetType;
       }
-      ret[componentId] = componentType;
+      return ret;
     }
-    return ret;
-  };
-  const selectComponentsByType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectComponents, (_state, componentTypeId) => componentTypeId],
-      (components, componentTypeId) => {
-        return components.filter((component) => component.component_type === componentTypeId);
-      }
-    )
   );
-  const selectNumberOfComponentsOfComponentType = (componentTypeId) => (state) => {
+  const selectNumberOfAssetsOfAssetType = (assetTypeId) => (state) => {
     var _a2;
-    if (!componentTypeId)
+    if (!assetTypeId)
       return 0;
-    return (_a2 = selectComponentsByType(componentTypeId)(state)) == null ? void 0 : _a2.length;
+    return (_a2 = selectAssetsOfAssetType(assetTypeId)(state)) == null ? void 0 : _a2.length;
   };
-  const selectComponentTypesFromIds = (componentTypeIds) => (state) => {
-    return componentTypeIds.reduce((acc, componentTypeId) => {
-      const componentType = state.componentTypeReducer.componentTypes[componentTypeId];
-      if (componentType) {
-        acc.push(componentType);
+  const selectAssetTypesFromIds = (assetTypeIds) => (state) => {
+    return assetTypeIds.reduce((acc, assetTypeId) => {
+      const assetType = state.assetTypeReducer.assetTypes[assetTypeId];
+      if (assetType) {
+        acc.push(assetType);
       }
       return acc;
     }, []);
   };
-  const selectComponentAttachmentMapping = (state) => state.componentReducer.attachments;
-  const selectAllComponentAttachments = toolkit.createSelector(
-    [selectComponentAttachmentMapping],
+  const selectAssetAttachmentMapping = (state) => state.assetReducer.attachments;
+  const selectAssetAttachments = toolkit.createSelector(
+    [selectAssetAttachmentMapping],
     (mapping) => Object.values(mapping)
   );
-  const selectComponentAttachment = (attachmentId) => (state) => {
-    return state.componentReducer.attachments[attachmentId];
+  const selectAssetAttachment = (attachmentId) => (state) => {
+    return state.assetReducer.attachments[attachmentId];
   };
-  const selectAttachmentsOfComponent = restructureCreateSelectorWithArgs(
+  const selectAttachmentsOfAsset = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
-      [selectAllComponentAttachments, (_state, componentId) => componentId],
-      (attachments, componentId) => {
-        return attachments.filter(({ component }) => componentId === component);
+      [selectAssetAttachments, (_state, assetId) => assetId],
+      (attachments, assetId) => {
+        return attachments.filter(({ asset }) => assetId === asset);
       }
     )
   );
-  const selectAttachmentsOfComponentByType = restructureCreateSelectorWithArgs(
+  const selectAttachmentsOfAssetsByType = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
-      [selectAllComponentAttachments, (_state, componentId) => componentId],
-      (attachments, componentId) => {
-        const attachmentsOfComponent = attachments.filter(({ component }) => componentId === component);
-        const fileAttachments = attachmentsOfComponent.filter(
+      [selectAssetAttachments, (_state, assetId) => assetId],
+      (attachments, assetId) => {
+        const attachmentsOfAsset = attachments.filter(({ asset }) => assetId === asset);
+        const fileAttachments = attachmentsOfAsset.filter(
           // this null check here is necessary, there are cases where file_type is null or undefined
           ({ file_type }) => !file_type || !file_type.startsWith("image/")
         );
-        const imageAttachments = attachmentsOfComponent.filter(
+        const imageAttachments = attachmentsOfAsset.filter(
           // this null check here is necessary, there are cases where file_type is null or undefined
           ({ file_type }) => file_type && file_type.startsWith("image/")
         );
@@ -1783,69 +1890,67 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const componentReducer = componentSlice.reducer;
+  const assetReducer = assetSlice.reducer;
   const initialState$o = {
-    completionsByComponentId: {}
+    completionsByAssetId: {}
   };
-  const componentStageCompletionSlice = toolkit.createSlice({
-    name: "componentStageCompletions",
+  const assetStageCompletionSlice = toolkit.createSlice({
+    name: "assetStageCompletions",
     initialState: initialState$o,
     extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$o)),
     reducers: {
       addStageCompletion: (state, action) => {
-        let stageToCompletionDateMapping = state.completionsByComponentId[action.payload.component];
+        let stageToCompletionDateMapping = state.completionsByAssetId[action.payload.asset];
         if (!stageToCompletionDateMapping) {
           stageToCompletionDateMapping = {};
-          state.completionsByComponentId[action.payload.component] = stageToCompletionDateMapping;
+          state.completionsByAssetId[action.payload.asset] = stageToCompletionDateMapping;
         }
         stageToCompletionDateMapping[action.payload.stage] = (/* @__PURE__ */ new Date()).toISOString();
       },
       addStageCompletions: (state, action) => {
-        for (const [componentId, stageIdToCompletionDateMapping] of Object.entries(action.payload)) {
+        for (const [assetId, stageIdToCompletionDateMapping] of Object.entries(action.payload)) {
           if (Object.keys(stageIdToCompletionDateMapping).length === 0)
-            throw new Error(
-              `Encountered empty stageIdToCompletionDateMapping argument for component ${componentId}`
-            );
-          let thisComponentCompletions = state.completionsByComponentId[componentId];
-          if (thisComponentCompletions === void 0) {
-            thisComponentCompletions = {};
+            throw new Error(`Encountered empty stageIdToCompletionDateMapping argument for asset ${assetId}`);
+          let thisAssetCompletions = state.completionsByAssetId[assetId];
+          if (thisAssetCompletions === void 0) {
+            thisAssetCompletions = {};
           }
           for (const [stageId, completionDate] of Object.entries(stageIdToCompletionDateMapping)) {
-            thisComponentCompletions[stageId] = completionDate;
+            thisAssetCompletions[stageId] = completionDate;
           }
-          state.completionsByComponentId[componentId] = thisComponentCompletions;
+          state.completionsByAssetId[assetId] = thisAssetCompletions;
         }
       },
       removeStageCompletions: (state, action) => {
         for (const completion of action.payload) {
-          const thisComponentCompletions = state.completionsByComponentId[completion.component];
-          if (!thisComponentCompletions || !(completion.stage in thisComponentCompletions)) {
+          const thisAssetCompletions = state.completionsByAssetId[completion.asset];
+          if (!thisAssetCompletions || !(completion.stage in thisAssetCompletions)) {
             console.warn(
               "Skipping removal of uncompleted stage. This message indicates completion objects are created unnecessarily."
             );
             continue;
           }
-          delete thisComponentCompletions[completion.stage];
+          delete thisAssetCompletions[completion.stage];
         }
       },
       setStageCompletions: (state, action) => {
-        state.completionsByComponentId = action.payload;
+        state.completionsByAssetId = action.payload;
       }
     }
   });
-  const { addStageCompletion, addStageCompletions, removeStageCompletions, setStageCompletions } = componentStageCompletionSlice.actions;
+  const { addStageCompletion, addStageCompletions, removeStageCompletions, setStageCompletions } = assetStageCompletionSlice.actions;
   const selectCompletedStages = (state) => {
-    return state.componentStageCompletionReducer.completionsByComponentId;
+    return state.assetStageCompletionReducer.completionsByAssetId;
   };
-  const selectCompletedStageIdsForComponent = (component) => (state) => {
-    return Object.keys(state.componentStageCompletionReducer.completionsByComponentId[component.offline_id] ?? {});
+  const selectCompletedStageIdsForAsset = (asset) => (state) => {
+    return Object.keys(state.assetStageCompletionReducer.completionsByAssetId[asset.offline_id] ?? {});
   };
-  const componentStageCompletionReducer = componentStageCompletionSlice.reducer;
+  const assetStageCompletionReducer = assetStageCompletionSlice.reducer;
   const initialState$n = {
     stages: {}
   };
-  const componentStageSlice = toolkit.createSlice({
-    name: "componentStages",
+  const assetStageSlice = toolkit.createSlice({
+    name: "assetStages",
     initialState: initialState$n,
     extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
     reducers: {
@@ -1880,60 +1985,48 @@ var __publicField = (obj, key, value) => {
       }
     }
   });
-  const selectStageMapping = (state) => state.componentStageReducer.stages;
+  const selectStageMapping = (state) => state.assetStageReducer.stages;
   const selectStage = restructureCreateSelectorWithArgs(
     toolkit.createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
       return stageMapping[stageId];
     })
   );
-  const selectStages = toolkit.createSelector(
-    [selectStageMapping],
-    (stageMapping) => {
-      return Object.values(stageMapping);
-    }
-  );
-  const selectStagesFromComponentTypeIds = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectStages, (_state, componentTypeIds) => componentTypeIds],
-      (stages, componentTypeIds) => {
-        const componentTypeIdsSet = new Set(componentTypeIds);
-        const ret = {};
-        for (const stage of stages) {
-          if (componentTypeIdsSet.has(stage.component_type)) {
-            if (!ret[stage.component_type]) {
-              ret[stage.component_type] = [];
-            }
-            ret[stage.component_type].push(stage);
+  const selectStages = toolkit.createSelector([selectStageMapping], (stageMapping) => {
+    return Object.values(stageMapping);
+  });
+  const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
+    toolkit.createSelector([selectStages, (_state, assetTypeIds) => assetTypeIds], (stages, assetTypeIds) => {
+      const assetTypeIdsSet = new Set(assetTypeIds);
+      const ret = {};
+      for (const stage of stages) {
+        if (assetTypeIdsSet.has(stage.asset_type)) {
+          if (!ret[stage.asset_type]) {
+            ret[stage.asset_type] = [];
           }
+          ret[stage.asset_type].push(stage);
         }
-        for (const key in ret) {
-          ret[key] = ret[key].sort((a, b) => a.priority - b.priority);
-        }
-        return ret;
       }
-    )
+      for (const key in ret) {
+        ret[key] = ret[key].sort((a, b) => a.priority - b.priority);
+      }
+      return ret;
+    })
   );
-  const selectComponentTypeStagesMapping = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectStageMapping, (_state, componentTypeId) => componentTypeId],
-      (stagesMapping, componentTypeId) => {
-        const componentTypeStagesMapping = {};
-        for (const [stageId, stage] of Object.entries(stagesMapping)) {
-          if (stage.component_type === componentTypeId) {
-            componentTypeStagesMapping[stageId] = stage;
-          }
+  const selectAssetTypeStagesMapping = restructureCreateSelectorWithArgs(
+    toolkit.createSelector([selectStageMapping, (_state, assetTypeId) => assetTypeId], (stagesMapping, assetTypeId) => {
+      const assetTypeStagesMapping = {};
+      for (const [stageId, stage] of Object.entries(stagesMapping)) {
+        if (stage.asset_type === assetTypeId) {
+          assetTypeStagesMapping[stageId] = stage;
         }
-        return componentTypeStagesMapping;
       }
-    )
+      return assetTypeStagesMapping;
+    })
   );
-  const selectStagesFromComponentType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectStages, (_state, componentTypeId) => componentTypeId],
-      (stages, componentTypeId) => {
-        return stages.filter((stage) => stage.component_type === componentTypeId).sort((a, b) => a.priority - b.priority);
-      }
-    )
+  const selectStagesOfAssetType = restructureCreateSelectorWithArgs(
+    toolkit.createSelector([selectStages, (_state, assetTypeId) => assetTypeId], (stages, assetTypeId) => {
+      return stages.filter((stage) => stage.asset_type === assetTypeId).sort((a, b) => a.priority - b.priority);
+    })
   );
   const selectStagesFromStageIds = restructureCreateSelectorWithArgs(
     toolkit.createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
@@ -1955,140 +2048,15 @@ var __publicField = (obj, key, value) => {
       return ret;
     })
   );
-  const { addStages, updateStages, removeStages, linkStageToForm, unlinkStageToForm } = componentStageSlice.actions;
-  const componentStageReducer = componentStageSlice.reducer;
+  const { addStages, updateStages, removeStages, linkStageToForm, unlinkStageToForm } = assetStageSlice.actions;
+  const assetStageReducer = assetStageSlice.reducer;
   const initialState$m = {
-    componentTypes: {},
-    hiddenComponentTypeIds: {},
-    attachments: {}
-  };
-  const componentTypeSlice = toolkit.createSlice({
-    name: "componentTypes",
-    initialState: initialState$m,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$m)),
-    reducers: {
-      addComponentType: (state, action) => {
-        state.componentTypes[action.payload.offline_id] = action.payload;
-      },
-      setComponentTypes: (state, action) => {
-        state.componentTypes = toOfflineIdRecord(action.payload);
-      },
-      toggleComponentTypeVisibility: (state, action) => {
-        state.hiddenComponentTypeIds[action.payload] = !state.hiddenComponentTypeIds[action.payload];
-      },
-      deleteComponentType: (state, action) => {
-        delete state.componentTypes[action.payload];
-      },
-      // Attachments
-      setComponentTypeAttachment: setAttachment,
-      setComponentTypeAttachments: setAttachments,
-      addComponentTypeAttachment: addAttachment,
-      addComponentTypeAttachments: addAttachments,
-      updateComponentTypeAttachment: updateAttachment,
-      updateComponentTypeAttachments: updateAttachments,
-      removeComponentTypeAttachment: removeAttachment,
-      removeComponentTypeAttachments: removeAttachments
-    }
-  });
-  const {
-    addComponentType,
-    setComponentTypes,
-    toggleComponentTypeVisibility,
-    deleteComponentType,
-    // Attachmet
-    setComponentTypeAttachment,
-    setComponentTypeAttachments,
-    addComponentTypeAttachment,
-    addComponentTypeAttachments,
-    updateComponentTypeAttachment,
-    updateComponentTypeAttachments,
-    removeComponentTypeAttachment,
-    removeComponentTypeAttachments
-  } = componentTypeSlice.actions;
-  const selectComponentTypesMapping = (state) => state.componentTypeReducer.componentTypes;
-  const selectComponentTypes = toolkit.createSelector(
-    [selectComponentTypesMapping],
-    (mapping) => Object.values(mapping)
-  );
-  const selectComponentType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector([selectComponentTypesMapping, (_state, id) => id], (mapping, id) => mapping[id])
-  );
-  const selectNumberOfComponentTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [
-        selectComponentTypesMapping,
-        (_state, args) => args
-      ],
-      (mapping, args) => {
-        var _a2;
-        const name = ((_a2 = args.name) == null ? void 0 : _a2.toLowerCase()) ?? null;
-        return Object.values(mapping).filter(
-          (componentType) => {
-            var _a3;
-            return (((_a3 = componentType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && componentType.offline_id !== args.componentTypeId;
-          }
-        ).length;
-      }
-    )
-  );
-  const selectComponentTypesByName = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectComponentTypesMapping, (_state, name) => name],
-      (mapping, name) => {
-        name = (name == null ? void 0 : name.toLowerCase()) ?? null;
-        return Object.values(mapping).filter(
-          (componentType) => {
-            var _a2;
-            return (((_a2 = componentType.name) == null ? void 0 : _a2.toLowerCase()) ?? null) === name;
-          }
-        );
-      }
-    )
-  );
-  const selectHiddenComponentTypeIds = (state) => state.componentTypeReducer.hiddenComponentTypeIds;
-  const selectComponentTypeAttachmentMapping = (state) => state.componentTypeReducer.attachments;
-  const selectAllComponentTypeAttachments = toolkit.createSelector(
-    [selectComponentTypeAttachmentMapping],
-    (mapping) => Object.values(mapping)
-  );
-  const selectComponentTypeAttachment = (attachmentId) => (state) => {
-    return state.componentTypeReducer.attachments[attachmentId];
-  };
-  const selectAttachmentsOfComponentType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAllComponentTypeAttachments, (_state, componentTypeId) => componentTypeId],
-      (attachments, componentTypeId) => {
-        return attachments.filter(({ component_type }) => componentTypeId === component_type);
-      }
-    )
-  );
-  const selectAttachmentsOfComponentTypeByType = restructureCreateSelectorWithArgs(
-    toolkit.createSelector(
-      [selectAllComponentTypeAttachments, (_state, componentTypeId) => componentTypeId],
-      (attachments, componentTypeId) => {
-        const attachmentsOfComponent = attachments.filter(
-          ({ component_type }) => component_type === componentTypeId
-        );
-        const fileAttachments = attachmentsOfComponent.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => !file_type || !file_type.startsWith("image/")
-        );
-        const imageAttachments = attachmentsOfComponent.filter(
-          // this null check here is necessary, there are cases where file_type is null or undefined
-          ({ file_type }) => file_type && file_type.startsWith("image/")
-        );
-        return { fileAttachments, imageAttachments };
-      }
-    )
-  );
-  const componentTypeReducer = componentTypeSlice.reducer;
-  const initialState$l = {
     workspaces: {},
     activeWorkspaceId: null
   };
   const workspaceSlice = toolkit.createSlice({
     name: "workspace",
-    initialState: initialState$l,
+    initialState: initialState$m,
     // The `reducers` field lets us define reducers and generate associated actions
     reducers: {
       setWorkspaces: (state, action) => {
@@ -2145,7 +2113,7 @@ var __publicField = (obj, key, value) => {
   );
   const workspaceReducer = workspaceSlice.reducer;
   const maxRecentIssues = 10;
-  const initialState$k = {
+  const initialState$l = {
     issues: {},
     attachments: {},
     comments: {},
@@ -2157,9 +2125,9 @@ var __publicField = (obj, key, value) => {
   };
   const issueSlice = toolkit.createSlice({
     name: "issues",
-    initialState: initialState$k,
+    initialState: initialState$l,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$k);
+      Object.assign(state, initialState$l);
     }),
     reducers: {
       setIssues: (state, action) => {
@@ -2592,14 +2560,14 @@ var __publicField = (obj, key, value) => {
     }
   );
   const issueReducer = issueSlice.reducer;
-  const initialState$j = {
+  const initialState$k = {
     issueTypes: {}
   };
   const issueTypeSlice = toolkit.createSlice({
     name: "issueTypes",
-    initialState: initialState$j,
+    initialState: initialState$k,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$j);
+      Object.assign(state, initialState$k);
     }),
     reducers: {
       setIssueTypes: (state, action) => {
@@ -2666,15 +2634,15 @@ var __publicField = (obj, key, value) => {
     return ((_a2 = selectIssuesOfIssueType(issueTypeId)(state)) == null ? void 0 : _a2.length) ?? 0;
   };
   const issueTypeReducer = issueTypeSlice.reducer;
-  const initialState$i = {
+  const initialState$j = {
     s3Urls: {}
   };
   const msPerHour = 1e3 * 60 * 60;
   const msPerWeek = msPerHour * 24 * 7;
   const fileSlice = toolkit.createSlice({
     name: "file",
-    initialState: initialState$i,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
+    initialState: initialState$j,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$j)),
     reducers: {
       setUploadUrl: (state, action) => {
         const { url, fields, sha1 } = action.payload;
@@ -2701,7 +2669,7 @@ var __publicField = (obj, key, value) => {
     return url;
   };
   const fileReducer = fileSlice.reducer;
-  const initialState$h = {
+  const initialState$i = {
     // TODO: Change first MapStyle.SATELLITE to MaptStyle.None when project creation map is fixed
     mapStyle: MapStyle.SATELLITE,
     showTooltips: false,
@@ -2709,8 +2677,8 @@ var __publicField = (obj, key, value) => {
   };
   const mapSlice = toolkit.createSlice({
     name: "map",
-    initialState: initialState$h,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$h)),
+    initialState: initialState$i,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$i)),
     reducers: {
       setMapStyle: (state, action) => {
         state.mapStyle = action.payload;
@@ -2740,8 +2708,8 @@ var __publicField = (obj, key, value) => {
   })(OrganizationAccessLevel || {});
   var AttachmentModel = /* @__PURE__ */ ((AttachmentModel2) => {
     AttachmentModel2["Issue"] = "issue";
-    AttachmentModel2["Component"] = "component";
-    AttachmentModel2["ComponentType"] = "component_type";
+    AttachmentModel2["Asset"] = "asset";
+    AttachmentModel2["AssetType"] = "asset_type";
     AttachmentModel2["Project"] = "project";
     AttachmentModel2["Document"] = "document";
     return AttachmentModel2;
@@ -2787,7 +2755,7 @@ var __publicField = (obj, key, value) => {
     LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
     return LicenseStatus2;
   })(LicenseStatus || {});
-  const initialState$g = {
+  const initialState$h = {
     users: {},
     currentUser: {
       id: 0,
@@ -2798,8 +2766,8 @@ var __publicField = (obj, key, value) => {
   };
   const userSlice = toolkit.createSlice({
     name: "users",
-    initialState: initialState$g,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
+    initialState: initialState$h,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$h)),
     reducers: {
       setUsers: (state, action) => {
         const usersMapping = {};
@@ -2861,13 +2829,13 @@ var __publicField = (obj, key, value) => {
   const selectUsersAsMapping = (state) => state.userReducer.users;
   const selectFavouriteProjects = (state) => state.userReducer.currentUser.profile.favourite_project_ids;
   const userReducer = userSlice.reducer;
-  const initialState$f = {
+  const initialState$g = {
     organizationAccesses: {}
   };
   const organizationAccessSlice = toolkit.createSlice({
     name: "organizationAccess",
-    initialState: initialState$f,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
+    initialState: initialState$g,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$g)),
     reducers: {
       setOrganizationAccesses: (state, action) => {
         if (!Array.isArray(action.payload))
@@ -2930,13 +2898,13 @@ var __publicField = (obj, key, value) => {
     return organizationAccesses;
   };
   const organizationAccessReducer = organizationAccessSlice.reducer;
-  const initialState$e = {
+  const initialState$f = {
     licenses: {}
   };
   const licenseSlice = toolkit.createSlice({
     name: "license",
-    initialState: initialState$e,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
+    initialState: initialState$f,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$f)),
     reducers: {
       setLicenses: (state, action) => {
         if (!Array.isArray(action.payload))
@@ -2981,13 +2949,13 @@ var __publicField = (obj, key, value) => {
     (licenses) => Object.values(licenses).filter((license) => license.project).reduce((accum, license) => ({ ...accum, [license.project]: license }), {})
   );
   const licenseReducer = licenseSlice.reducer;
-  const initialState$d = {
+  const initialState$e = {
     projectAccesses: {}
   };
   const projectAccessSlice = toolkit.createSlice({
     name: "projectAccess",
-    initialState: initialState$d,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$d)),
+    initialState: initialState$e,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$e)),
     reducers: {
       setProjectAccesses: (state, action) => {
         if (!Array.isArray(action.payload))
@@ -3055,7 +3023,7 @@ var __publicField = (obj, key, value) => {
     return projectAccesses;
   };
   const projectAccessReducer = projectAccessSlice.reducer;
-  const initialState$c = {
+  const initialState$d = {
     projects: {},
     activeProjectId: null,
     recentProjectIds: [],
@@ -3065,7 +3033,7 @@ var __publicField = (obj, key, value) => {
   };
   const projectSlice = toolkit.createSlice({
     name: "projects",
-    initialState: initialState$c,
+    initialState: initialState$d,
     reducers: {
       setProjects: (state, action) => {
         const projectsMap = {};
@@ -3259,14 +3227,14 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const initialState$b = {
+  const initialState$c = {
     organizations: {},
     activeOrganizationId: null
   };
   const organizationSlice = toolkit.createSlice({
     name: "organizations",
-    initialState: initialState$b,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
+    initialState: initialState$c,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$c)),
     reducers: {
       setOrganizations: (state, action) => {
         for (const org of action.payload) {
@@ -3385,14 +3353,14 @@ var __publicField = (obj, key, value) => {
       }
     };
   };
-  const initialState$a = {
+  const initialState$b = {
     deletedRequests: [],
     latestRetryTime: 0
   };
   const outboxSlice = toolkit.createSlice({
     name: "outbox",
-    initialState: initialState$a,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$a)),
+    initialState: initialState$b,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$b)),
     reducers: {
       // 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
@@ -3424,7 +3392,7 @@ var __publicField = (obj, key, value) => {
   const selectLatestRetryTime = (state) => state.outboxReducer.latestRetryTime;
   const { enqueueRequest, markForDeletion, markAsDeleted, _setLatestRetryTime } = outboxSlice.actions;
   const outboxReducer = outboxSlice.reducer;
-  const initialState$9 = {
+  const initialState$a = {
     projectFiles: {},
     activeProjectFileId: null,
     isImportingProjectFile: false,
@@ -3432,8 +3400,8 @@ var __publicField = (obj, key, value) => {
   };
   const projectFileSlice = toolkit.createSlice({
     name: "projectFiles",
-    initialState: initialState$9,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$9)),
+    initialState: initialState$a,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$a)),
     reducers: {
       addOrReplaceProjectFiles: (state, action) => {
         for (let fileObj of action.payload) {
@@ -3534,12 +3502,12 @@ var __publicField = (obj, key, value) => {
   const selectActiveProjectFileId = (state) => state.projectFileReducer.activeProjectFileId;
   const selectIsImportingProjectFile = (state) => state.projectFileReducer.isImportingProjectFile;
   const projectFileReducer = projectFileSlice.reducer;
-  const initialState$8 = {
+  const initialState$9 = {
     isRehydrated: false
   };
   const rehydratedSlice = toolkit.createSlice({
     name: "rehydrated",
-    initialState: initialState$8,
+    initialState: initialState$9,
     // The `reducers` field lets us define reducers and generate associated actions
     reducers: {
       setRehydrated: (state, action) => {
@@ -3549,11 +3517,12 @@ var __publicField = (obj, key, value) => {
   });
   const selectRehydrated = (state) => state.rehydratedReducer.isRehydrated;
   const rehydratedReducer = rehydratedSlice.reducer;
-  const initialState$7 = {
+  const initialState$8 = {
     useIssueTemplate: false,
     placementMode: false,
     enableClustering: false,
     svgLayout: false,
+    // TODO: this is no longer used
     expandedSections: {
       Issues: true,
       "Map Layers": false,
@@ -3566,8 +3535,8 @@ var __publicField = (obj, key, value) => {
   };
   const settingSlice = toolkit.createSlice({
     name: "settings",
-    initialState: initialState$7,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
+    initialState: initialState$8,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$8)),
     reducers: {
       setEnableDuplicateIssues: (state, action) => {
         state.useIssueTemplate = action.payload;
@@ -3626,14 +3595,14 @@ var __publicField = (obj, key, value) => {
       return revisionA < revisionB ? -1 : 1;
     }
   };
-  const initialState$6 = {
+  const initialState$7 = {
     formRevisions: {},
     attachments: {}
   };
   const formRevisionsSlice = toolkit.createSlice({
     name: "formRevisions",
-    initialState: initialState$6,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
+    initialState: initialState$7,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$7)),
     reducers: {
       // revision related actions
       setFormRevision: (state, action) => {
@@ -3764,27 +3733,27 @@ var __publicField = (obj, key, value) => {
       });
     })
   );
-  const selectLatestFormRevisionsOfComponentTypes = restructureCreateSelectorWithArgs(
+  const selectLatestFormRevisionsOfAssetTypes = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
       [
         (state) => state.formReducer.forms,
         selectFormRevisionMapping,
-        (_state, componentTypeIds) => componentTypeIds
+        (_state, assetTypeIds) => assetTypeIds
       ],
-      (userForms, revisions, componentTypeIds) => {
-        const componentTypeIdsSet = new Set(componentTypeIds);
-        const formsOfComponentTypes = {};
+      (userForms, revisions, assetTypeIds) => {
+        const assetTypeIdsSet = new Set(assetTypeIds);
+        const formsOfAssetTypes = {};
         const ret = {};
         for (const form of Object.values(userForms)) {
-          if (form.component_type && componentTypeIdsSet.has(form.component_type)) {
-            formsOfComponentTypes[form.offline_id] = form;
+          if (form.asset_type && assetTypeIdsSet.has(form.asset_type)) {
+            formsOfAssetTypes[form.offline_id] = form;
           }
         }
         for (const revision of Object.values(revisions)) {
-          const form = formsOfComponentTypes[revision.form];
-          if (!form || !form.component_type || ret[form.component_type] && formRevisionSortFn(ret[form.component_type], revision) > 0)
+          const form = formsOfAssetTypes[revision.form];
+          if (!form || !form.asset_type || ret[form.asset_type] && formRevisionSortFn(ret[form.asset_type], revision) > 0)
             continue;
-          ret[form.component_type] = revision;
+          ret[form.asset_type] = revision;
         }
         return ret;
       }
@@ -3813,13 +3782,13 @@ var __publicField = (obj, key, value) => {
     )
   );
   const formRevisionReducer = formRevisionsSlice.reducer;
-  const initialState$5 = {
+  const initialState$6 = {
     forms: {}
   };
   const formSlice = toolkit.createSlice({
     name: "forms",
-    initialState: initialState$5,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
+    initialState: initialState$6,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$6)),
     reducers: {
       setForms: (state, action) => {
         state.forms = {};
@@ -3901,11 +3870,11 @@ var __publicField = (obj, key, value) => {
   const selectFormMapping = (state) => {
     return state.formReducer.forms;
   };
-  const selectFormOfComponentType = restructureCreateSelectorWithArgs(
+  const selectFormOfAssetType = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
-      [selectFormMapping, (_state, componentTypeId) => componentTypeId],
-      (userForms, componentTypeId) => {
-        return Object.values(userForms).find((userForm) => userForm.component_type === componentTypeId);
+      [selectFormMapping, (_state, assetTypeId) => assetTypeId],
+      (userForms, assetTypeId) => {
+        return Object.values(userForms).find((userForm) => userForm.asset_type === assetTypeId);
       }
     )
   );
@@ -3921,17 +3890,17 @@ var __publicField = (obj, key, value) => {
     return Object.keys(userForms).length;
   });
   const selectGeneralFormCount = toolkit.createSelector([selectFormMapping], (userForms) => {
-    return Object.values(userForms).filter((form) => !form.component_type).length;
+    return Object.values(userForms).filter((form) => !form.asset_type).length;
   });
   const formReducer = formSlice.reducer;
-  const initialState$4 = {
+  const initialState$5 = {
     formSubmissions: {},
     attachments: {}
   };
   const formSubmissionSlice = toolkit.createSlice({
     name: "formSubmissions",
-    initialState: initialState$4,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$4)),
+    initialState: initialState$5,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$5)),
     reducers: {
       setFormSubmission: (state, action) => {
         state.formSubmissions[action.payload.offline_id] = action.payload;
@@ -4129,31 +4098,31 @@ var __publicField = (obj, key, value) => {
       }
     )
   );
-  const selectFormSubmissionsOfComponent = restructureCreateSelectorWithArgs(
+  const selectFormSubmissionsOfAsset = restructureCreateSelectorWithArgs(
     toolkit.createSelector(
-      [selectFormSubmissions, (_state, componentId) => componentId],
-      (submissions, componentId) => {
+      [selectFormSubmissions, (_state, assetId) => assetId],
+      (submissions, assetId) => {
         return submissions.filter((submission) => {
-          return submission.component === componentId;
+          return submission.asset === assetId;
         });
       }
     )
   );
-  const selectFormSubmissionsByComponents = toolkit.createSelector(
-    [selectFormSubmissionsMapping, selectComponentsMapping],
-    (submissions, components) => {
+  const selectFormSubmissionsByAssets = toolkit.createSelector(
+    [selectFormSubmissionsMapping, selectAssetsMapping],
+    (submissions, assets) => {
       var _a2;
-      const componentSubmissionMapping = {};
-      for (const componentId in components) {
-        componentSubmissionMapping[componentId] = [];
+      const assetSubmissionMapping = {};
+      for (const assetId in assets) {
+        assetSubmissionMapping[assetId] = [];
       }
       for (const submissionId in submissions) {
         const submission = submissions[submissionId];
-        if (submission.component) {
-          (_a2 = componentSubmissionMapping[submission.component]) == null ? void 0 : _a2.push(submission);
+        if (submission.asset) {
+          (_a2 = assetSubmissionMapping[submission.asset]) == null ? void 0 : _a2.push(submission);
         }
       }
-      return componentSubmissionMapping;
+      return assetSubmissionMapping;
     }
   );
   const selectFormSubmissionAttachmentsMapping = (state) => {
@@ -4168,12 +4137,12 @@ var __publicField = (obj, key, value) => {
     )
   );
   const formSubmissionReducer = formSubmissionSlice.reducer;
-  const initialState$3 = {
+  const initialState$4 = {
     emailDomains: {}
   };
   const emailDomainsSlice = toolkit.createSlice({
     name: "emailDomains",
-    initialState: initialState$3,
+    initialState: initialState$4,
     reducers: {
       setEmailDomains: (state, action) => {
         const emailDomains = {};
@@ -4200,15 +4169,15 @@ var __publicField = (obj, key, value) => {
     (ed1, ed2) => ed1.domain.localeCompare(ed2.domain)
   );
   const emailDomainsReducer = emailDomainsSlice.reducer;
-  const initialState$2 = {
+  const initialState$3 = {
     documents: {},
     attachments: {}
   };
   const documentSlice = toolkit.createSlice({
     name: "documents",
-    initialState: initialState$2,
+    initialState: initialState$3,
     extraReducers: (builder) => builder.addCase("RESET", (state) => {
-      Object.assign(state, initialState$2);
+      Object.assign(state, initialState$3);
     }),
     reducers: {
       setDocuments: (state, action) => {
@@ -4439,13 +4408,13 @@ var __publicField = (obj, key, value) => {
     )
   );
   const documentsReducer = documentSlice.reducer;
-  const initialState$1 = {
+  const initialState$2 = {
     teams: {}
   };
   const teamSlice = toolkit.createSlice({
     name: "teams",
-    initialState: initialState$1,
-    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$1)),
+    initialState: initialState$2,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$2)),
     reducers: {
       setTeam: (state, action) => {
         state.teams[action.payload.offline_id] = action.payload;
@@ -4495,6 +4464,54 @@ var __publicField = (obj, key, value) => {
     })
   );
   const teamReducer = teamSlice.reducer;
+  const initialState$1 = {
+    conversations: {}
+  };
+  const agentsSlice = toolkit.createSlice({
+    name: "agents",
+    initialState: initialState$1,
+    extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$1)),
+    reducers: {
+      setConversations: (state, action) => {
+        state.conversations = {};
+        for (const conversation of action.payload) {
+          state.conversations[conversation.offline_id] = conversation;
+        }
+      },
+      addConversation: (state, action) => {
+        if (action.payload.offline_id in state.conversations) {
+          throw new Error("Conversation already exists in history");
+        }
+        state.conversations[action.payload.offline_id] = action.payload;
+      },
+      setConversation: (state, action) => {
+        if (!(action.payload.offline_id in state.conversations)) {
+          throw new Error("Conversation does not exist in history");
+        }
+        state.conversations[action.payload.offline_id] = action.payload;
+      },
+      updateConversation: (state, action) => {
+        const existing = state.conversations[action.payload.offline_id];
+        if (!existing) {
+          throw new Error("Conversation does not exist in history");
+        }
+        state.conversations[action.payload.offline_id] = { ...existing, ...action.payload };
+      }
+    }
+  });
+  const { setConversations, addConversation, setConversation, updateConversation } = agentsSlice.actions;
+  const selectConversationMapping = (state) => state.agentsReducer.conversations;
+  const selectConversations = toolkit.createSelector(
+    [selectConversationMapping],
+    (conversationMapping) => Object.values(conversationMapping)
+  );
+  const selectConversation = restructureCreateSelectorWithArgs(
+    toolkit.createSelector(
+      [selectConversationMapping, (_state, conversationId) => conversationId],
+      (conversationMapping, conversationId) => conversationMapping[conversationId]
+    )
+  );
+  const agentsReducer = agentsSlice.reducer;
   const initialState = {
     version: 0
   };
@@ -4504,7 +4521,7 @@ var __publicField = (obj, key, value) => {
     reducers: {}
   });
   const versioningReducer = versioningSlice.reducer;
-  const fullComponentMarkerSize = 45;
+  const fullAssetMarkerSize = 45;
   const DEFAULT_ISSUE_STATUS = IssueStatus.BACKLOG;
   const DEFAULT_ISSUE_PRIORITY = IssuePriority.MEDIUM;
   const OUTBOX_RETRY_DELAY = 5e3;
@@ -4522,10 +4539,10 @@ var __publicField = (obj, key, value) => {
     fileReducer,
     authReducer,
     categoryReducer,
-    componentReducer,
-    componentStageCompletionReducer,
-    componentStageReducer,
-    componentTypeReducer,
+    assetReducer,
+    assetStageCompletionReducer,
+    assetStageReducer,
+    assetTypeReducer,
     issueReducer,
     issueTypeReducer,
     mapReducer,
@@ -4545,7 +4562,8 @@ var __publicField = (obj, key, value) => {
     emailDomainsReducer,
     licenseReducer,
     documentsReducer,
-    teamReducer
+    teamReducer,
+    agentsReducer
   };
   const overmapReducer = toolkit.combineReducers(overmapReducers);
   const resetStore = "RESET";
@@ -5305,6 +5323,9 @@ var __publicField = (obj, key, value) => {
     }
     async setTourStep(stepIndex) {
       this.client.store.dispatch(setTourStep(stepIndex));
+      const currentStep = this.client.store.getState().userReducer.currentUser.profile.tour_step;
+      if (currentStep === stepIndex)
+        return Promise.resolve(void 0);
       return this.enqueueRequest({
         description: "Set tour step",
         method: HttpMethod.PATCH,
@@ -5423,244 +5444,234 @@ var __publicField = (obj, key, value) => {
       store.dispatch(setCategories(result));
     }
   }
-  class ComponentService extends BaseApiService {
+  class AssetService extends BaseApiService {
     // Basic CRUD functions
-    add(component, workspaceId) {
-      const offlineComponent = offline(component);
-      this.client.store.dispatch(addComponent(offlineComponent));
+    add(asset, workspaceId) {
+      const offlineAsset = offline(asset);
+      this.client.store.dispatch(addAsset(offlineAsset));
       const promise = this.enqueueRequest({
-        description: "Create Component",
+        description: "Create asset",
         method: HttpMethod.POST,
-        url: `/components/types/${offlineComponent.component_type}/add-components/`,
+        url: `/assets/types/${offlineAsset.asset_type}/add-assets/`,
         queryParams: {
           workspace_id: workspaceId.toString()
         },
-        payload: { components: [offlineComponent] },
+        payload: { assets: [offlineAsset] },
         blockers: [],
-        blocks: [offlineComponent.offline_id]
+        blocks: [offlineAsset.offline_id]
       });
-      return [offlineComponent, promise];
+      return [offlineAsset, promise];
     }
-    update(component, workspaceId) {
-      this.client.store.dispatch(updateComponent(component));
+    update(asset, workspaceId) {
+      this.client.store.dispatch(updateAsset(asset));
       const promise = this.enqueueRequest({
-        description: "Edit component",
+        description: "Edit asset",
         method: HttpMethod.PATCH,
-        url: `/components/${component.offline_id}/`,
+        url: `/assets/${asset.offline_id}/`,
         queryParams: {
           workspace_id: workspaceId.toString()
         },
-        payload: component,
-        blockers: [component.offline_id],
-        blocks: [component.offline_id]
+        payload: asset,
+        blockers: [asset.offline_id],
+        blocks: [asset.offline_id]
       });
-      return [component, promise];
+      return [asset, promise];
     }
-    async remove(id) {
+    async remove(assetId) {
       const { store } = this.client;
-      const backupComponent = selectComponent(id)(store.getState());
-      if (!backupComponent)
-        throw new Error(`No component with id ${id} found in the store`);
-      const attachmentsOfComponent = selectAttachmentsOfComponent(id)(store.getState());
-      store.dispatch(removeComponent(id));
-      if (attachmentsOfComponent.length > 0) {
-        const attachmentsOfComponentIds = attachmentsOfComponent.map(({ offline_id }) => offline_id);
-        store.dispatch(removeComponentAttachments(attachmentsOfComponentIds));
+      const assetToBeDeleted = selectAsset(assetId)(store.getState());
+      if (!assetToBeDeleted)
+        throw new Error(`No asset with id ${assetId} found in the store`);
+      const attachmentsOfAssets = selectAttachmentsOfAsset(assetId)(store.getState());
+      store.dispatch(removeAsset(assetId));
+      if (attachmentsOfAssets.length > 0) {
+        const attachmentsOfAssetIds = attachmentsOfAssets.map(({ offline_id }) => offline_id);
+        store.dispatch(removeAssetAttachments(attachmentsOfAssetIds));
       }
       return this.enqueueRequest({
-        description: "Delete issue",
+        description: "Delete asset",
         method: HttpMethod.DELETE,
-        url: `/components/${id}/`,
-        blockers: [id],
+        url: `/assets/${assetId}/`,
+        blockers: [assetId],
         blocks: []
       }).catch((err) => {
-        store.dispatch(addComponent(backupComponent));
-        store.dispatch(addComponentAttachments(attachmentsOfComponent));
+        store.dispatch(addAsset(assetToBeDeleted));
+        store.dispatch(addAssetAttachments(attachmentsOfAssets));
         throw err;
       });
     }
-    async deleteAllByComponentType(componentTypeId) {
-      const clientStore2 = this.client.store;
-      const allComponentsOfType = selectComponentsFromComponentType(componentTypeId)(clientStore2.getState());
-      const affectedComponentIds = (allComponentsOfType || []).map((c) => c.offline_id);
-      const affectedOfflineIds = [componentTypeId, ...affectedComponentIds];
+    async deleteAllAssetsOfAssetType(assetTypeId) {
       const { store } = this.client;
       const state = store.getState();
-      const componentsOfThisType = selectComponentsByType(componentTypeId)(state);
-      store.dispatch(removeAllComponentsOfType(componentTypeId));
+      const allAssetsOfAssetType = selectAssetsOfAssetType(assetTypeId)(state);
+      const allAssetsOfAssetTypeIds = (allAssetsOfAssetType || []).map((c) => c.offline_id);
+      const affectedOfflineIds = [assetTypeId, ...allAssetsOfAssetTypeIds];
+      store.dispatch(removeAllAssetsOfType(assetTypeId));
       return this.enqueueRequest({
-        description: "Batch delete components by component type",
+        description: "Delete all assets of asset type",
         method: HttpMethod.DELETE,
-        url: `/components/types/${componentTypeId}/delete-all-of-type/`,
+        url: `/assets/types/${assetTypeId}/delete-all-of-type/`,
         blockers: affectedOfflineIds,
         blocks: affectedOfflineIds
       }).catch((err) => {
-        if (componentsOfThisType) {
-          store.dispatch(addComponentsInBatches(componentsOfThisType));
+        if (allAssetsOfAssetType) {
+          store.dispatch(addAssetsInBatches(allAssetsOfAssetType));
         }
         throw err;
       });
     }
-    async addBatch(componentsToCreate, workspaceId, componentTypeId) {
-      const fullComponents = componentsToCreate.map((component) => {
-        return { ...offline(component), submitted_at: (/* @__PURE__ */ new Date()).toISOString() };
+    async addBatch(assetsToCreate, workspaceId, assetTypeId) {
+      const fullAssets = assetsToCreate.map((asset) => {
+        return { ...offline(asset), submitted_at: (/* @__PURE__ */ new Date()).toISOString() };
       });
       const { store } = this.client;
-      store.dispatch(addComponentsInBatches(fullComponents));
+      store.dispatch(addAssetsInBatches(fullAssets));
       const promise = this.enqueueRequest({
-        description: "Batch create components",
+        description: "Batch create assets",
         method: HttpMethod.POST,
-        url: `/components/types/${componentTypeId}/add-components/`,
+        url: `/assets/types/${assetTypeId}/add-assets/`,
         queryParams: {
           workspace_id: workspaceId.toString()
         },
         payload: {
-          components: fullComponents
+          assets: fullAssets
         },
-        blockers: [componentTypeId],
-        blocks: fullComponents.map((c) => c.offline_id)
+        blockers: [assetTypeId],
+        blocks: fullAssets.map((c) => c.offline_id)
       });
       void promise.then((result) => {
-        for (const component of Object.values(result)) {
-          store.dispatch(updateComponent(component));
+        for (const assets of Object.values(result)) {
+          store.dispatch(updateAsset(assets));
         }
       }).catch((e) => {
-        for (const component of fullComponents) {
-          store.dispatch(removeComponent(component.offline_id));
+        for (const asset of fullAssets) {
+          store.dispatch(removeAsset(asset.offline_id));
         }
         throw e;
       });
       return promise;
     }
-    async refreshStore(replace) {
+    async refreshStore() {
       const { store } = this.client;
       const result = await this.enqueueRequest({
-        description: "Get components",
+        description: "Get assets",
         method: HttpMethod.GET,
-        url: `/projects/${store.getState().projectReducer.activeProjectId}/components/`,
+        url: `/projects/${store.getState().projectReducer.activeProjectId}/assets/`,
         blockers: [],
         blocks: []
       });
-      if (replace) {
-        store.dispatch(setComponents(result));
-      } else {
-        store.dispatch(addComponentsInBatches(result));
-      }
+      store.dispatch(setAssets(result));
     }
   }
-  class ComponentStageCompletionService extends BaseApiService {
-    add(componentId, stageId) {
+  class AssetStageCompletionService extends BaseApiService {
+    add(assetId, stageId) {
       var _a2;
       const { store } = this.client;
-      const componentType = (_a2 = store.getState().componentReducer.components[componentId]) == null ? void 0 : _a2.component_type;
-      if (!componentType) {
-        throw new Error(`Component ${componentId} not found`);
+      const assetTypeId = (_a2 = store.getState().assetReducer.assets[assetId]) == null ? void 0 : _a2.asset_type;
+      if (!assetTypeId) {
+        throw new Error(`Asset with offline_id ${assetId} not found`);
       }
-      const offlineCompletion = offline({
-        component: componentId,
+      const offlineStageCompletion = offline({
+        asset: assetId,
         stage: stageId
       });
-      store.dispatch(addStageCompletion(offlineCompletion));
+      store.dispatch(addStageCompletion(offlineStageCompletion));
       const promise = this.enqueueRequest({
-        description: "Mark stage as completed",
+        description: "Complete stage",
         method: HttpMethod.POST,
-        url: `/components/types/${componentType}/complete-stages/`,
+        url: `/assets/types/${assetTypeId}/complete-stages/`,
         // TODO: Add submitted_at to model
-        payload: { completions: [{ ...offlineCompletion, submitted_at: (/* @__PURE__ */ new Date()).getTime() / 1e3 }] },
-        blockers: [componentId, stageId],
-        blocks: [offlineCompletion.offline_id]
+        payload: { completions: [{ ...offlineStageCompletion, submitted_at: (/* @__PURE__ */ new Date()).getTime() / 1e3 }] },
+        blockers: [assetId, stageId],
+        blocks: [offlineStageCompletion.offline_id]
       });
-      return [offlineCompletion, promise];
+      return [offlineStageCompletion, promise];
     }
     async refreshStore() {
       const { store } = this.client;
       const result = await this.enqueueRequest({
-        description: "Get completed stages",
+        description: "Get stage completions",
         method: HttpMethod.GET,
-        url: `/projects/${store.getState().projectReducer.activeProjectId}/component-stage-completions/`,
+        url: `/projects/${store.getState().projectReducer.activeProjectId}/asset-stage-completions/`,
         blockers: [],
         blocks: []
       });
       store.dispatch(addStageCompletions(result));
     }
     /**
-     * Creates a collection of ComponentStageCompletions, marking the referenced stages as completed for the referenced
-     * components. It's REQUIRED that all components referenced all have the SAME component type.
-     * @param componentTypeId The ID of the component type for which we are completing stages (we can only complete
-     * stages for one component type at a time)
+     * Creates a collection of AssetStageCompletions, marking the referenced stages as completed for the referenced
+     * assets. It's REQUIRED that all assets referenced all have the SAME asset type.
+     * @param assetTypeId The ID of the asset type for which we are completing stages (we can only complete
+     * stages for one asset type at a time)
      * @param stageCompletions
      */
-    async bulkAdd(componentTypeId, stageCompletions) {
-      const offlineStagesCompletions = stageCompletions.map((completion) => {
+    async bulkAdd(assetTypeId, stageCompletions) {
+      const offlineStageCompletions = stageCompletions.map((completion) => {
         return offline(completion);
       });
       const asMapping = {};
       for (const completion of stageCompletions) {
-        const stageToCompletionDateMapping = asMapping[completion.component] || {};
+        const stageToCompletionDateMapping = asMapping[completion.asset] || {};
         stageToCompletionDateMapping[completion.stage] = (/* @__PURE__ */ new Date()).toISOString();
-        asMapping[completion.component] = stageToCompletionDateMapping;
+        asMapping[completion.asset] = stageToCompletionDateMapping;
       }
       this.client.store.dispatch(addStageCompletions(asMapping));
       await this.enqueueRequest({
-        description: "Mark multiple stage as completed",
+        description: "Bulk complete stages",
         method: HttpMethod.POST,
-        url: `/components/types/${componentTypeId}/complete-stages/`,
+        url: `/assets/types/${assetTypeId}/complete-stages/`,
         payload: {
-          completions: offlineStagesCompletions
+          completions: offlineStageCompletions
         },
-        blockers: [
-          componentTypeId,
-          ...stageCompletions.map((c) => c.component),
-          ...stageCompletions.map((c) => c.stage)
-        ],
-        blocks: offlineStagesCompletions.map((c) => c.offline_id)
+        blockers: [assetTypeId, ...stageCompletions.map((c) => c.asset), ...stageCompletions.map((c) => c.stage)],
+        blocks: offlineStageCompletions.map((c) => c.offline_id)
       });
     }
-    bulkDelete(stageId, componentIds) {
-      const completionsToRemove = componentIds.map((componentId) => {
+    bulkDelete(stageId, assetIds) {
+      const stageCompletionsToRemove = assetIds.map((assetId) => {
         return {
-          component: componentId,
+          asset: assetId,
           stage: stageId
         };
       });
-      this.client.store.dispatch(removeStageCompletions(completionsToRemove));
+      this.client.store.dispatch(removeStageCompletions(stageCompletionsToRemove));
       return this.enqueueRequest({
-        description: `Undo stage for ${componentIds.length} component(s)`,
+        description: `Undo stage for ${assetIds.length} assets(s)`,
         // TODO: Rename to setCompletedStages
         method: HttpMethod.DELETE,
-        url: `/components/stages/${stageId}/undo-stages/`,
+        url: `/assets/stages/${stageId}/undo-stages/`,
         payload: {
-          components: componentIds
+          assets: assetIds
         },
-        blockers: [stageId, ...componentIds],
+        blockers: [stageId, ...assetIds],
         blocks: []
       });
     }
   }
-  class ComponentStageService extends BaseApiService {
-    async bulkCreateStages(stagesToSubmit, componentTypeId, workspaceId) {
+  class AssetStageService extends BaseApiService {
+    async bulkCreateStages(stagesToSubmit, assetTypeId, workspaceId) {
       const payload = stagesToSubmit.map((stage) => {
         return offline(stage);
       });
       const fullStages = payload.map((stage) => {
-        return { ...stage, component_type: componentTypeId };
+        return { ...stage, asset_type: assetTypeId };
       });
       this.client.store.dispatch(addStages(fullStages));
       return this.enqueueRequest({
-        description: "Add component stages",
+        description: "Add asset stages",
         method: HttpMethod.POST,
-        url: `/components/types/${componentTypeId}/add-stages/`,
+        url: `/assets/types/${assetTypeId}/add-stages/`,
         payload: {
           stages: payload
         },
         queryParams: {
           workspace_id: workspaceId.toString()
         },
-        blockers: [componentTypeId, workspaceId],
+        blockers: [assetTypeId, workspaceId],
         blocks: payload.map(({ offline_id }) => offline_id)
       });
     }
-    async bulkUpdateStages(stagesToUpdate, componentTypeId) {
+    async bulkUpdateStages(stagesToUpdate, assetTypeId) {
       const store = this.client.store;
       const state = store.getState();
       const prevStages = selectStagesFromStageIds(
@@ -5671,13 +5682,13 @@ var __publicField = (obj, key, value) => {
       }
       store.dispatch(updateStages(stagesToUpdate));
       return this.enqueueRequest({
-        description: "Edit component stages",
+        description: "Edit asset stages",
         method: HttpMethod.PATCH,
-        url: `/components/types/${componentTypeId}/bulk-update-stages/`,
+        url: `/assets/types/${assetTypeId}/bulk-update-stages/`,
         payload: {
           stages: stagesToUpdate
         },
-        blockers: [componentTypeId],
+        blockers: [assetTypeId],
         blocks: stagesToUpdate.map(({ offline_id }) => offline_id)
       }).catch((e) => {
         store.dispatch(updateStages(prevStages));
@@ -5687,9 +5698,9 @@ var __publicField = (obj, key, value) => {
     async bulkDelete(idsToDelete) {
       this.client.store.dispatch(removeStages(idsToDelete));
       return this.enqueueRequest({
-        description: "Delete component stages",
+        description: "Delete asset stages",
         method: HttpMethod.DELETE,
-        url: "/components/stages/bulk-delete/",
+        url: "/assets/stages/bulk-delete/",
         payload: {
           stage_ids: idsToDelete
         },
@@ -5697,15 +5708,15 @@ var __publicField = (obj, key, value) => {
         blocks: []
       });
     }
-    async update(componentStage) {
-      this.client.store.dispatch(addStages([componentStage]));
+    async update(assetStage) {
+      this.client.store.dispatch(addStages([assetStage]));
       return this.enqueueRequest({
-        description: "Update component stage",
+        description: "Update asset stage",
         method: HttpMethod.PATCH,
-        url: `/components/stages/${componentStage.offline_id}/`,
-        payload: componentStage,
-        blockers: [componentStage.offline_id],
-        blocks: [componentStage.offline_id]
+        url: `/assets/stages/${assetStage.offline_id}/`,
+        payload: assetStage,
+        blockers: [assetStage.offline_id],
+        blocks: [assetStage.offline_id]
       });
     }
     async linkForm(stageId, formId2) {
@@ -5713,9 +5724,9 @@ var __publicField = (obj, key, value) => {
       store.dispatch(linkStageToForm({ stageId, formId: formId2 }));
       try {
         await this.enqueueRequest({
-          description: "Link component stage to form",
+          description: "Link asset stage to form",
           method: HttpMethod.POST,
-          url: `/components/stages/${stageId}/associate-with-form/`,
+          url: `/assets/stages/${stageId}/associate-with-form/`,
           payload: { user_form: formId2 },
           blockers: [stageId, formId2],
           blocks: [stageId]
@@ -5730,9 +5741,9 @@ var __publicField = (obj, key, value) => {
       store.dispatch(unlinkStageToForm({ stageId }));
       try {
         await this.enqueueRequest({
-          description: "Unlink component stage from form",
+          description: "Unlink asset stage from form",
           method: HttpMethod.DELETE,
-          url: `/components/stages/${stageId}/associate-with-form/`,
+          url: `/assets/stages/${stageId}/associate-with-form/`,
           blockers: [stageId, formId2],
           blocks: [stageId]
         });
@@ -5744,9 +5755,9 @@ var __publicField = (obj, key, value) => {
     async refreshStore() {
       const { store } = this.client;
       const result = await this.enqueueRequest({
-        description: "Get component stages",
+        description: "Get asset stages",
         method: HttpMethod.GET,
-        url: `/projects/${store.getState().projectReducer.activeProjectId}/component-stages/`,
+        url: `/projects/${store.getState().projectReducer.activeProjectId}/asset-stages/`,
         blockers: [],
         blocks: []
       });
@@ -5760,20 +5771,20 @@ var __publicField = (obj, key, value) => {
       deleteUrlPrefix: "/issues",
       fetchUrlPostfix: "/issue-attachments"
     },
-    [AttachmentModel.Component]: {
-      name: "component",
-      attachUrlPrefix: "/components",
-      deleteUrlPrefix: "/components",
-      fetchUrlPostfix: "/component-attachments"
+    [AttachmentModel.Asset]: {
+      name: "asset",
+      attachUrlPrefix: "/assets",
+      deleteUrlPrefix: "/assets",
+      fetchUrlPostfix: "/asset-attachments"
     },
-    [AttachmentModel.ComponentType]: {
-      name: "component type",
-      attachUrlPrefix: "/components/types",
-      deleteUrlPrefix: "/components/types",
-      fetchUrlPostfix: "/component-type-attachments"
+    [AttachmentModel.AssetType]: {
+      name: "asset type",
+      attachUrlPrefix: "/assets/types",
+      deleteUrlPrefix: "/assets/types",
+      fetchUrlPostfix: "/asset-type-attachments"
     },
     [AttachmentModel.Project]: {
-      name: "component project",
+      name: "project",
       attachUrlPrefix: "/projects",
       deleteUrlPrefix: "/projects",
       fetchUrlPostfix: "/attachments"
@@ -5789,8 +5800,8 @@ var __publicField = (obj, key, value) => {
     getNumberOfAttachmentsWithSha1(sha1) {
       const {
         issueReducer: issueReducer2,
-        componentReducer: componentReducer2,
-        componentTypeReducer: componentTypeReducer2,
+        assetReducer: assetReducer2,
+        assetTypeReducer: assetTypeReducer2,
         documentsReducer: documentsReducer2,
         projectReducer: projectReducer2,
         formSubmissionReducer: formSubmissionReducer2,
@@ -5798,8 +5809,8 @@ var __publicField = (obj, key, value) => {
       } = this.client.store.getState();
       const objectsWithSha1 = [].concat(
         Object.values(issueReducer2.attachments),
-        Object.values(componentReducer2.attachments),
-        Object.values(componentTypeReducer2.attachments),
+        Object.values(assetReducer2.attachments),
+        Object.values(assetTypeReducer2.attachments),
         Object.values(documentsReducer2.attachments),
         Object.values(projectReducer2.attachments),
         Object.values(formRevisionReducer2.attachments),
@@ -5921,10 +5932,10 @@ var __publicField = (obj, key, value) => {
       return promise;
     }
   }
-  class ComponentAttachmentService extends BaseAttachmentService {
+  class AssetAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "attachmentModel", AttachmentModel.Component);
+      __publicField(this, "attachmentModel", AttachmentModel.Asset);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -5935,115 +5946,108 @@ var __publicField = (obj, key, value) => {
         file_type: data.file.type,
         submitted_at: data.submittedAt,
         description: data.description,
-        component: data.modelId
+        asset: data.modelId
       });
     }
-    async attachFilesToComponent(files, componentId) {
-      return this.attachFiles(
-        files,
-        componentId,
-        this.buildOfflineAttachment.bind(this),
-        {
-          addAttachments: addComponentAttachments,
-          updateAttachments: updateComponentAttachments,
-          removeAttachments: removeComponentAttachments
-        }
-      );
+    async attachFilesToAsset(files, assetId) {
+      return this.attachFiles(files, assetId, this.buildOfflineAttachment.bind(this), {
+        addAttachments: addAssetAttachments,
+        updateAttachments: updateAssetAttachments,
+        removeAttachments: removeAssetAttachments
+      });
     }
-    deleteComponentAttachment(attachmentId) {
+    deleteAssetAttachment(attachmentId) {
       return this.deleteAttachment(
         attachmentId,
         {
-          setAttachment: setComponentAttachment,
-          removeAttachment: removeComponentAttachment
+          setAttachment: setAssetAttachment,
+          removeAttachment: removeAssetAttachment
         },
         {
-          selectAttachment: selectComponentAttachment
+          selectAttachment: selectAssetAttachment
         }
       );
     }
     async refreshStore() {
       return this.getAttachments({
-        setAttachments: setComponentAttachments
+        setAttachments: setAssetAttachments
       });
     }
   }
-  class ComponentTypeService extends BaseApiService {
-    add(componentType) {
-      const offlineComponentType = offline(componentType);
+  class AssetTypeService extends BaseApiService {
+    add(assetType) {
+      const offlineAssetType = offline(assetType);
       const { store } = this.client;
       const activeProjectId = store.getState().projectReducer.activeProjectId;
-      store.dispatch(addComponentType(offlineComponentType));
+      store.dispatch(addAssetType(offlineAssetType));
       const promise = this.enqueueRequest({
-        description: "Create ComponentType",
+        description: "Create asset type",
         method: HttpMethod.POST,
-        url: `/projects/${activeProjectId}/component-types/`,
-        payload: { ...offlineComponentType },
+        url: `/projects/${activeProjectId}/asset-types/`,
+        payload: { ...offlineAssetType },
         blockers: [],
-        blocks: [offlineComponentType.offline_id]
+        blocks: [offlineAssetType.offline_id]
       });
-      return [offlineComponentType, promise];
+      return [offlineAssetType, promise];
     }
-    update(componentType) {
-      this.client.store.dispatch(addComponentType(componentType));
+    update(assetType) {
+      this.client.store.dispatch(addAssetType(assetType));
       return this.enqueueRequest({
-        description: "Update ComponentType",
+        description: "Update asset type",
         method: HttpMethod.PATCH,
-        url: `/components/types/${componentType.offline_id}/`,
-        payload: componentType,
-        blockers: [componentType.offline_id],
-        blocks: [componentType.offline_id]
+        url: `/assets/types/${assetType.offline_id}/`,
+        payload: assetType,
+        blockers: [assetType.offline_id],
+        blocks: [assetType.offline_id]
       });
     }
-    async delete(componentTypeId) {
+    async delete(assetTypeId) {
       const { store } = this.client;
       const state = store.getState();
-      const componentType = selectComponentType(componentTypeId)(state);
-      if (!componentType) {
-        throw new Error("Expected componentType to exist");
-      }
-      const stagesOfComponentType = selectStagesFromComponentType(componentTypeId)(state) ?? [];
-      const attachmentsOfComponentType = selectAttachmentsOfComponentType(componentTypeId)(state);
-      store.dispatch(deleteComponentType(componentTypeId));
-      if (stagesOfComponentType.length > 0) {
-        const stagesOfComponentTypeIds = stagesOfComponentType.map(
-          (componentTypeStage) => componentTypeStage.offline_id
-        );
-        store.dispatch(removeStages(stagesOfComponentTypeIds));
+      const assetType = selectAssetType(assetTypeId)(state);
+      if (!assetType) {
+        throw new Error(`Expected asset type with offline_id ${assetTypeId} to exist`);
+      }
+      const stagesOfAssetType = selectStagesOfAssetType(assetTypeId)(state) ?? [];
+      const attachmentsOfAssetType = selectAttachmentsOfAssetType(assetTypeId)(state);
+      store.dispatch(deleteAssetType(assetTypeId));
+      if (stagesOfAssetType.length > 0) {
+        const stagesOfAssetTypeIds = stagesOfAssetType.map((assetStage) => assetStage.offline_id);
+        store.dispatch(removeStages(stagesOfAssetTypeIds));
       }
-      if (attachmentsOfComponentType.length > 0) {
-        const attachmentsOfComponentTypeIds = attachmentsOfComponentType.map(({ offline_id }) => offline_id);
-        store.dispatch(removeComponentTypeAttachments(attachmentsOfComponentTypeIds));
+      if (attachmentsOfAssetType.length > 0) {
+        const attachmentsOfAssetTypeIds = attachmentsOfAssetType.map(({ offline_id }) => offline_id);
+        store.dispatch(removeAssetTypeAttachments(attachmentsOfAssetTypeIds));
       }
       return this.enqueueRequest({
-        description: "Delete ComponentType",
+        description: "Delete asset type",
         method: HttpMethod.DELETE,
-        url: `/components/types/${componentTypeId}/`,
-        blockers: [componentTypeId],
+        url: `/assets/types/${assetTypeId}/`,
+        blockers: [assetTypeId],
         blocks: []
       }).catch((e) => {
-        store.dispatch(addComponentType(componentType));
-        store.dispatch(addStages(stagesOfComponentType));
-        store.dispatch(addComponentTypeAttachments(attachmentsOfComponentType));
+        store.dispatch(addAssetType(assetType));
+        store.dispatch(addStages(stagesOfAssetType));
+        store.dispatch(addAssetTypeAttachments(attachmentsOfAssetType));
         throw e;
       });
     }
     async refreshStore() {
       const { store } = this.client;
       const result = await this.enqueueRequest({
-        description: "Get component types",
+        description: "Get asset types",
         method: HttpMethod.GET,
-        url: `/projects/${store.getState().projectReducer.activeProjectId}/component-types/`,
+        url: `/projects/${store.getState().projectReducer.activeProjectId}/asset-types/`,
         blockers: [],
         blocks: []
       });
-      store.dispatch(setComponentTypes(result));
+      store.dispatch(setAssetTypes(result));
     }
   }
-  class ComponentTypeAttachmentService extends BaseAttachmentService {
+  class AssetTypeAttachmentService extends BaseAttachmentService {
     constructor() {
       super(...arguments);
-      __publicField(this, "attachmentModel", AttachmentModel.ComponentType);
+      __publicField(this, "attachmentModel", AttachmentModel.AssetType);
     }
     buildOfflineAttachment(data) {
       return offline({
@@ -6054,36 +6058,36 @@ var __publicField = (obj, key, value) => {
         file_type: data.file.type,
         submitted_at: data.submittedAt,
         description: data.description,
-        component_type: data.modelId
+        asset_type: data.modelId
       });
     }
-    async attachFilesToComponentType(files, componentTypeId) {
+    async attachFilesToAssetType(files, assetTypeId) {
       return this.attachFiles(
         files,
-        componentTypeId,
+        assetTypeId,
         this.buildOfflineAttachment.bind(this),
         {
-          addAttachments: addComponentTypeAttachments,
-          updateAttachments: updateComponentTypeAttachments,
-          removeAttachments: removeComponentTypeAttachments
+          addAttachments: addAssetTypeAttachments,
+          updateAttachments: updateAssetTypeAttachments,
+          removeAttachments: removeAssetTypeAttachments
         }
       );
     }
-    deleteComponentTypeAttachment(attachmentId) {
+    deleteAssetTypeAttachment(attachmentId) {
       return this.deleteAttachment(
         attachmentId,
         {
-          setAttachment: setComponentTypeAttachment,
-          removeAttachment: removeComponentTypeAttachment
+          setAttachment: setAssetTypeAttachment,
+          removeAttachment: removeAssetTypeAttachment
         },
         {
-          selectAttachment: selectComponentTypeAttachment
+          selectAttachment: selectAssetTypeAttachment
         }
       );
     }
     async refreshStore() {
       return this.getAttachments({
-        setAttachments: setComponentTypeAttachments
+        setAttachments: setAssetTypeAttachments
       });
     }
   }
@@ -6274,7 +6278,8 @@ var __publicField = (obj, key, value) => {
         if (error2 instanceof APIError) {
           (_a2 = blocks.unsafeShowToast) == null ? void 0 : _a2.call(blocks, {
             title: "Could not create issue",
-            description: "An unexpected error occurred while creating the issue."
+            description: error2.message,
+            severity: "danger"
           });
         }
         store.dispatch(removeIssue(issuePayload.offline_id));
@@ -6545,7 +6550,7 @@ var __publicField = (obj, key, value) => {
       if (replaceExisting) {
         this.client.store.dispatch(setIsFetchingInitialData(true));
       }
-      return this.enqueueRequest({
+      const result = await this.enqueueRequest({
         uuid: uuid2,
         description: "Get initial data",
         method: HttpMethod.GET,
@@ -6554,18 +6559,20 @@ var __publicField = (obj, key, value) => {
         isAuthNeeded: true,
         blockers: [],
         blocks: []
-      }).then((result) => {
-        void this._processInitialData(result, replaceExisting);
-        return result;
       });
+      void this._processInitialData(result, replaceExisting);
     }
-    async fetchProjectUsers(projectId) {
+    async fetchProjectUsers() {
+      const projectId = this.client.store.getState().projectReducer.activeProjectId;
       return this.enqueueRequest({
         description: "Fetch users",
         method: HttpMethod.GET,
         url: `/projects/${projectId}/users/`,
         blockers: [],
         blocks: []
+      }).then((users) => {
+        this.client.store.dispatch(addUsers(users));
+        return users;
       });
     }
     async fetchOrganizationUsers(orgId) {
@@ -6578,13 +6585,14 @@ var __publicField = (obj, key, value) => {
       });
     }
     // TODO:
-    //  Don't accept updateStore in ComponentService.list. Just return the offline objects and promise. Here, if
-    //  overwrite, use setComponents. Otherwise, use bulkAddComponents.
+    //  Don't accept updateStore in AssetService.list. Just return the offline objects and promise. Here, if
+    //  overwrite, use setAssets. Otherwise, use bulkAddAssets.
+    // TODO: This needs major cleanup. Send less in the initial data: Only the basic project info and anything needed
+    //  literally immediately.
     async _processInitialData(data, overwrite) {
       var _a2, _b, _c;
       const workspaces = {};
       const projects = [];
-      const categories = [];
       const projectsData = data.projects;
       const { store } = this.client;
       const oldProjectId = (_a2 = projectsData.find(
@@ -6608,18 +6616,11 @@ var __publicField = (obj, key, value) => {
           isProjectIdValid = true;
           for (const workspaceData of projectData.workspaces) {
             const workspace = { ...workspaceData, project: projectData.id };
-            if (workspace.categories) {
-              for (const category of workspace.categories) {
-                categories.push(category);
-              }
-            }
-            delete workspace.categories;
             workspaces[workspace.offline_id] = workspace;
           }
         }
       }
       store.dispatch(setCurrentUser(data.user));
-      store.dispatch(addUsers(data.project_owners));
       store.dispatch(setLicenses(data.licenses));
       const organizationsData = data.organizations;
       store.dispatch(setOrganizations(organizationsData));
@@ -6640,8 +6641,11 @@ var __publicField = (obj, key, value) => {
         currentOrgId = firstOrg.id;
       }
       if (currentOrgId) {
-        await this.client.organizations.fetchInitialOrganizationData(currentOrgId, false);
-        void this.client.teams.refreshStore();
+        const initialOrgData = await this.client.organizations.fetchInitialOrganizationData(currentOrgId, false);
+        currentOrgId = initialOrgData.organization.id;
+      }
+      if (!currentOrgId) {
+        throw new Error("No organization found");
       }
       if (!isProjectIdValid) {
         if (validProjects.length !== 0) {
@@ -6651,12 +6655,6 @@ var __publicField = (obj, key, value) => {
           if (projectData) {
             for (const workspaceData of projectData.workspaces) {
               const workspace = { ...workspaceData, project: projectData.id };
-              if (workspace.categories) {
-                for (const category of workspace.categories) {
-                  categories.push(category);
-                }
-              }
-              delete workspace.categories;
               workspaces[workspace.offline_id] = workspace;
             }
           }
@@ -6665,14 +6663,6 @@ var __publicField = (obj, key, value) => {
           store.dispatch(setActiveProjectId(currentProjectId));
         }
       }
-      if (currentProjectId) {
-        const usersResultPromise = this.fetchProjectUsers(currentProjectId);
-        const projectAccessRefreshPromise = this.client.projectAccesses.refreshStore();
-        const usersResult = await usersResultPromise;
-        await projectAccessRefreshPromise;
-        store.dispatch(addUsers(usersResult));
-        void this.client.projectAttachments.refreshStore();
-      }
       let currentWorkspaceId;
       const oldWorkspaceId = this.client.store.getState().workspaceReducer.activeWorkspaceId;
       if (overwrite || !oldWorkspaceId) {
@@ -6680,51 +6670,49 @@ var __publicField = (obj, key, value) => {
       } else {
         currentWorkspaceId = oldWorkspaceId;
       }
-      if (currentWorkspaceId && currentProjectId) {
+      if (currentWorkspaceId) {
         store.dispatch(setActiveWorkspaceId(currentWorkspaceId));
-        void this.client.categories.refreshStore().then(() => {
-          void this.client.issues.refreshStore().then(() => {
-            void this.client.issueAttachments.refreshStore().then();
-            void this.client.issueComments.refreshStore().then();
-            void this.client.issueUpdates.refreshStore().then();
-          });
-        });
-        void this.client.projectFiles.refreshStore().then();
-        void this.client.componentTypes.refreshStore().then(() => {
-          void this.client.componentTypeAttachments.refreshStore().then(() => {
-            void this.client.componentStages.refreshStore().then(() => {
-              void this.client.components.refreshStore(overwrite).then(() => {
-                void this.client.componentAttachments.refreshStore().then();
-              });
-            });
-            void this.client.componentStageCompletions.refreshStore().then();
-          });
-        });
-        void this.client.userForms.refreshStore().then(() => {
-          void this.client.userFormSubmissions.refreshStore().then();
-        });
-      }
-      if (currentProjectId) {
-        void this.client.documents.refreshStore().then(() => {
-          void this.client.documentAttachments.refreshStore().then();
-        });
-        void this.client.documents.refreshStore();
-        void this.client.issueUpdates.refreshStore();
-        void this.client.issueTypes.refreshStore();
       }
-      store.dispatch(setIsFetchingInitialData(false));
       if (overwrite) {
         console.log("Overwriting data");
         store.dispatch(setProjects(projects));
         store.dispatch(setWorkspaces(workspaces));
-        store.dispatch(setCategories(categories));
         store.dispatch(resetRecentIssues());
       } else {
         console.log("Updating data (collisions will be replaced)");
         store.dispatch(addOrReplaceProjects(projects));
         store.dispatch(addOrReplaceWorkspaces(workspaces));
-        store.dispatch(addOrReplaceCategories(categories));
       }
+      if (!currentProjectId) {
+        store.dispatch(setIsFetchingInitialData(false));
+      } else {
+        try {
+          await this.client.projectFiles.refreshStore();
+        } finally {
+          store.dispatch(setIsFetchingInitialData(false));
+        }
+        void this.client.assetTypes.refreshStore();
+        void this.client.assetStages.refreshStore();
+        void this.client.assets.refreshStore();
+        void this.client.assetStageCompletions.refreshStore();
+        void this.client.categories.refreshStore();
+        void this.client.issueTypes.refreshStore();
+        void this.client.issues.refreshStore();
+        void this.fetchProjectUsers();
+        void this.client.documents.refreshStore();
+        void this.client.userForms.refreshStore();
+        void this.client.documentAttachments.refreshStore();
+        void this.client.userFormSubmissions.refreshStore();
+        void this.client.agent.refreshStore();
+        void this.client.issueAttachments.refreshStore();
+        void this.client.issueComments.refreshStore();
+        void this.client.issueUpdates.refreshStore();
+        void this.client.projectAccesses.refreshStore();
+        void this.client.projectAttachments.refreshStore();
+        void this.client.assetTypeAttachments.refreshStore();
+        void this.client.assetAttachments.refreshStore();
+      }
+      void this.client.teams.refreshStore();
     }
   }
   class ProjectAccessService extends BaseApiService {
@@ -6764,16 +6752,11 @@ var __publicField = (obj, key, value) => {
       const { store } = this.client;
       const state = store.getState();
       const projectId = state.projectReducer.activeProjectId;
-      const currentUser = state.userReducer.currentUser;
       if (!projectId) {
         throw new Error("No active project");
       }
       const promise = this.fetchAll(projectId);
       const result = await promise;
-      const activeProjectAccess = result.find((projectAccess) => projectAccess.user === currentUser.id);
-      if (!activeProjectAccess) {
-        throw new Error("Current user does not have a project access instance");
-      }
       store.dispatch(setProjectAccesses(result));
     }
   }
@@ -7123,7 +7106,7 @@ var __publicField = (obj, key, value) => {
         });
       });
     }
-    async add(state, initialRevision, url, ownerUser, ownerOrganization, componentTypeId, issueTypeId) {
+    async add(state, initialRevision, url, ownerUser, ownerOrganization, assetTypeId, issueTypeId) {
       if (!!ownerUser === !!ownerOrganization) {
         throw new Error("Exactly one of ownerUser and ownerOrganization must be defined.");
       }
@@ -7142,7 +7125,7 @@ var __publicField = (obj, key, value) => {
         favorite: true,
         submitted_at: submittedAt,
         created_by: currentUser.id,
-        ...componentTypeId && { component_type: componentTypeId },
+        ...assetTypeId && { asset_type: assetTypeId },
         ...issueTypeId && { issue_type: issueTypeId },
         ...ownerAttrs
       };
@@ -7166,11 +7149,11 @@ var __publicField = (obj, key, value) => {
         } : void 0,
         payload: {
           ...offlineFormPayload,
-          ...componentTypeId && { component_type: componentTypeId },
+          ...assetTypeId && { asset_type: assetTypeId },
           ...issueTypeId && { issue_type: issueTypeId },
           initial_revision: payloadWithoutImage
         },
-        blockers: componentTypeId ? [componentTypeId] : issueTypeId ? [issueTypeId] : [],
+        blockers: assetTypeId ? [assetTypeId] : issueTypeId ? [issueTypeId] : [],
         blocks: [offlineFormPayload.offline_id, payloadWithoutImage.offline_id]
       });
       const attachImagesPromises = this.getAttachImagePromises(images, offlineRevisionPayload.offline_id);
@@ -7194,7 +7177,7 @@ var __publicField = (obj, key, value) => {
         `/forms/in-organization/${activeOrganizationId}/`,
         void 0,
         activeOrganizationId,
-        attachedTo && "componentTypeId" in attachedTo ? attachedTo.componentTypeId : void 0,
+        attachedTo && "assetTypeId" in attachedTo ? attachedTo.assetTypeId : void 0,
         attachedTo && "issueTypeId" in attachedTo ? attachedTo.issueTypeId : void 0
       );
     }
@@ -7207,7 +7190,7 @@ var __publicField = (obj, key, value) => {
         "/forms/my-forms/",
         currentUser.id,
         void 0,
-        attachedTo && "componentTypeId" in attachedTo ? attachedTo.componentTypeId : void 0,
+        attachedTo && "assetTypeId" in attachedTo ? attachedTo.assetTypeId : void 0,
         attachedTo && "issueTypeId" in attachedTo ? attachedTo.issueTypeId : void 0
       );
     }
@@ -7375,8 +7358,8 @@ var __publicField = (obj, key, value) => {
               url: `/forms/submission/${submission.offline_id}/attachments/`,
               payload: submissionAttachmentPayload,
               blockers: [
-                submission.component,
-                submission.component_stage,
+                submission.asset,
+                submission.asset_stage,
                 submission.issue,
                 submission.form_revision
               ].filter((x) => x !== void 0),
@@ -7412,7 +7395,7 @@ var __publicField = (obj, key, value) => {
         method: HttpMethod.POST,
         url: `/forms/revisions/${payload.form_revision}/respond/`,
         payload: { ...offlineSubmission, project: activeProjectId },
-        blockers: [payload.issue, payload.component, payload.component_stage, "add-form-entry"].filter(
+        blockers: [payload.issue, payload.asset, payload.asset_stage, "add-form-entry"].filter(
           (x) => x !== void 0
         ),
         blocks: [payload.offline_id]
@@ -7430,10 +7413,10 @@ var __publicField = (obj, key, value) => {
       const settledPromise = Promise.all([promise, ...attachFilesPromises]).then(() => promise);
       return [offlineSubmission, settledPromise];
     }
-    // Note currently the bulkAdd method is specific to form submissions for components
+    // 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) {
-      const { formRevision, values: argsValues, componentOfflineIds } = args;
+      const { formRevision, values: argsValues, assetOfflineIds } = args;
       const { store } = this.client;
       const offlineSubmissions = [];
       const offlineAttachments = [];
@@ -7443,16 +7426,16 @@ var __publicField = (obj, key, value) => {
       const { values, files } = separateFilesFromValues(argsValues);
       const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
       const createdBy = store.getState().userReducer.currentUser.id;
-      for (const component_id of componentOfflineIds) {
+      for (const assetId of assetOfflineIds) {
         const submission = offline({
           form_revision: formRevision,
           values,
           created_by: createdBy,
           submitted_at: submittedAt,
-          component: component_id
+          asset: assetId
         });
         submissionOfflineIds.push(submission.offline_id);
-        submissionsPayload.push({ offline_id: submission.offline_id, component_id });
+        submissionsPayload.push({ offline_id: submission.offline_id, asset_id: assetId });
         offlineSubmissions.push(submission);
         for (const [fieldIdentifier, fileArray] of Object.entries(files)) {
           for (const file of fileArray) {
@@ -7499,7 +7482,7 @@ var __publicField = (obj, key, value) => {
           attachments: attachmentsPayload,
           files: Object.values(filesRecord)
         },
-        blockers: componentOfflineIds,
+        blockers: assetOfflineIds,
         blocks: submissionOfflineIds
       });
       promise.then(({ submissions, attachments, presigned_urls }) => {
@@ -7542,7 +7525,7 @@ var __publicField = (obj, key, value) => {
         method: HttpMethod.PATCH,
         url: `/forms/submissions/${submission.offline_id}/`,
         payload: offlineSubmission,
-        blockers: [offlineSubmission.issue, offlineSubmission.component, offlineSubmission.component_stage].filter(
+        blockers: [offlineSubmission.issue, offlineSubmission.asset, offlineSubmission.asset_stage].filter(
           (x) => x !== void 0
         ),
         blocks: [offlineSubmission.offline_id]
@@ -8351,24 +8334,70 @@ var __publicField = (obj, key, value) => {
     }
   }
   class AgentService extends BaseApiService {
+    async startConversation(prompt) {
+      const activeProjectId = this.client.store.getState().projectReducer.activeProjectId;
+      return this.enqueueRequest({
+        description: "Start agent conversation",
+        method: HttpMethod.POST,
+        url: "/agents/prompt/",
+        payload: {
+          prompt,
+          active_project: activeProjectId
+        },
+        blockers: ["prompt"],
+        blocks: ["prompt"]
+      }).then((response) => {
+        if (response.conversation) {
+          this.client.store.dispatch(addConversation(response.conversation));
+          return response.conversation;
+        }
+        throw new Error("Unexpected response from agent");
+      });
+    }
     /**
      * Prompt the agent with a message.
-     * @param request The message to prompt the agent with.
+     * @param prompt The message to prompt the agent with.
      * @param conversationId If continuing an existing message, the UUID of that conversation.
      */
-    async prompt(request2, conversationId) {
-      const activeProjectId = this.client.store.getState().projectReducer.activeProjectId;
+    async continueConversation(prompt, conversationId) {
+      const { store } = this.client;
+      const activeProjectId = store.getState().projectReducer.activeProjectId;
       return this.enqueueRequest({
         description: "Prompt agent",
         method: HttpMethod.POST,
         url: "/agents/prompt/",
         payload: {
-          prompt: request2,
+          prompt,
           active_project: activeProjectId
         },
         blockers: ["prompt"],
         blocks: ["prompt"],
-        queryParams: conversationId ? { conversation_id: conversationId } : {}
+        queryParams: { conversation_id: conversationId }
+      }).then((response) => {
+        if (response.response) {
+          const conversation = store.getState().agentsReducer.conversations[conversationId];
+          if (!conversation) {
+            throw new Error("Conversation not found");
+          }
+          store.dispatch(
+            updateConversation({
+              offline_id: conversationId,
+              tiptap_content: [...conversation.tiptap_content || [], response.response]
+            })
+          );
+        }
+        throw new Error("Unexpected response from agent");
+      });
+    }
+    async fetchDetails(conversationId) {
+      return this.enqueueRequest({
+        description: "Get agent conversation",
+        method: HttpMethod.GET,
+        url: `/agents/conversations/${conversationId}/`,
+        blockers: ["conversation"],
+        blocks: ["conversation"]
+      }).then((response) => {
+        this.client.store.dispatch(setConversation(response));
       });
     }
     async rate(responseId, rating) {
@@ -8381,6 +8410,18 @@ var __publicField = (obj, key, value) => {
         blocks: ["rate"]
       });
     }
+    async refreshStore() {
+      const { store } = this.client;
+      const activeProject = store.getState().projectReducer.activeProjectId;
+      const result = await this.enqueueRequest({
+        description: "Get agent conversation history",
+        method: HttpMethod.GET,
+        url: `/projects/${activeProject}/agent-conversations/`,
+        blockers: ["agent-conversations"],
+        blocks: ["agent-conversations"]
+      });
+      store.dispatch(setConversations(result));
+    }
   }
   class TeamService extends BaseApiService {
     add(teamPayload) {
@@ -8536,12 +8577,12 @@ var __publicField = (obj, key, value) => {
       __publicField(this, "issueAttachments", new IssueAttachmentService(this));
       __publicField(this, "workspaces", new WorkspaceService(this));
       __publicField(this, "main", new MainService(this));
-      __publicField(this, "components", new ComponentService(this));
-      __publicField(this, "componentAttachments", new ComponentAttachmentService(this));
-      __publicField(this, "componentTypes", new ComponentTypeService(this));
-      __publicField(this, "componentTypeAttachments", new ComponentTypeAttachmentService(this));
-      __publicField(this, "componentStages", new ComponentStageService(this));
-      __publicField(this, "componentStageCompletions", new ComponentStageCompletionService(this));
+      __publicField(this, "assets", new AssetService(this));
+      __publicField(this, "assetAttachments", new AssetAttachmentService(this));
+      __publicField(this, "assetTypes", new AssetTypeService(this));
+      __publicField(this, "assetTypeAttachments", new AssetTypeAttachmentService(this));
+      __publicField(this, "assetStages", new AssetStageService(this));
+      __publicField(this, "assetStageCompletions", new AssetStageCompletionService(this));
       __publicField(this, "userForms", new UserFormService(this));
       __publicField(this, "userFormSubmissions", new UserFormSubmissionService(this));
       __publicField(this, "projects", new ProjectService(this));
@@ -15172,9 +15213,9 @@ var __publicField = (obj, key, value) => {
       }, [filter, maxResults, ownerFilter]);
       const userForms = useAppSelector(selectFilteredForms(ownerFilterOptions)) ?? [];
       const userFormMapping = useAppSelector(selectFormMapping);
-      const attachableUserForms = userForms.filter((form) => !form.component_type && !form.issue_type);
+      const attachableUserForms = userForms.filter((form) => !form.asset_type && !form.issue_type);
       const attachableUserFormMapping = Object.values(userFormMapping).filter(
-        (form) => !form.component_type
+        (form) => !form.asset_type
       );
       const handleToggleFavorite = React.useCallback(
         (form) => {
@@ -16578,6 +16619,13 @@ var __publicField = (obj, key, value) => {
   }, Symbol.toStringTag, { value: "Module" }));
   exports2.APIError = APIError;
   exports2.AgentService = AgentService;
+  exports2.AssetAttachmentService = AssetAttachmentService;
+  exports2.AssetService = AssetService;
+  exports2.AssetStageColors = AssetStageColors;
+  exports2.AssetStageCompletionService = AssetStageCompletionService;
+  exports2.AssetStageService = AssetStageService;
+  exports2.AssetTypeAttachmentService = AssetTypeAttachmentService;
+  exports2.AssetTypeService = AssetTypeService;
   exports2.AttachmentModel = AttachmentModel;
   exports2.AuthService = AuthService;
   exports2.BaseApiService = BaseApiService;
@@ -16589,13 +16637,6 @@ var __publicField = (obj, key, value) => {
   exports2.ColorPicker = ColorPicker;
   exports2.Colors = Colors;
   exports2.ColorsToString = ColorsToString;
-  exports2.ComponentAttachmentService = ComponentAttachmentService;
-  exports2.ComponentService = ComponentService;
-  exports2.ComponentStageColors = ComponentStageColors;
-  exports2.ComponentStageCompletionService = ComponentStageCompletionService;
-  exports2.ComponentStageService = ComponentStageService;
-  exports2.ComponentTypeAttachmentService = ComponentTypeAttachmentService;
-  exports2.ComponentTypeService = ComponentTypeService;
   exports2.DEFAULT_ISSUE_PRIORITY = DEFAULT_ISSUE_PRIORITY;
   exports2.DEFAULT_ISSUE_STATUS = DEFAULT_ISSUE_STATUS;
   exports2.DateField = DateField;
@@ -16687,14 +16728,15 @@ var __publicField = (obj, key, value) => {
   exports2.acceptProjectInvite = acceptProjectInvite;
   exports2.addActiveProjectFormSubmissionsCount = addActiveProjectFormSubmissionsCount;
   exports2.addActiveProjectIssuesCount = addActiveProjectIssuesCount;
+  exports2.addAsset = addAsset;
+  exports2.addAssetAttachment = addAssetAttachment;
+  exports2.addAssetAttachments = addAssetAttachments;
+  exports2.addAssetType = addAssetType;
+  exports2.addAssetTypeAttachment = addAssetTypeAttachment;
+  exports2.addAssetTypeAttachments = addAssetTypeAttachments;
+  exports2.addAssetsInBatches = addAssetsInBatches;
   exports2.addCategory = addCategory;
-  exports2.addComponent = addComponent;
-  exports2.addComponentAttachment = addComponentAttachment;
-  exports2.addComponentAttachments = addComponentAttachments;
-  exports2.addComponentType = addComponentType;
-  exports2.addComponentTypeAttachment = addComponentTypeAttachment;
-  exports2.addComponentTypeAttachments = addComponentTypeAttachments;
-  exports2.addComponentsInBatches = addComponentsInBatches;
+  exports2.addConversation = addConversation;
   exports2.addDocumentAttachment = addDocumentAttachment;
   exports2.addDocumentAttachments = addDocumentAttachments;
   exports2.addDocuments = addDocuments;
@@ -16735,7 +16777,17 @@ var __publicField = (obj, key, value) => {
   exports2.addToRecentIssues = addToRecentIssues;
   exports2.addUsers = addUsers;
   exports2.addWorkspace = addWorkspace;
+  exports2.agentsReducer = agentsReducer;
+  exports2.agentsSlice = agentsSlice;
   exports2.areArraysEqual = areArraysEqual;
+  exports2.assetReducer = assetReducer;
+  exports2.assetSlice = assetSlice;
+  exports2.assetStageCompletionReducer = assetStageCompletionReducer;
+  exports2.assetStageCompletionSlice = assetStageCompletionSlice;
+  exports2.assetStageReducer = assetStageReducer;
+  exports2.assetStageSlice = assetStageSlice;
+  exports2.assetTypeReducer = assetTypeReducer;
+  exports2.assetTypeSlice = assetTypeSlice;
   exports2.authReducer = authReducer;
   exports2.authSlice = authSlice;
   exports2.blobToBase64 = blobToBase64;
@@ -16745,14 +16797,6 @@ var __publicField = (obj, key, value) => {
   exports2.classNames = classNames$1;
   exports2.cleanRecentIssues = cleanRecentIssues;
   exports2.clearTokens = clearTokens;
-  exports2.componentReducer = componentReducer;
-  exports2.componentSlice = componentSlice;
-  exports2.componentStageCompletionReducer = componentStageCompletionReducer;
-  exports2.componentStageCompletionSlice = componentStageCompletionSlice;
-  exports2.componentStageReducer = componentStageReducer;
-  exports2.componentStageSlice = componentStageSlice;
-  exports2.componentTypeReducer = componentTypeReducer;
-  exports2.componentTypeSlice = componentTypeSlice;
   exports2.constructUploadedFilePayloads = constructUploadedFilePayloads;
   exports2.coordinatesAreEqual = coordinatesAreEqual;
   exports2.coordinatesToLiteral = coordinatesToLiteral;
@@ -16763,7 +16807,7 @@ var __publicField = (obj, key, value) => {
   exports2.createPointMarker = createPointMarker;
   exports2.defaultBadgeColor = defaultBadgeColor;
   exports2.defaultStore = defaultStore;
-  exports2.deleteComponentType = deleteComponentType;
+  exports2.deleteAssetType = deleteAssetType;
   exports2.deleteForm = deleteForm;
   exports2.deleteFormRevision = deleteFormRevision;
   exports2.deleteFormRevisionAttachment = deleteFormRevisionAttachment;
@@ -16812,7 +16856,7 @@ var __publicField = (obj, key, value) => {
   exports2.formSubmissionReducer = formSubmissionReducer;
   exports2.formSubmissionSlice = formSubmissionSlice;
   exports2.forms = index;
-  exports2.fullComponentMarkerSize = fullComponentMarkerSize;
+  exports2.fullAssetMarkerSize = fullAssetMarkerSize;
   exports2.generateBadgeColors = generateBadgeColors;
   exports2.genericMemo = genericMemo;
   exports2.getFileIdentifier = getFileIdentifier;
@@ -16872,15 +16916,15 @@ var __publicField = (obj, key, value) => {
   exports2.projectSlice = projectSlice;
   exports2.rehydratedReducer = rehydratedReducer;
   exports2.rehydratedSlice = rehydratedSlice;
-  exports2.removeAllComponentsOfType = removeAllComponentsOfType;
+  exports2.removeAllAssetsOfType = removeAllAssetsOfType;
+  exports2.removeAsset = removeAsset;
+  exports2.removeAssetAttachment = removeAssetAttachment;
+  exports2.removeAssetAttachments = removeAssetAttachments;
+  exports2.removeAssetTypeAttachment = removeAssetTypeAttachment;
+  exports2.removeAssetTypeAttachments = removeAssetTypeAttachments;
   exports2.removeAttachmentsOfIssue = removeAttachmentsOfIssue;
   exports2.removeCategory = removeCategory;
   exports2.removeColor = removeColor;
-  exports2.removeComponent = removeComponent;
-  exports2.removeComponentAttachment = removeComponentAttachment;
-  exports2.removeComponentAttachments = removeComponentAttachments;
-  exports2.removeComponentTypeAttachment = removeComponentTypeAttachment;
-  exports2.removeComponentTypeAttachments = removeComponentTypeAttachments;
   exports2.removeDocumentAttachment = removeDocumentAttachment;
   exports2.removeDocumentAttachments = removeDocumentAttachments;
   exports2.removeDocuments = removeDocuments;
@@ -16931,16 +16975,31 @@ var __publicField = (obj, key, value) => {
   exports2.selectActiveWorkspace = selectActiveWorkspace;
   exports2.selectActiveWorkspaceId = selectActiveWorkspaceId;
   exports2.selectAllAttachments = selectAllAttachments;
-  exports2.selectAllComponentAttachments = selectAllComponentAttachments;
-  exports2.selectAllComponentTypeAttachments = selectAllComponentTypeAttachments;
   exports2.selectAllDocumentAttachments = selectAllDocumentAttachments;
   exports2.selectAllProjectAttachments = selectAllProjectAttachments;
   exports2.selectAncestorIdsOfDocument = selectAncestorIdsOfDocument;
   exports2.selectAppearance = selectAppearance;
-  exports2.selectAttachmentsOfComponent = selectAttachmentsOfComponent;
-  exports2.selectAttachmentsOfComponentByType = selectAttachmentsOfComponentByType;
-  exports2.selectAttachmentsOfComponentType = selectAttachmentsOfComponentType;
-  exports2.selectAttachmentsOfComponentTypeByType = selectAttachmentsOfComponentTypeByType;
+  exports2.selectAsset = selectAsset;
+  exports2.selectAssetAttachment = selectAssetAttachment;
+  exports2.selectAssetAttachmentMapping = selectAssetAttachmentMapping;
+  exports2.selectAssetAttachments = selectAssetAttachments;
+  exports2.selectAssetToAssetTypeMapping = selectAssetToAssetTypeMapping;
+  exports2.selectAssetType = selectAssetType;
+  exports2.selectAssetTypeAttachment = selectAssetTypeAttachment;
+  exports2.selectAssetTypeAttachmentMapping = selectAssetTypeAttachmentMapping;
+  exports2.selectAssetTypeAttachments = selectAssetTypeAttachments;
+  exports2.selectAssetTypeStagesMapping = selectAssetTypeStagesMapping;
+  exports2.selectAssetTypes = selectAssetTypes;
+  exports2.selectAssetTypesByName = selectAssetTypesByName;
+  exports2.selectAssetTypesFromIds = selectAssetTypesFromIds;
+  exports2.selectAssetTypesMapping = selectAssetTypesMapping;
+  exports2.selectAssets = selectAssets;
+  exports2.selectAssetsMapping = selectAssetsMapping;
+  exports2.selectAssetsOfAssetType = selectAssetsOfAssetType;
+  exports2.selectAttachmentsOfAsset = selectAttachmentsOfAsset;
+  exports2.selectAttachmentsOfAssetType = selectAttachmentsOfAssetType;
+  exports2.selectAttachmentsOfAssetTypeByType = selectAttachmentsOfAssetTypeByType;
+  exports2.selectAttachmentsOfAssetsByType = selectAttachmentsOfAssetsByType;
   exports2.selectAttachmentsOfDocument = selectAttachmentsOfDocument;
   exports2.selectAttachmentsOfDocumentByType = selectAttachmentsOfDocumentByType;
   exports2.selectAttachmentsOfFormRevision = selectAttachmentsOfFormRevision;
@@ -16957,25 +17016,11 @@ var __publicField = (obj, key, value) => {
   exports2.selectCenterMapToProject = selectCenterMapToProject;
   exports2.selectCommentMapping = selectCommentMapping;
   exports2.selectCommentsOfIssue = selectCommentsOfIssue;
-  exports2.selectCompletedStageIdsForComponent = selectCompletedStageIdsForComponent;
+  exports2.selectCompletedStageIdsForAsset = selectCompletedStageIdsForAsset;
   exports2.selectCompletedStages = selectCompletedStages;
-  exports2.selectComponent = selectComponent;
-  exports2.selectComponentAttachment = selectComponentAttachment;
-  exports2.selectComponentAttachmentMapping = selectComponentAttachmentMapping;
-  exports2.selectComponentType = selectComponentType;
-  exports2.selectComponentTypeAttachment = selectComponentTypeAttachment;
-  exports2.selectComponentTypeAttachmentMapping = selectComponentTypeAttachmentMapping;
-  exports2.selectComponentTypeFromComponent = selectComponentTypeFromComponent;
-  exports2.selectComponentTypeFromComponents = selectComponentTypeFromComponents;
-  exports2.selectComponentTypeStagesMapping = selectComponentTypeStagesMapping;
-  exports2.selectComponentTypes = selectComponentTypes;
-  exports2.selectComponentTypesByName = selectComponentTypesByName;
-  exports2.selectComponentTypesFromIds = selectComponentTypesFromIds;
-  exports2.selectComponentTypesMapping = selectComponentTypesMapping;
-  exports2.selectComponents = selectComponents;
-  exports2.selectComponentsByType = selectComponentsByType;
-  exports2.selectComponentsFromComponentType = selectComponentsFromComponentType;
-  exports2.selectComponentsMapping = selectComponentsMapping;
+  exports2.selectConversation = selectConversation;
+  exports2.selectConversationMapping = selectConversationMapping;
+  exports2.selectConversations = selectConversations;
   exports2.selectCreateProjectType = selectCreateProjectType;
   exports2.selectCurrentUser = selectCurrentUser;
   exports2.selectDeletedRequests = selectDeletedRequests;
@@ -16997,7 +17042,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectFilteredForms = selectFilteredForms;
   exports2.selectForm = selectForm;
   exports2.selectFormMapping = selectFormMapping;
-  exports2.selectFormOfComponentType = selectFormOfComponentType;
+  exports2.selectFormOfAssetType = selectFormOfAssetType;
   exports2.selectFormOfIssueType = selectFormOfIssueType;
   exports2.selectFormRevision = selectFormRevision;
   exports2.selectFormRevisionMapping = selectFormRevisionMapping;
@@ -17006,16 +17051,16 @@ var __publicField = (obj, key, value) => {
   exports2.selectFormSubmission = selectFormSubmission;
   exports2.selectFormSubmissionAttachmentsMapping = selectFormSubmissionAttachmentsMapping;
   exports2.selectFormSubmissions = selectFormSubmissions;
-  exports2.selectFormSubmissionsByComponents = selectFormSubmissionsByComponents;
+  exports2.selectFormSubmissionsByAssets = selectFormSubmissionsByAssets;
   exports2.selectFormSubmissionsByFormRevisions = selectFormSubmissionsByFormRevisions;
   exports2.selectFormSubmissionsMapping = selectFormSubmissionsMapping;
-  exports2.selectFormSubmissionsOfComponent = selectFormSubmissionsOfComponent;
+  exports2.selectFormSubmissionsOfAsset = selectFormSubmissionsOfAsset;
   exports2.selectFormSubmissionsOfForm = selectFormSubmissionsOfForm;
   exports2.selectFormSubmissionsOfIssue = selectFormSubmissionsOfIssue;
   exports2.selectFormsCount = selectFormsCount;
   exports2.selectGeneralFormCount = selectGeneralFormCount;
+  exports2.selectHiddenAssetTypeIds = selectHiddenAssetTypeIds;
   exports2.selectHiddenCategoryCount = selectHiddenCategoryCount;
-  exports2.selectHiddenComponentTypeIds = selectHiddenComponentTypeIds;
   exports2.selectIsFetchingInitialData = selectIsFetchingInitialData;
   exports2.selectIsImportingProjectFile = selectIsImportingProjectFile;
   exports2.selectIsLoading = selectIsLoading;
@@ -17037,7 +17082,7 @@ var __publicField = (obj, key, value) => {
   exports2.selectIssuesOfIssueTypeCount = selectIssuesOfIssueTypeCount;
   exports2.selectLatestFormRevisionByForm = selectLatestFormRevisionByForm;
   exports2.selectLatestFormRevisionOfForm = selectLatestFormRevisionOfForm;
-  exports2.selectLatestFormRevisionsOfComponentTypes = selectLatestFormRevisionsOfComponentTypes;
+  exports2.selectLatestFormRevisionsOfAssetTypes = selectLatestFormRevisionsOfAssetTypes;
   exports2.selectLatestRetryTime = selectLatestRetryTime;
   exports2.selectLicense = selectLicense;
   exports2.selectLicenseForProject = selectLicenseForProject;
@@ -17045,8 +17090,8 @@ var __publicField = (obj, key, value) => {
   exports2.selectLicensesForProjectsMapping = selectLicensesForProjectsMapping;
   exports2.selectMainWorkspace = selectMainWorkspace;
   exports2.selectMapStyle = selectMapStyle;
-  exports2.selectNumberOfComponentTypesMatchingCaseInsensitiveName = selectNumberOfComponentTypesMatchingCaseInsensitiveName;
-  exports2.selectNumberOfComponentsOfComponentType = selectNumberOfComponentsOfComponentType;
+  exports2.selectNumberOfAssetTypesMatchingCaseInsensitiveName = selectNumberOfAssetTypesMatchingCaseInsensitiveName;
+  exports2.selectNumberOfAssetsOfAssetType = selectNumberOfAssetsOfAssetType;
   exports2.selectOrganization = selectOrganization;
   exports2.selectOrganizationAccess = selectOrganizationAccess;
   exports2.selectOrganizationAccessForUser = selectOrganizationAccessForUser;
@@ -17087,9 +17132,9 @@ var __publicField = (obj, key, value) => {
   exports2.selectStageFormIdsFromStageIds = selectStageFormIdsFromStageIds;
   exports2.selectStageMapping = selectStageMapping;
   exports2.selectStages = selectStages;
-  exports2.selectStagesFromComponentType = selectStagesFromComponentType;
-  exports2.selectStagesFromComponentTypeIds = selectStagesFromComponentTypeIds;
+  exports2.selectStagesFromAssetTypeIds = selectStagesFromAssetTypeIds;
   exports2.selectStagesFromStageIds = selectStagesFromStageIds;
+  exports2.selectStagesOfAssetType = selectStagesOfAssetType;
   exports2.selectTeam = selectTeam;
   exports2.selectTeams = selectTeams;
   exports2.selectTeamsMapping = selectTeamsMapping;
@@ -17111,14 +17156,16 @@ var __publicField = (obj, key, value) => {
   exports2.setActiveProjectId = setActiveProjectId;
   exports2.setActiveWorkspaceId = setActiveWorkspaceId;
   exports2.setAppearance = setAppearance;
+  exports2.setAssetAttachment = setAssetAttachment;
+  exports2.setAssetAttachments = setAssetAttachments;
+  exports2.setAssetTypeAttachment = setAssetTypeAttachment;
+  exports2.setAssetTypeAttachments = setAssetTypeAttachments;
+  exports2.setAssetTypes = setAssetTypes;
+  exports2.setAssets = setAssets;
   exports2.setCategories = setCategories;
   exports2.setCenterMapToProject = setCenterMapToProject;
-  exports2.setComponentAttachment = setComponentAttachment;
-  exports2.setComponentAttachments = setComponentAttachments;
-  exports2.setComponentTypeAttachment = setComponentTypeAttachment;
-  exports2.setComponentTypeAttachments = setComponentTypeAttachments;
-  exports2.setComponentTypes = setComponentTypes;
-  exports2.setComponents = setComponents;
+  exports2.setConversation = setConversation;
+  exports2.setConversations = setConversations;
   exports2.setCreateProjectType = setCreateProjectType;
   exports2.setCurrentUser = setCurrentUser;
   exports2.setDocumentAttachment = setDocumentAttachment;
@@ -17179,18 +17226,19 @@ var __publicField = (obj, key, value) => {
   exports2.teamSlice = teamSlice;
   exports2.toFileNameSafeString = toFileNameSafeString;
   exports2.toOfflineIdRecord = toOfflineIdRecord;
-  exports2.toggleComponentTypeVisibility = toggleComponentTypeVisibility;
+  exports2.toggleAssetTypeVisibility = toggleAssetTypeVisibility;
   exports2.truncate = truncate;
   exports2.unfavoriteForm = unfavoriteForm;
   exports2.unhideAllCategories = unhideAllCategories;
   exports2.unhideCategory = unhideCategory;
   exports2.unlinkStageToForm = unlinkStageToForm;
   exports2.updateActiveOrganization = updateActiveOrganization;
-  exports2.updateComponent = updateComponent;
-  exports2.updateComponentAttachment = updateComponentAttachment;
-  exports2.updateComponentAttachments = updateComponentAttachments;
-  exports2.updateComponentTypeAttachment = updateComponentTypeAttachment;
-  exports2.updateComponentTypeAttachments = updateComponentTypeAttachments;
+  exports2.updateAsset = updateAsset;
+  exports2.updateAssetAttachment = updateAssetAttachment;
+  exports2.updateAssetAttachments = updateAssetAttachments;
+  exports2.updateAssetTypeAttachment = updateAssetTypeAttachment;
+  exports2.updateAssetTypeAttachments = updateAssetTypeAttachments;
+  exports2.updateConversation = updateConversation;
   exports2.updateDocumentAttachment = updateDocumentAttachment;
   exports2.updateDocumentAttachments = updateDocumentAttachments;
   exports2.updateDocuments = updateDocuments;