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

package/dist/overmap-core.js

@@ -678,15 +678,15 @@ const wrapMigration = (migrator) => (state) => {
 };
 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 = 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;
@@ -1384,7 +1384,7 @@ const ColorsToString = {
   [mint.mint9]: "mint",
   [sky.sky9]: "sky"
 };
-const ComponentStageColors = {
+const AssetStageColors = {
   indigo: indigo.indigo9,
   red: red.red9,
   violet: violet.violet9,
@@ -1406,7 +1406,7 @@ const generateBadgeColors = (rawColor) => {
   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)
@@ -1430,7 +1430,7 @@ const getLocalRelativeDateString = memoize((date, min, max) => {
     return getLocalDateString(date);
   return relative.format(days, "days");
 });
-const initialState$q = {
+const initialState$r = {
   categories: {},
   usedCategoryColors: [],
   categoryVisibility: {
@@ -1440,8 +1440,8 @@ const initialState$q = {
 };
 const categorySlice = 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))
@@ -1625,167 +1625,274 @@ function removeAttachments(state, action) {
     delete state.attachments[attachmentId];
   }
 }
+const initialState$q = {
+  assetTypes: {},
+  hiddenAssetTypeIds: {},
+  attachments: {}
+};
+const assetTypeSlice = 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 = createSelector(
+  [selectAssetTypesMapping],
+  (mapping) => Object.values(mapping)
+);
+const selectAssetType = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectAssetTypesMapping, (_state, assetTypeId) => assetTypeId],
+    (mapping, assetTypeId) => mapping[assetTypeId]
+  )
+);
+const selectNumberOfAssetTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectAssetTypesMapping, (_state, args) => args],
+    (mapping, args) => {
+      var _a2;
+      const name = ((_a2 = args.name) == null ? void 0 : _a2.toLowerCase()) ?? null;
+      return Object.values(mapping).filter(
+        (assetType) => {
+          var _a3;
+          return (((_a3 = assetType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && assetType.offline_id !== args.assetTypeId;
+        }
+      ).length;
+    }
+  )
+);
+const selectAssetTypesByName = restructureCreateSelectorWithArgs(
+  createSelector([selectAssetTypesMapping, (_state, name) => name], (mapping, name) => {
+    name = (name == null ? void 0 : name.toLowerCase()) ?? null;
+    return Object.values(mapping).filter((assetType) => {
+      var _a2;
+      return (((_a2 = assetType.name) == null ? void 0 : _a2.toLowerCase()) ?? null) === name;
+    });
+  })
+);
+const selectHiddenAssetTypeIds = (state) => state.assetTypeReducer.hiddenAssetTypeIds;
+const selectAssetTypeAttachmentMapping = (state) => state.assetTypeReducer.attachments;
+const selectAssetTypeAttachments = createSelector(
+  [selectAssetTypeAttachmentMapping],
+  (mapping) => Object.values(mapping)
+);
+const selectAssetTypeAttachment = (attachmentId) => (state) => {
+  return state.assetTypeReducer.attachments[attachmentId];
+};
+const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+    (attachments, assetTypeId) => {
+      return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
+    }
+  )
+);
+const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
+  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 = createSlice({
-  name: "components",
+const assetSlice = 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(
+  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 = 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(
-  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 = createSelector(
-  [selectComponentAttachmentMapping],
+const selectAssetAttachmentMapping = (state) => state.assetReducer.attachments;
+const selectAssetAttachments = 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(
   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(
   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/")
       );
@@ -1793,69 +1900,67 @@ const selectAttachmentsOfComponentByType = restructureCreateSelectorWithArgs(
     }
   )
 );
-const componentReducer = componentSlice.reducer;
+const assetReducer = assetSlice.reducer;
 const initialState$o = {
-  completionsByComponentId: {}
+  completionsByAssetId: {}
 };
-const componentStageCompletionSlice = createSlice({
-  name: "componentStageCompletions",
+const assetStageCompletionSlice = 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 = createSlice({
-  name: "componentStages",
+const assetStageSlice = createSlice({
+  name: "assetStages",
   initialState: initialState$n,
   extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$n)),
   reducers: {
@@ -1890,60 +1995,48 @@ const componentStageSlice = createSlice({
     }
   }
 });
-const selectStageMapping = (state) => state.componentStageReducer.stages;
+const selectStageMapping = (state) => state.assetStageReducer.stages;
 const selectStage = restructureCreateSelectorWithArgs(
   createSelector([selectStageMapping, (_state, stageId) => stageId], (stageMapping, stageId) => {
     return stageMapping[stageId];
   })
 );
-const selectStages = createSelector(
-  [selectStageMapping],
-  (stageMapping) => {
-    return Object.values(stageMapping);
-  }
-);
-const selectStagesFromComponentTypeIds = restructureCreateSelectorWithArgs(
-  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 = createSelector([selectStageMapping], (stageMapping) => {
+  return Object.values(stageMapping);
+});
+const selectStagesFromAssetTypeIds = restructureCreateSelectorWithArgs(
+  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(
-  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(
+  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(
-  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(
+  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(
   createSelector([selectStageMapping, (_state, stageIds) => stageIds], (stageMapping, stageIds) => {
@@ -1965,140 +2058,15 @@ const selectStageFormIdsFromStageIds = restructureCreateSelectorWithArgs(
     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 = 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 = createSelector(
-  [selectComponentTypesMapping],
-  (mapping) => Object.values(mapping)
-);
-const selectComponentType = restructureCreateSelectorWithArgs(
-  createSelector([selectComponentTypesMapping, (_state, id) => id], (mapping, id) => mapping[id])
-);
-const selectNumberOfComponentTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
-  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(
-  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 = createSelector(
-  [selectComponentTypeAttachmentMapping],
-  (mapping) => Object.values(mapping)
-);
-const selectComponentTypeAttachment = (attachmentId) => (state) => {
-  return state.componentTypeReducer.attachments[attachmentId];
-};
-const selectAttachmentsOfComponentType = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectAllComponentTypeAttachments, (_state, componentTypeId) => componentTypeId],
-    (attachments, componentTypeId) => {
-      return attachments.filter(({ component_type }) => componentTypeId === component_type);
-    }
-  )
-);
-const selectAttachmentsOfComponentTypeByType = restructureCreateSelectorWithArgs(
-  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 = createSlice({
   name: "workspace",
-  initialState: initialState$l,
+  initialState: initialState$m,
   // The `reducers` field lets us define reducers and generate associated actions
   reducers: {
     setWorkspaces: (state, action) => {
@@ -2155,7 +2123,7 @@ const selectPermittedWorkspaceIds = createSelector(
 );
 const workspaceReducer = workspaceSlice.reducer;
 const maxRecentIssues = 10;
-const initialState$k = {
+const initialState$l = {
   issues: {},
   attachments: {},
   comments: {},
@@ -2167,9 +2135,9 @@ const initialState$k = {
 };
 const issueSlice = 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) => {
@@ -2602,14 +2570,14 @@ const selectRecentIssuesAsSearchResults = createSelector(
   }
 );
 const issueReducer = issueSlice.reducer;
-const initialState$j = {
+const initialState$k = {
   issueTypes: {}
 };
 const issueTypeSlice = 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) => {
@@ -2676,15 +2644,15 @@ const selectIssuesOfIssueTypeCount = (issueTypeId) => (state) => {
   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 = 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;
@@ -2711,7 +2679,7 @@ const selectUploadUrl = (sha1) => (state) => {
   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,
@@ -2719,8 +2687,8 @@ const initialState$h = {
 };
 const mapSlice = 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;
@@ -2750,8 +2718,8 @@ var OrganizationAccessLevel = /* @__PURE__ */ ((OrganizationAccessLevel2) => {
 })(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;
@@ -2797,7 +2765,7 @@ var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
   LicenseStatus2[LicenseStatus2["PAST_DUE"] = 8] = "PAST_DUE";
   return LicenseStatus2;
 })(LicenseStatus || {});
-const initialState$g = {
+const initialState$h = {
   users: {},
   currentUser: {
     id: 0,
@@ -2808,8 +2776,8 @@ const initialState$g = {
 };
 const userSlice = 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 = {};
@@ -2871,13 +2839,13 @@ const selectUser = (userId) => (state) => {
 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 = 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))
@@ -2940,13 +2908,13 @@ const selectOrganizationAccessUserMapping = (state) => {
   return organizationAccesses;
 };
 const organizationAccessReducer = organizationAccessSlice.reducer;
-const initialState$e = {
+const initialState$f = {
   licenses: {}
 };
 const licenseSlice = 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))
@@ -2991,13 +2959,13 @@ const selectLicensesForProjectsMapping = createSelector(
   (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 = 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))
@@ -3065,7 +3033,7 @@ const selectProjectAccessUserMapping = (state) => {
   return projectAccesses;
 };
 const projectAccessReducer = projectAccessSlice.reducer;
-const initialState$c = {
+const initialState$d = {
   projects: {},
   activeProjectId: null,
   recentProjectIds: [],
@@ -3075,7 +3043,7 @@ const initialState$c = {
 };
 const projectSlice = createSlice({
   name: "projects",
-  initialState: initialState$c,
+  initialState: initialState$d,
   reducers: {
     setProjects: (state, action) => {
       const projectsMap = {};
@@ -3269,14 +3237,14 @@ const selectAttachmentsOfProjectByType = restructureCreateSelectorWithArgs(
     }
   )
 );
-const initialState$b = {
+const initialState$c = {
   organizations: {},
   activeOrganizationId: null
 };
 const organizationSlice = 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) {
@@ -3395,14 +3363,14 @@ const createOfflineAction = (request2, baseUrl) => {
     }
   };
 };
-const initialState$a = {
+const initialState$b = {
   deletedRequests: [],
   latestRetryTime: 0
 };
 const outboxSlice = 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
@@ -3434,7 +3402,7 @@ const selectDeletedRequests = (state) => state.outboxReducer.deletedRequests;
 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,
@@ -3442,8 +3410,8 @@ const initialState$9 = {
 };
 const projectFileSlice = 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) {
@@ -3544,12 +3512,12 @@ const selectProjectFiles = createSelector(
 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 = createSlice({
   name: "rehydrated",
-  initialState: initialState$8,
+  initialState: initialState$9,
   // The `reducers` field lets us define reducers and generate associated actions
   reducers: {
     setRehydrated: (state, action) => {
@@ -3559,11 +3527,12 @@ const rehydratedSlice = createSlice({
 });
 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,
@@ -3576,8 +3545,8 @@ const initialState$7 = {
 };
 const settingSlice = 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;
@@ -3636,14 +3605,14 @@ const formRevisionSortFn = (formRevisionA, formRevisionB) => {
     return revisionA < revisionB ? -1 : 1;
   }
 };
-const initialState$6 = {
+const initialState$7 = {
   formRevisions: {},
   attachments: {}
 };
 const formRevisionsSlice = 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) => {
@@ -3774,27 +3743,27 @@ const selectFormRevisionsOfForm = restructureCreateSelectorWithArgs(
     });
   })
 );
-const selectLatestFormRevisionsOfComponentTypes = restructureCreateSelectorWithArgs(
+const selectLatestFormRevisionsOfAssetTypes = restructureCreateSelectorWithArgs(
   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;
     }
@@ -3823,13 +3792,13 @@ const selectAttachmentsOfFormRevision = restructureCreateSelectorWithArgs(
   )
 );
 const formRevisionReducer = formRevisionsSlice.reducer;
-const initialState$5 = {
+const initialState$6 = {
   forms: {}
 };
 const formSlice = 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 = {};
@@ -3911,11 +3880,11 @@ const selectForm = (formId2) => (state) => {
 const selectFormMapping = (state) => {
   return state.formReducer.forms;
 };
-const selectFormOfComponentType = restructureCreateSelectorWithArgs(
+const selectFormOfAssetType = restructureCreateSelectorWithArgs(
   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);
     }
   )
 );
@@ -3931,17 +3900,17 @@ const selectFormsCount = createSelector([selectFormMapping], (userForms) => {
   return Object.keys(userForms).length;
 });
 const selectGeneralFormCount = 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 = 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;
@@ -4139,31 +4108,31 @@ const selectFormSubmissionsOfIssue = restructureCreateSelectorWithArgs(
     }
   )
 );
-const selectFormSubmissionsOfComponent = restructureCreateSelectorWithArgs(
+const selectFormSubmissionsOfAsset = restructureCreateSelectorWithArgs(
   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 = createSelector(
-  [selectFormSubmissionsMapping, selectComponentsMapping],
-  (submissions, components) => {
+const selectFormSubmissionsByAssets = 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) => {
@@ -4178,12 +4147,12 @@ const selectAttachmentsOfFormSubmission = restructureCreateSelectorWithArgs(
   )
 );
 const formSubmissionReducer = formSubmissionSlice.reducer;
-const initialState$3 = {
+const initialState$4 = {
   emailDomains: {}
 };
 const emailDomainsSlice = createSlice({
   name: "emailDomains",
-  initialState: initialState$3,
+  initialState: initialState$4,
   reducers: {
     setEmailDomains: (state, action) => {
       const emailDomains = {};
@@ -4210,15 +4179,15 @@ const selectSortedEmailDomains = (state) => Object.values(state.emailDomainsRedu
   (ed1, ed2) => ed1.domain.localeCompare(ed2.domain)
 );
 const emailDomainsReducer = emailDomainsSlice.reducer;
-const initialState$2 = {
+const initialState$3 = {
   documents: {},
   attachments: {}
 };
 const documentSlice = 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) => {
@@ -4449,13 +4418,13 @@ const selectAttachmentsOfDocumentByType = restructureCreateSelectorWithArgs(
   )
 );
 const documentsReducer = documentSlice.reducer;
-const initialState$1 = {
+const initialState$2 = {
   teams: {}
 };
 const teamSlice = 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;
@@ -4505,6 +4474,54 @@ const selectTeamsOfUser = restructureCreateSelectorWithArgs(
   })
 );
 const teamReducer = teamSlice.reducer;
+const initialState$1 = {
+  conversations: {}
+};
+const agentsSlice = 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 = createSelector(
+  [selectConversationMapping],
+  (conversationMapping) => Object.values(conversationMapping)
+);
+const selectConversation = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectConversationMapping, (_state, conversationId) => conversationId],
+    (conversationMapping, conversationId) => conversationMapping[conversationId]
+  )
+);
+const agentsReducer = agentsSlice.reducer;
 const initialState = {
   version: 0
 };
@@ -4514,7 +4531,7 @@ const versioningSlice = createSlice({
   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;
@@ -4532,10 +4549,10 @@ const overmapReducers = {
   fileReducer,
   authReducer,
   categoryReducer,
-  componentReducer,
-  componentStageCompletionReducer,
-  componentStageReducer,
-  componentTypeReducer,
+  assetReducer,
+  assetStageCompletionReducer,
+  assetStageReducer,
+  assetTypeReducer,
   issueReducer,
   issueTypeReducer,
   mapReducer,
@@ -4555,7 +4572,8 @@ const overmapReducers = {
   emailDomainsReducer,
   licenseReducer,
   documentsReducer,
-  teamReducer
+  teamReducer,
+  agentsReducer
 };
 const overmapReducer = combineReducers(overmapReducers);
 const resetStore = "RESET";
@@ -5315,6 +5333,9 @@ class AuthService extends BaseApiService {
   }
   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,
@@ -5433,244 +5454,234 @@ class CategoryService extends BaseApiService {
     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(
@@ -5681,13 +5692,13 @@ class ComponentStageService extends BaseApiService {
     }
     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));
@@ -5697,9 +5708,9 @@ class ComponentStageService extends BaseApiService {
   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
       },
@@ -5707,15 +5718,15 @@ class ComponentStageService extends BaseApiService {
       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) {
@@ -5723,9 +5734,9 @@ class ComponentStageService extends BaseApiService {
     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]
@@ -5740,9 +5751,9 @@ class ComponentStageService extends BaseApiService {
     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]
       });
@@ -5754,9 +5765,9 @@ class ComponentStageService extends BaseApiService {
   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: []
     });
@@ -5770,20 +5781,20 @@ const AttachmentModelMeta = {
     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"
@@ -5799,8 +5810,8 @@ class BaseAttachmentService extends BaseApiService {
   getNumberOfAttachmentsWithSha1(sha1) {
     const {
       issueReducer: issueReducer2,
-      componentReducer: componentReducer2,
-      componentTypeReducer: componentTypeReducer2,
+      assetReducer: assetReducer2,
+      assetTypeReducer: assetTypeReducer2,
       documentsReducer: documentsReducer2,
       projectReducer: projectReducer2,
       formSubmissionReducer: formSubmissionReducer2,
@@ -5808,8 +5819,8 @@ class BaseAttachmentService extends BaseApiService {
     } = 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),
@@ -5931,10 +5942,10 @@ class BaseAttachmentService extends BaseApiService {
     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({
@@ -5945,115 +5956,108 @@ class ComponentAttachmentService extends BaseAttachmentService {
       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`);
     }
-    if (attachmentsOfComponentType.length > 0) {
-      const attachmentsOfComponentTypeIds = attachmentsOfComponentType.map(({ offline_id }) => offline_id);
-      store.dispatch(removeComponentTypeAttachments(attachmentsOfComponentTypeIds));
+    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 (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({
@@ -6064,36 +6068,36 @@ class ComponentTypeAttachmentService extends BaseAttachmentService {
       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
     });
   }
 }
@@ -6284,7 +6288,8 @@ class IssueService extends BaseApiService {
       if (error2 instanceof APIError) {
         (_a2 = unsafeShowToast) == null ? void 0 : _a2({
           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));
@@ -6555,7 +6560,7 @@ class MainService extends BaseApiService {
     if (replaceExisting) {
       this.client.store.dispatch(setIsFetchingInitialData(true));
     }
-    return this.enqueueRequest({
+    const result = await this.enqueueRequest({
       uuid,
       description: "Get initial data",
       method: HttpMethod.GET,
@@ -6564,18 +6569,20 @@ class MainService extends BaseApiService {
       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) {
@@ -6588,13 +6595,14 @@ class MainService extends BaseApiService {
     });
   }
   // 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(
@@ -6618,18 +6626,11 @@ class MainService extends BaseApiService {
         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));
@@ -6650,8 +6651,11 @@ class MainService extends BaseApiService {
       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) {
@@ -6661,12 +6665,6 @@ class MainService extends BaseApiService {
         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;
           }
         }
@@ -6675,14 +6673,6 @@ class MainService extends BaseApiService {
         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) {
@@ -6690,51 +6680,49 @@ class MainService extends BaseApiService {
     } 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 {
@@ -6774,16 +6762,11 @@ class ProjectAccessService extends BaseApiService {
     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));
   }
 }
@@ -7133,7 +7116,7 @@ class UserFormService extends BaseApiService {
       });
     });
   }
-  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.");
     }
@@ -7152,7 +7135,7 @@ class UserFormService extends BaseApiService {
       favorite: true,
       submitted_at: submittedAt,
       created_by: currentUser.id,
-      ...componentTypeId && { component_type: componentTypeId },
+      ...assetTypeId && { asset_type: assetTypeId },
       ...issueTypeId && { issue_type: issueTypeId },
       ...ownerAttrs
     };
@@ -7176,11 +7159,11 @@ class UserFormService extends BaseApiService {
       } : 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);
@@ -7204,7 +7187,7 @@ class UserFormService extends BaseApiService {
       `/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
     );
   }
@@ -7217,7 +7200,7 @@ class UserFormService extends BaseApiService {
       "/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
     );
   }
@@ -7385,8 +7368,8 @@ class UserFormSubmissionService extends BaseApiService {
             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),
@@ -7422,7 +7405,7 @@ class UserFormSubmissionService extends BaseApiService {
       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]
@@ -7440,10 +7423,10 @@ class UserFormSubmissionService extends BaseApiService {
     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 = [];
@@ -7453,16 +7436,16 @@ class UserFormSubmissionService extends BaseApiService {
     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) {
@@ -7509,7 +7492,7 @@ class UserFormSubmissionService extends BaseApiService {
         attachments: attachmentsPayload,
         files: Object.values(filesRecord)
       },
-      blockers: componentOfflineIds,
+      blockers: assetOfflineIds,
       blocks: submissionOfflineIds
     });
     promise.then(({ submissions, attachments, presigned_urls }) => {
@@ -7552,7 +7535,7 @@ class UserFormSubmissionService extends BaseApiService {
       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]
@@ -8361,24 +8344,70 @@ class DocumentAttachmentService extends BaseAttachmentService {
   }
 }
 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) {
@@ -8391,6 +8420,18 @@ class AgentService extends BaseApiService {
       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) {
@@ -8546,12 +8587,12 @@ class OvermapSDK {
     __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));
@@ -15182,9 +15223,9 @@ const FormBrowser = memo(
     }, [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 = useCallback(
       (form) => {
@@ -16589,6 +16630,13 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
 export {
   APIError,
   AgentService,
+  AssetAttachmentService,
+  AssetService,
+  AssetStageColors,
+  AssetStageCompletionService,
+  AssetStageService,
+  AssetTypeAttachmentService,
+  AssetTypeService,
   AttachmentModel,
   AuthService,
   BaseApiService,
@@ -16600,13 +16648,6 @@ export {
   ColorPicker,
   Colors,
   ColorsToString,
-  ComponentAttachmentService,
-  ComponentService,
-  ComponentStageColors,
-  ComponentStageCompletionService,
-  ComponentStageService,
-  ComponentTypeAttachmentService,
-  ComponentTypeService,
   DEFAULT_ISSUE_PRIORITY,
   DEFAULT_ISSUE_STATUS,
   DateField,
@@ -16698,14 +16739,15 @@ export {
   acceptProjectInvite,
   addActiveProjectFormSubmissionsCount,
   addActiveProjectIssuesCount,
+  addAsset,
+  addAssetAttachment,
+  addAssetAttachments,
+  addAssetType,
+  addAssetTypeAttachment,
+  addAssetTypeAttachments,
+  addAssetsInBatches,
   addCategory,
-  addComponent,
-  addComponentAttachment,
-  addComponentAttachments,
-  addComponentType,
-  addComponentTypeAttachment,
-  addComponentTypeAttachments,
-  addComponentsInBatches,
+  addConversation,
   addDocumentAttachment,
   addDocumentAttachments,
   addDocuments,
@@ -16746,7 +16788,17 @@ export {
   addToRecentIssues,
   addUsers,
   addWorkspace,
+  agentsReducer,
+  agentsSlice,
   areArraysEqual,
+  assetReducer,
+  assetSlice,
+  assetStageCompletionReducer,
+  assetStageCompletionSlice,
+  assetStageReducer,
+  assetStageSlice,
+  assetTypeReducer,
+  assetTypeSlice,
   authReducer,
   authSlice,
   blobToBase64,
@@ -16756,14 +16808,6 @@ export {
   classNames$1 as classNames,
   cleanRecentIssues,
   clearTokens,
-  componentReducer,
-  componentSlice,
-  componentStageCompletionReducer,
-  componentStageCompletionSlice,
-  componentStageReducer,
-  componentStageSlice,
-  componentTypeReducer,
-  componentTypeSlice,
   constructUploadedFilePayloads,
   coordinatesAreEqual,
   coordinatesToLiteral,
@@ -16774,7 +16818,7 @@ export {
   createPointMarker,
   defaultBadgeColor,
   defaultStore,
-  deleteComponentType,
+  deleteAssetType,
   deleteForm,
   deleteFormRevision,
   deleteFormRevisionAttachment,
@@ -16823,7 +16867,7 @@ export {
   formSubmissionReducer,
   formSubmissionSlice,
   index as forms,
-  fullComponentMarkerSize,
+  fullAssetMarkerSize,
   generateBadgeColors,
   genericMemo,
   getFileIdentifier,
@@ -16883,15 +16927,15 @@ export {
   projectSlice,
   rehydratedReducer,
   rehydratedSlice,
-  removeAllComponentsOfType,
+  removeAllAssetsOfType,
+  removeAsset,
+  removeAssetAttachment,
+  removeAssetAttachments,
+  removeAssetTypeAttachment,
+  removeAssetTypeAttachments,
   removeAttachmentsOfIssue,
   removeCategory,
   removeColor,
-  removeComponent,
-  removeComponentAttachment,
-  removeComponentAttachments,
-  removeComponentTypeAttachment,
-  removeComponentTypeAttachments,
   removeDocumentAttachment,
   removeDocumentAttachments,
   removeDocuments,
@@ -16942,16 +16986,31 @@ export {
   selectActiveWorkspace,
   selectActiveWorkspaceId,
   selectAllAttachments,
-  selectAllComponentAttachments,
-  selectAllComponentTypeAttachments,
   selectAllDocumentAttachments,
   selectAllProjectAttachments,
   selectAncestorIdsOfDocument,
   selectAppearance,
-  selectAttachmentsOfComponent,
-  selectAttachmentsOfComponentByType,
-  selectAttachmentsOfComponentType,
-  selectAttachmentsOfComponentTypeByType,
+  selectAsset,
+  selectAssetAttachment,
+  selectAssetAttachmentMapping,
+  selectAssetAttachments,
+  selectAssetToAssetTypeMapping,
+  selectAssetType,
+  selectAssetTypeAttachment,
+  selectAssetTypeAttachmentMapping,
+  selectAssetTypeAttachments,
+  selectAssetTypeStagesMapping,
+  selectAssetTypes,
+  selectAssetTypesByName,
+  selectAssetTypesFromIds,
+  selectAssetTypesMapping,
+  selectAssets,
+  selectAssetsMapping,
+  selectAssetsOfAssetType,
+  selectAttachmentsOfAsset,
+  selectAttachmentsOfAssetType,
+  selectAttachmentsOfAssetTypeByType,
+  selectAttachmentsOfAssetsByType,
   selectAttachmentsOfDocument,
   selectAttachmentsOfDocumentByType,
   selectAttachmentsOfFormRevision,
@@ -16968,25 +17027,11 @@ export {
   selectCenterMapToProject,
   selectCommentMapping,
   selectCommentsOfIssue,
-  selectCompletedStageIdsForComponent,
+  selectCompletedStageIdsForAsset,
   selectCompletedStages,
-  selectComponent,
-  selectComponentAttachment,
-  selectComponentAttachmentMapping,
-  selectComponentType,
-  selectComponentTypeAttachment,
-  selectComponentTypeAttachmentMapping,
-  selectComponentTypeFromComponent,
-  selectComponentTypeFromComponents,
-  selectComponentTypeStagesMapping,
-  selectComponentTypes,
-  selectComponentTypesByName,
-  selectComponentTypesFromIds,
-  selectComponentTypesMapping,
-  selectComponents,
-  selectComponentsByType,
-  selectComponentsFromComponentType,
-  selectComponentsMapping,
+  selectConversation,
+  selectConversationMapping,
+  selectConversations,
   selectCreateProjectType,
   selectCurrentUser,
   selectDeletedRequests,
@@ -17008,7 +17053,7 @@ export {
   selectFilteredForms,
   selectForm,
   selectFormMapping,
-  selectFormOfComponentType,
+  selectFormOfAssetType,
   selectFormOfIssueType,
   selectFormRevision,
   selectFormRevisionMapping,
@@ -17017,16 +17062,16 @@ export {
   selectFormSubmission,
   selectFormSubmissionAttachmentsMapping,
   selectFormSubmissions,
-  selectFormSubmissionsByComponents,
+  selectFormSubmissionsByAssets,
   selectFormSubmissionsByFormRevisions,
   selectFormSubmissionsMapping,
-  selectFormSubmissionsOfComponent,
+  selectFormSubmissionsOfAsset,
   selectFormSubmissionsOfForm,
   selectFormSubmissionsOfIssue,
   selectFormsCount,
   selectGeneralFormCount,
+  selectHiddenAssetTypeIds,
   selectHiddenCategoryCount,
-  selectHiddenComponentTypeIds,
   selectIsFetchingInitialData,
   selectIsImportingProjectFile,
   selectIsLoading,
@@ -17048,7 +17093,7 @@ export {
   selectIssuesOfIssueTypeCount,
   selectLatestFormRevisionByForm,
   selectLatestFormRevisionOfForm,
-  selectLatestFormRevisionsOfComponentTypes,
+  selectLatestFormRevisionsOfAssetTypes,
   selectLatestRetryTime,
   selectLicense,
   selectLicenseForProject,
@@ -17056,8 +17101,8 @@ export {
   selectLicensesForProjectsMapping,
   selectMainWorkspace,
   selectMapStyle,
-  selectNumberOfComponentTypesMatchingCaseInsensitiveName,
-  selectNumberOfComponentsOfComponentType,
+  selectNumberOfAssetTypesMatchingCaseInsensitiveName,
+  selectNumberOfAssetsOfAssetType,
   selectOrganization,
   selectOrganizationAccess,
   selectOrganizationAccessForUser,
@@ -17098,9 +17143,9 @@ export {
   selectStageFormIdsFromStageIds,
   selectStageMapping,
   selectStages,
-  selectStagesFromComponentType,
-  selectStagesFromComponentTypeIds,
+  selectStagesFromAssetTypeIds,
   selectStagesFromStageIds,
+  selectStagesOfAssetType,
   selectTeam,
   selectTeams,
   selectTeamsMapping,
@@ -17122,14 +17167,16 @@ export {
   setActiveProjectId,
   setActiveWorkspaceId,
   setAppearance,
+  setAssetAttachment,
+  setAssetAttachments,
+  setAssetTypeAttachment,
+  setAssetTypeAttachments,
+  setAssetTypes,
+  setAssets,
   setCategories,
   setCenterMapToProject,
-  setComponentAttachment,
-  setComponentAttachments,
-  setComponentTypeAttachment,
-  setComponentTypeAttachments,
-  setComponentTypes,
-  setComponents,
+  setConversation,
+  setConversations,
   setCreateProjectType,
   setCurrentUser,
   setDocumentAttachment,
@@ -17190,18 +17237,19 @@ export {
   teamSlice,
   toFileNameSafeString,
   toOfflineIdRecord,
-  toggleComponentTypeVisibility,
+  toggleAssetTypeVisibility,
   truncate,
   unfavoriteForm,
   unhideAllCategories,
   unhideCategory,
   unlinkStageToForm,
   updateActiveOrganization,
-  updateComponent,
-  updateComponentAttachment,
-  updateComponentAttachments,
-  updateComponentTypeAttachment,
-  updateComponentTypeAttachments,
+  updateAsset,
+  updateAssetAttachment,
+  updateAssetAttachments,
+  updateAssetTypeAttachment,
+  updateAssetTypeAttachments,
+  updateConversation,
   updateDocumentAttachment,
   updateDocumentAttachments,
   updateDocuments,