@overmap-ai/core 1.0.55 → 1.0.57-component-asset-renames.0

package/dist/overmap-core.js

@@ -1350,7 +1350,7 @@ const ColorsToString = {
   [mint.mint9]: "mint",
   [sky.sky9]: "sky"
 };
-const ComponentStageColors = {
+const AssetStageColors = {
   indigo: indigo.indigo9,
   red: red.red9,
   violet: violet.violet9,
@@ -1372,7 +1372,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)
@@ -1592,122 +1592,115 @@ function removeAttachments(state, action) {
   }
 }
 const initialState$q = {
-  componentTypes: {},
-  hiddenComponentTypeIds: {},
+  assetTypes: {},
+  hiddenAssetTypeIds: {},
   attachments: {}
 };
-const componentTypeSlice = createSlice({
-  name: "componentTypes",
+const assetTypeSlice = createSlice({
+  name: "assetTypes",
   initialState: initialState$q,
   extraReducers: (builder) => builder.addCase("RESET", (state) => Object.assign(state, initialState$q)),
   reducers: {
-    addComponentType: (state, action) => {
-      state.componentTypes[action.payload.offline_id] = action.payload;
+    addAssetType: (state, action) => {
+      state.assetTypes[action.payload.offline_id] = action.payload;
     },
-    setComponentTypes: (state, action) => {
-      state.componentTypes = toOfflineIdRecord(action.payload);
+    setAssetTypes: (state, action) => {
+      state.assetTypes = toOfflineIdRecord(action.payload);
     },
-    toggleComponentTypeVisibility: (state, action) => {
-      state.hiddenComponentTypeIds[action.payload] = !state.hiddenComponentTypeIds[action.payload];
+    toggleAssetTypeVisibility: (state, action) => {
+      state.hiddenAssetTypeIds[action.payload] = !state.hiddenAssetTypeIds[action.payload];
     },
-    deleteComponentType: (state, action) => {
-      delete state.componentTypes[action.payload];
+    deleteAssetType: (state, action) => {
+      delete state.assetTypes[action.payload];
     },
     // Attachments
-    setComponentTypeAttachment: setAttachment,
-    setComponentTypeAttachments: setAttachments,
-    addComponentTypeAttachment: addAttachment,
-    addComponentTypeAttachments: addAttachments,
-    updateComponentTypeAttachment: updateAttachment,
-    updateComponentTypeAttachments: updateAttachments,
-    removeComponentTypeAttachment: removeAttachment,
-    removeComponentTypeAttachments: removeAttachments
+    setAssetTypeAttachment: setAttachment,
+    setAssetTypeAttachments: setAttachments,
+    addAssetTypeAttachment: addAttachment,
+    addAssetTypeAttachments: addAttachments,
+    updateAssetTypeAttachment: updateAttachment,
+    updateAssetTypeAttachments: updateAttachments,
+    removeAssetTypeAttachment: removeAttachment,
+    removeAssetTypeAttachments: removeAttachments
   }
 });
 const {
-  addComponentType,
-  setComponentTypes,
-  toggleComponentTypeVisibility,
-  deleteComponentType,
+  addAssetType,
+  setAssetTypes,
+  toggleAssetTypeVisibility,
+  deleteAssetType,
   // Attachmet
-  setComponentTypeAttachment,
-  setComponentTypeAttachments,
-  addComponentTypeAttachment,
-  addComponentTypeAttachments,
-  updateComponentTypeAttachment,
-  updateComponentTypeAttachments,
-  removeComponentTypeAttachment,
-  removeComponentTypeAttachments
-} = componentTypeSlice.actions;
-const selectComponentTypesMapping = (state) => state.componentTypeReducer.componentTypes;
-const selectComponentTypes = createSelector(
-  [selectComponentTypesMapping],
+  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 selectComponentType = restructureCreateSelectorWithArgs(
-  createSelector([selectComponentTypesMapping, (_state, id) => id], (mapping, id) => mapping[id])
+const selectAssetType = restructureCreateSelectorWithArgs(
+  createSelector(
+    [selectAssetTypesMapping, (_state, assetTypeId) => assetTypeId],
+    (mapping, assetTypeId) => mapping[assetTypeId]
+  )
 );
-const selectNumberOfComponentTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
+const selectNumberOfAssetTypesMatchingCaseInsensitiveName = restructureCreateSelectorWithArgs(
   createSelector(
-    [
-      selectComponentTypesMapping,
-      (_state, args) => args
-    ],
+    [selectAssetTypesMapping, (_state, args) => args],
     (mapping, args) => {
       var _a2;
       const name = ((_a2 = args.name) == null ? void 0 : _a2.toLowerCase()) ?? null;
       return Object.values(mapping).filter(
-        (componentType) => {
+        (assetType) => {
           var _a3;
-          return (((_a3 = componentType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && componentType.offline_id !== args.componentTypeId;
+          return (((_a3 = assetType.name) == null ? void 0 : _a3.toLowerCase()) ?? null) === name && assetType.offline_id !== args.assetTypeId;
         }
       ).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 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 selectHiddenComponentTypeIds = (state) => state.componentTypeReducer.hiddenComponentTypeIds;
-const selectComponentTypeAttachmentMapping = (state) => state.componentTypeReducer.attachments;
-const selectAllComponentTypeAttachments = createSelector(
-  [selectComponentTypeAttachmentMapping],
+const selectHiddenAssetTypeIds = (state) => state.assetTypeReducer.hiddenAssetTypeIds;
+const selectAssetTypeAttachmentMapping = (state) => state.assetTypeReducer.attachments;
+const selectAssetTypeAttachments = createSelector(
+  [selectAssetTypeAttachmentMapping],
   (mapping) => Object.values(mapping)
 );
-const selectComponentTypeAttachment = (attachmentId) => (state) => {
-  return state.componentTypeReducer.attachments[attachmentId];
+const selectAssetTypeAttachment = (attachmentId) => (state) => {
+  return state.assetTypeReducer.attachments[attachmentId];
 };
-const selectAttachmentsOfComponentType = restructureCreateSelectorWithArgs(
+const selectAttachmentsOfAssetType = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectAllComponentTypeAttachments, (_state, componentTypeId) => componentTypeId],
-    (attachments, componentTypeId) => {
-      return attachments.filter(({ component_type }) => componentTypeId === component_type);
+    [selectAssetTypeAttachments, (_state, assetTypeId) => assetTypeId],
+    (attachments, assetTypeId) => {
+      return attachments.filter(({ asset_type }) => assetTypeId === asset_type);
     }
   )
 );
-const selectAttachmentsOfComponentTypeByType = restructureCreateSelectorWithArgs(
+const selectAttachmentsOfAssetTypeByType = restructureCreateSelectorWithArgs(
   createSelector(
-    [selectAllComponentTypeAttachments, (_state, componentTypeId) => componentTypeId],
-    (attachments, componentTypeId) => {
-      const attachmentsOfComponent = attachments.filter(
-        ({ component_type }) => component_type === componentTypeId
-      );
-      const fileAttachments = attachmentsOfComponent.filter(
+    [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 = attachmentsOfComponent.filter(
+      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/")
       );
@@ -1715,173 +1708,157 @@ const selectAttachmentsOfComponentTypeByType = restructureCreateSelectorWithArgs
     }
   )
 );
-const componentTypeReducer = componentTypeSlice.reducer;
+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 = restructureCreateSelectorWithArgs(
-  createSelector(
-    [selectComponents, (_state, componentTypeId) => componentTypeId],
-    (components, componentTypeId) => {
-      if (!componentTypeId)
-        return [];
-      return components.filter((component) => component.component_type === 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 selectComponent = (componentId) => (state) => {
-  return state.componentReducer.components[componentId];
-};
-const selectComponentTypeFromComponent = (componentTypeId) => (state) => {
-  return state.componentTypeReducer.componentTypes[componentTypeId];
+const selectAsset = (assetId) => (state) => {
+  return state.assetReducer.assets[assetId];
 };
-const selectComponentTypeFromComponents = createSelector(
-  [selectComponents, selectComponentTypesMapping],
-  (components, componentTypeMapping) => {
+const selectAssetToAssetTypeMapping = createSelector(
+  [selectAssets, selectAssetTypesMapping],
+  (assets, assetTypeMapping) => {
     const ret = {};
-    for (const component of components) {
-      const componentType = componentTypeMapping[component.component_type];
-      if (!componentType) {
+    for (const asset of assets) {
+      const assetType = assetTypeMapping[asset.asset_type];
+      if (!assetType) {
         console.error(
-          `Component type with ID ${component.component_type} not found.
-				Expected all referenced component types to be populated.
+          `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 {};
       }
-      ret[component.offline_id] = componentType;
+      ret[asset.offline_id] = assetType;
     }
     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 selectAttachmentsOfAssetByType = 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/")
       );
@@ -1889,69 +1866,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: {
@@ -1986,60 +1961,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) => {
@@ -2061,8 +2024,8 @@ 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 = {
   workspaces: {},
   activeWorkspaceId: null
@@ -2721,8 +2684,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;
@@ -3535,6 +3498,7 @@ const initialState$8 = {
   placementMode: false,
   enableClustering: false,
   svgLayout: false,
+  // TODO: this is no longer used
   expandedSections: {
     Issues: true,
     "Map Layers": false,
@@ -3745,27 +3709,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;
     }
@@ -3882,11 +3846,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);
     }
   )
 );
@@ -3902,7 +3866,7 @@ 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$5 = {
@@ -4110,31 +4074,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) => {
@@ -4533,7 +4497,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;
@@ -4551,10 +4515,10 @@ const overmapReducers = {
   fileReducer,
   authReducer,
   categoryReducer,
-  componentReducer,
-  componentStageCompletionReducer,
-  componentStageReducer,
-  componentTypeReducer,
+  assetReducer,
+  assetStageCompletionReducer,
+  assetStageReducer,
+  assetTypeReducer,
   issueReducer,
   issueTypeReducer,
   mapReducer,
@@ -5396,110 +5360,108 @@ 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.client.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.client.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.client.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.client.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.client.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;
     });
@@ -5508,128 +5470,124 @@ class ComponentService extends BaseApiService {
   async refreshStore() {
     const { store } = this.client;
     const result = await this.client.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: []
     });
-    store.dispatch(setComponents(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.client.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.client.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.client.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.client.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.client.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(
@@ -5640,13 +5598,13 @@ class ComponentStageService extends BaseApiService {
     }
     store.dispatch(updateStages(stagesToUpdate));
     return this.client.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));
@@ -5656,9 +5614,9 @@ class ComponentStageService extends BaseApiService {
   async bulkDelete(idsToDelete) {
     this.client.store.dispatch(removeStages(idsToDelete));
     return this.client.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
       },
@@ -5666,15 +5624,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.client.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) {
@@ -5682,9 +5640,9 @@ class ComponentStageService extends BaseApiService {
     store.dispatch(linkStageToForm({ stageId, formId: formId2 }));
     try {
       await this.client.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]
@@ -5699,9 +5657,9 @@ class ComponentStageService extends BaseApiService {
     store.dispatch(unlinkStageToForm({ stageId }));
     try {
       await this.client.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]
       });
@@ -5713,9 +5671,9 @@ class ComponentStageService extends BaseApiService {
   async refreshStore() {
     const { store } = this.client;
     const result = await this.client.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: []
     });
@@ -5729,20 +5687,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"
@@ -5758,8 +5716,8 @@ class BaseAttachmentService extends BaseApiService {
   getNumberOfAttachmentsWithSha1(sha1) {
     const {
       issueReducer: issueReducer2,
-      componentReducer: componentReducer2,
-      componentTypeReducer: componentTypeReducer2,
+      assetReducer: assetReducer2,
+      assetTypeReducer: assetTypeReducer2,
       documentsReducer: documentsReducer2,
       projectReducer: projectReducer2,
       formSubmissionReducer: formSubmissionReducer2,
@@ -5767,8 +5725,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),
@@ -5890,10 +5848,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({
@@ -5904,115 +5862,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.client.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.client.enqueueRequest({
-      description: "Update ComponentType",
+      description: "Update asset type",
       method: HttpMethod.PATCH,
-      url: `/components/types/${componentType.offline_id}/`,
-      payload: componentType,
-      blockers: [componentType.offline_id],
-      blocks: [componentType.offline_id]
+      url: `/assets/types/${assetType.offline_id}/`,
+      payload: assetType,
+      blockers: [assetType.offline_id],
+      blocks: [assetType.offline_id]
     });
   }
-  async delete(componentTypeId) {
+  async delete(assetTypeId) {
     const { store } = this.client;
     const state = store.getState();
-    const componentType = selectComponentType(componentTypeId)(state);
-    if (!componentType) {
-      throw new Error("Expected componentType to exist");
-    }
-    const stagesOfComponentType = selectStagesFromComponentType(componentTypeId)(state) ?? [];
-    const attachmentsOfComponentType = selectAttachmentsOfComponentType(componentTypeId)(state);
-    store.dispatch(deleteComponentType(componentTypeId));
-    if (stagesOfComponentType.length > 0) {
-      const stagesOfComponentTypeIds = stagesOfComponentType.map(
-        (componentTypeStage) => componentTypeStage.offline_id
-      );
-      store.dispatch(removeStages(stagesOfComponentTypeIds));
+    const assetType = selectAssetType(assetTypeId)(state);
+    if (!assetType) {
+      throw new Error(`Expected asset type with offline_id ${assetTypeId} to exist`);
+    }
+    const stagesOfAssetType = selectStagesOfAssetType(assetTypeId)(state) ?? [];
+    const attachmentsOfAssetType = selectAttachmentsOfAssetType(assetTypeId)(state);
+    store.dispatch(deleteAssetType(assetTypeId));
+    if (stagesOfAssetType.length > 0) {
+      const stagesOfAssetTypeIds = stagesOfAssetType.map((assetStage) => assetStage.offline_id);
+      store.dispatch(removeStages(stagesOfAssetTypeIds));
     }
-    if (attachmentsOfComponentType.length > 0) {
-      const attachmentsOfComponentTypeIds = attachmentsOfComponentType.map(({ offline_id }) => offline_id);
-      store.dispatch(removeComponentTypeAttachments(attachmentsOfComponentTypeIds));
+    if (attachmentsOfAssetType.length > 0) {
+      const attachmentsOfAssetTypeIds = attachmentsOfAssetType.map(({ offline_id }) => offline_id);
+      store.dispatch(removeAssetTypeAttachments(attachmentsOfAssetTypeIds));
     }
     return this.client.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.client.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({
@@ -6023,36 +5974,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
     });
   }
 }
@@ -6550,8 +6501,8 @@ 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) {
@@ -6656,10 +6607,10 @@ class MainService extends BaseApiService {
       } finally {
         store.dispatch(setIsFetchingInitialData(false));
       }
-      void this.client.componentTypes.refreshStore();
-      void this.client.componentStages.refreshStore();
-      void this.client.components.refreshStore();
-      void this.client.componentStageCompletions.refreshStore();
+      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();
@@ -6674,8 +6625,8 @@ class MainService extends BaseApiService {
       void this.client.issueUpdates.refreshStore();
       void this.client.projectAccesses.refreshStore();
       void this.client.projectAttachments.refreshStore();
-      void this.client.componentTypeAttachments.refreshStore();
-      void this.client.componentAttachments.refreshStore();
+      void this.client.assetTypeAttachments.refreshStore();
+      void this.client.assetAttachments.refreshStore();
     }
     void this.client.teams.refreshStore();
   }
@@ -7071,7 +7022,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.");
     }
@@ -7090,7 +7041,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
     };
@@ -7114,11 +7065,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);
@@ -7142,7 +7093,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
     );
   }
@@ -7155,7 +7106,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
     );
   }
@@ -7323,8 +7274,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),
@@ -7360,7 +7311,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]
@@ -7378,10 +7329,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 = [];
@@ -7391,16 +7342,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) {
@@ -7447,7 +7398,7 @@ class UserFormSubmissionService extends BaseApiService {
         attachments: attachmentsPayload,
         files: Object.values(filesRecord)
       },
-      blockers: componentOfflineIds,
+      blockers: assetOfflineIds,
       blocks: submissionOfflineIds
     });
     promise.then(({ submissions, attachments, presigned_urls }) => {
@@ -7490,7 +7441,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]
@@ -8576,12 +8527,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));
@@ -15293,9 +15244,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) => {
@@ -15727,7 +15678,7 @@ const styles = {
 const formId = "form-builder";
 const fieldsToChoose = [
   ["string", "text"],
-  ["select", "multi-select", "upload"],
+  ["select", "multi-select", "upload", "qr"],
   ["boolean", "date", "number", "multi-string"]
 ];
 const CompleteFieldTypeToClsMapping = {
@@ -16700,6 +16651,13 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
 export {
   APIError,
   AgentService,
+  AssetAttachmentService,
+  AssetService,
+  AssetStageColors,
+  AssetStageCompletionService,
+  AssetStageService,
+  AssetTypeAttachmentService,
+  AssetTypeService,
   AttachmentModel,
   AuthService,
   BaseApiService,
@@ -16711,13 +16669,6 @@ export {
   ColorPicker,
   Colors,
   ColorsToString,
-  ComponentAttachmentService,
-  ComponentService,
-  ComponentStageColors,
-  ComponentStageCompletionService,
-  ComponentStageService,
-  ComponentTypeAttachmentService,
-  ComponentTypeService,
   DEFAULT_ISSUE_PRIORITY,
   DEFAULT_ISSUE_STATUS,
   DateField,
@@ -16809,14 +16760,14 @@ export {
   acceptProjectInvite,
   addActiveProjectFormSubmissionsCount,
   addActiveProjectIssuesCount,
+  addAsset,
+  addAssetAttachment,
+  addAssetAttachments,
+  addAssetType,
+  addAssetTypeAttachment,
+  addAssetTypeAttachments,
+  addAssetsInBatches,
   addCategory,
-  addComponent,
-  addComponentAttachment,
-  addComponentAttachments,
-  addComponentType,
-  addComponentTypeAttachment,
-  addComponentTypeAttachments,
-  addComponentsInBatches,
   addConversation,
   addDocumentAttachment,
   addDocumentAttachments,
@@ -16861,6 +16812,14 @@ export {
   agentsReducer,
   agentsSlice,
   areArraysEqual,
+  assetReducer,
+  assetSlice,
+  assetStageCompletionReducer,
+  assetStageCompletionSlice,
+  assetStageReducer,
+  assetStageSlice,
+  assetTypeReducer,
+  assetTypeSlice,
   authReducer,
   authSlice,
   blobToBase64,
@@ -16870,14 +16829,6 @@ export {
   classNames$1 as classNames,
   cleanRecentIssues,
   clearTokens,
-  componentReducer,
-  componentSlice,
-  componentStageCompletionReducer,
-  componentStageCompletionSlice,
-  componentStageReducer,
-  componentStageSlice,
-  componentTypeReducer,
-  componentTypeSlice,
   constructUploadedFilePayloads,
   coordinatesAreEqual,
   coordinatesToLiteral,
@@ -16888,7 +16839,7 @@ export {
   createPointMarker,
   defaultBadgeColor,
   defaultStore,
-  deleteComponentType,
+  deleteAssetType,
   deleteForm,
   deleteFormRevision,
   deleteFormRevisionAttachment,
@@ -16937,7 +16888,7 @@ export {
   formSubmissionReducer,
   formSubmissionSlice,
   index as forms,
-  fullComponentMarkerSize,
+  fullAssetMarkerSize,
   generateBadgeColors,
   genericMemo,
   getFileIdentifier,
@@ -16945,6 +16896,7 @@ export {
   getLocalDateString,
   getLocalRelativeDateString,
   getMarkerCoordinates,
+  getOutboxCoordinator,
   getRenamedFile,
   getStageColor,
   hashFile,
@@ -16997,15 +16949,15 @@ export {
   projectSlice,
   rehydratedReducer,
   rehydratedSlice,
-  removeAllComponentsOfType,
+  removeAllAssetsOfType,
+  removeAsset,
+  removeAssetAttachment,
+  removeAssetAttachments,
+  removeAssetTypeAttachment,
+  removeAssetTypeAttachments,
   removeAttachmentsOfIssue,
   removeCategory,
   removeColor,
-  removeComponent,
-  removeComponentAttachment,
-  removeComponentAttachments,
-  removeComponentTypeAttachment,
-  removeComponentTypeAttachments,
   removeDocumentAttachment,
   removeDocumentAttachments,
   removeDocuments,
@@ -17056,16 +17008,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,
+  selectAttachmentsOfAssetByType,
+  selectAttachmentsOfAssetType,
+  selectAttachmentsOfAssetTypeByType,
   selectAttachmentsOfDocument,
   selectAttachmentsOfDocumentByType,
   selectAttachmentsOfFormRevision,
@@ -17082,25 +17049,8 @@ 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,
@@ -17125,7 +17075,7 @@ export {
   selectFilteredForms,
   selectForm,
   selectFormMapping,
-  selectFormOfComponentType,
+  selectFormOfAssetType,
   selectFormOfIssueType,
   selectFormRevision,
   selectFormRevisionMapping,
@@ -17134,16 +17084,16 @@ export {
   selectFormSubmission,
   selectFormSubmissionAttachmentsMapping,
   selectFormSubmissions,
-  selectFormSubmissionsByComponents,
+  selectFormSubmissionsByAssets,
   selectFormSubmissionsByFormRevisions,
   selectFormSubmissionsMapping,
-  selectFormSubmissionsOfComponent,
+  selectFormSubmissionsOfAsset,
   selectFormSubmissionsOfForm,
   selectFormSubmissionsOfIssue,
   selectFormsCount,
   selectGeneralFormCount,
+  selectHiddenAssetTypeIds,
   selectHiddenCategoryCount,
-  selectHiddenComponentTypeIds,
   selectIsFetchingInitialData,
   selectIsImportingProjectFile,
   selectIsLoading,
@@ -17165,7 +17115,7 @@ export {
   selectIssuesOfIssueTypeCount,
   selectLatestFormRevisionByForm,
   selectLatestFormRevisionOfForm,
-  selectLatestFormRevisionsOfComponentTypes,
+  selectLatestFormRevisionsOfAssetTypes,
   selectLatestRetryTime,
   selectLicense,
   selectLicenseForProject,
@@ -17173,8 +17123,8 @@ export {
   selectLicensesForProjectsMapping,
   selectMainWorkspace,
   selectMapStyle,
-  selectNumberOfComponentTypesMatchingCaseInsensitiveName,
-  selectNumberOfComponentsOfComponentType,
+  selectNumberOfAssetTypesMatchingCaseInsensitiveName,
+  selectNumberOfAssetsOfAssetType,
   selectOrganization,
   selectOrganizationAccess,
   selectOrganizationAccessForUser,
@@ -17215,9 +17165,9 @@ export {
   selectStageFormIdsFromStageIds,
   selectStageMapping,
   selectStages,
-  selectStagesFromComponentType,
-  selectStagesFromComponentTypeIds,
+  selectStagesFromAssetTypeIds,
   selectStagesFromStageIds,
+  selectStagesOfAssetType,
   selectTeam,
   selectTeams,
   selectTeamsMapping,
@@ -17239,14 +17189,14 @@ export {
   setActiveProjectId,
   setActiveWorkspaceId,
   setAppearance,
+  setAssetAttachment,
+  setAssetAttachments,
+  setAssetTypeAttachment,
+  setAssetTypeAttachments,
+  setAssetTypes,
+  setAssets,
   setCategories,
   setCenterMapToProject,
-  setComponentAttachment,
-  setComponentAttachments,
-  setComponentTypeAttachment,
-  setComponentTypeAttachments,
-  setComponentTypes,
-  setComponents,
   setConversation,
   setConversations,
   setCreateProjectType,
@@ -17309,18 +17259,18 @@ 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,