@overmap-ai/core 1.0.74-gcs.2 → 1.0.74-geojson-layers.0

package/dist/store/slices/assetProcedureFieldsSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetProcedure, AssetProcedureFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldsState = ModelState<Stored<AssetProcedureFields>>;
+export type AssetProcedureFieldsState = ModelState<AssetProcedureFields["uuid"], Stored<AssetProcedureFields>>;
 export declare const assetProcedureFieldsSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsState, {
-    initializeAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    initializeAssetProcedureFields: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    addAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addAssetProcedureFields: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addAssetProcedureFieldsMany: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    setAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setAssetProcedureFields: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    setAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setAssetProcedureFieldsMany: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    updateAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    updateAssetProcedureFields: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    updateAssetProcedureFieldsMany: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFields: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsMany: (state: ModelState<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFields", "assetProcedureFields", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsState>>;
 export declare const initializeAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/initializeAssetProcedureFields">, addAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/addAssetProcedureFields">, addAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/addAssetProcedureFieldsMany">, setAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/setAssetProcedureFields">, setAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/setAssetProcedureFieldsMany">, updateAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/updateAssetProcedureFields">, updateAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/updateAssetProcedureFieldsMany">, deleteAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFields/deleteAssetProcedureFields">, deleteAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFields/deleteAssetProcedureFieldsMany">;
 export declare const selectAssetProcedureFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>;

package/dist/store/slices/assetProcedureInstanceSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetProcedure, AssetProcedureInstance, AssetType, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureInstanceState = ModelState<Stored<AssetProcedureInstance>>;
+export type AssetProcedureInstanceState = ModelState<AssetProcedureInstance["uuid"], Stored<AssetProcedureInstance>>;
 export declare const assetProcedureInstanceSlice: import('@reduxjs/toolkit').Slice<AssetProcedureInstanceState, {
-    initializeAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    initializeAssetProcedureInstances: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>[];
         type: string;
     }) => void;
-    addAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    addAssetProcedureInstance: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>;
         type: string;
     }) => void;
-    addAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    addAssetProcedureInstances: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>[];
         type: string;
     }) => void;
-    setAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    setAssetProcedureInstance: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>;
         type: string;
     }) => void;
-    setAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    setAssetProcedureInstances: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>[];
         type: string;
     }) => void;
-    updateAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    updateAssetProcedureInstance: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>;
         type: string;
     }) => void;
-    updateAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+    updateAssetProcedureInstances: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
         payload: Stored<AssetProcedureInstance>[];
         type: string;
     }) => void;
-    deleteAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureInstance: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureInstances: (state: ModelState<string, Stored<AssetProcedureInstance>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureInstances", "assetProcedureInstances", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureInstanceState>>;
 export declare const initializeAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/initializeAssetProcedureInstances">, addAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/addAssetProcedureInstance">, addAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/addAssetProcedureInstances">, updateAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/updateAssetProcedureInstance">, updateAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/updateAssetProcedureInstances">, deleteAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureInstances/deleteAssetProcedureInstance">, deleteAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureInstances/deleteAssetProcedureInstances">, setAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/setAssetProcedureInstance">, setAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/setAssetProcedureInstances">;
 export declare const selectAssetProcedureInstancesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureInstance>>;

package/dist/store/slices/assetProcedureSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetProcedure, Organization, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureState = ModelState<Stored<AssetProcedure>>;
+export type AssetProcedureState = ModelState<AssetProcedure["uuid"], Stored<AssetProcedure>>;
 export declare const assetProcedureSlice: import('@reduxjs/toolkit').Slice<AssetProcedureState, {
-    initializeAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+    initializeAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>[];
         type: string;
     }) => void;
-    addAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: {
+    addAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>;
         type: string;
     }) => void;
-    addAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+    addAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>[];
         type: string;
     }) => void;
-    setAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: {
+    setAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>;
         type: string;
     }) => void;
-    setAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+    setAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>[];
         type: string;
     }) => void;
-    updateAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: {
+    updateAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>;
         type: string;
     }) => void;
-    updateAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+    updateAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
         payload: Stored<AssetProcedure>[];
         type: string;
     }) => void;
-    deleteAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedures", "assetProcedures", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureState>>;
 export declare const initializeAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/initializeAssetProcedures">, addAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/addAssetProcedure">, addAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/addAssetProcedures">, updateAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/updateAssetProcedure">, updateAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/updateAssetProcedures">, deleteAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedures/deleteAssetProcedure">, deleteAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedures/deleteAssetProcedures">, setAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/setAssetProcedure">, setAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/setAssetProcedures">;
 export declare const selectAssetProceduresMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedure>>;

package/dist/store/slices/assetSlice.d.ts

@@ -1,37 +1,43 @@
 import { Asset, AssetType, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetState = ModelState<Stored<Asset>>;
+export type AssetState = ModelState<Asset["uuid"], Stored<Asset>>;
 export declare const assetSlice: import('@reduxjs/toolkit').Slice<AssetState, {
-    initializeAssets: (state: ModelState<Stored<Asset>>, action: {
+    initializeAssets: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    addAsset: (state: ModelState<Stored<Asset>>, action: {
+    addAsset: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    addAssets: (state: ModelState<Stored<Asset>>, action: {
+    addAssets: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    setAsset: (state: ModelState<Stored<Asset>>, action: {
+    setAsset: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    setAssets: (state: ModelState<Stored<Asset>>, action: {
+    setAssets: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    updateAsset: (state: ModelState<Stored<Asset>>, action: {
+    updateAsset: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    updateAssets: (state: ModelState<Stored<Asset>>, action: {
+    updateAssets: (state: ModelState<string, Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    deleteAsset: (state: ModelState<Stored<Asset>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssets: (state: ModelState<Stored<Asset>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAsset: (state: ModelState<string, Stored<Asset>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssets: (state: ModelState<string, Stored<Asset>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assets", "assets", import('@reduxjs/toolkit').SliceSelectors<AssetState>>;
 export declare const initializeAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">, addAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">, addAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">, updateAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">, updateAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">, deleteAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assets/deleteAsset">, deleteAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assets/deleteAssets">, setAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">, setAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
 export declare const selectAssetsMapping: (state: OvermapRootState) => Record<string, Stored<Asset>>;

package/dist/store/slices/assetStageCompletionSlice.d.ts

@@ -1,29 +1,35 @@
 import { AssetStageCompletion, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetStageCompletionState = ModelState<Stored<AssetStageCompletion>>;
+export type AssetStageCompletionState = ModelState<AssetStageCompletion["uuid"], Stored<AssetStageCompletion>>;
 export declare const assetStageCompletionSlice: import('@reduxjs/toolkit').Slice<AssetStageCompletionState, {
-    initializeAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+    initializeAssetStageCompletions: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
         payload: Stored<AssetStageCompletion>[];
         type: string;
     }) => void;
-    addAssetStageCompletion: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+    addAssetStageCompletion: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
         payload: Stored<AssetStageCompletion>;
         type: string;
     }) => void;
-    addAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+    addAssetStageCompletions: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
         payload: Stored<AssetStageCompletion>[];
         type: string;
     }) => void;
-    updateAssetStageCompletion: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+    updateAssetStageCompletion: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
         payload: Stored<AssetStageCompletion>;
         type: string;
     }) => void;
-    updateAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+    updateAssetStageCompletions: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
         payload: Stored<AssetStageCompletion>[];
         type: string;
     }) => void;
-    deleteAssetStageCompletion: (state: ModelState<Stored<AssetStageCompletion>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetStageCompletion: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetStageCompletions: (state: ModelState<string, Stored<AssetStageCompletion>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetStageCompletions", "assetStageCompletions", import('@reduxjs/toolkit').SliceSelectors<AssetStageCompletionState>>;
 export declare const initializeAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/initializeAssetStageCompletions">, addAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/addAssetStageCompletion">, addAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/addAssetStageCompletions">, updateAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/updateAssetStageCompletion">, updateAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/updateAssetStageCompletions">, deleteAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStageCompletions/deleteAssetStageCompletion">, deleteAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStageCompletions/deleteAssetStageCompletions">;
 export declare const assetStageCompletionReducer: import('redux').Reducer<AssetStageCompletionState>;

package/dist/store/slices/assetStageSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetProcedure, AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetStageState = ModelState<Stored<AssetStage>>;
+export type AssetStageState = ModelState<AssetStage["uuid"], Stored<AssetStage>>;
 export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<AssetStageState, {
-    initializeAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
+    initializeAssetStages: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    setAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
+    setAssetStage: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    setAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
+    setAssetStages: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    addAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
+    addAssetStage: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    addAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
+    addAssetStages: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    updateAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
+    updateAssetStage: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    updateAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
+    updateAssetStages: (state: ModelState<string, Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    deleteAssetStage: (state: ModelState<Stored<AssetStage>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetStages: (state: ModelState<Stored<AssetStage>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetStage: (state: ModelState<string, Stored<AssetStage>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetStages: (state: ModelState<string, Stored<AssetStage>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetStages", "assetStages", import('@reduxjs/toolkit').SliceSelectors<AssetStageState>>;
 export declare const initializeAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeAssetStages">, setAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setAssetStage">, setAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/setAssetStages">, addAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/addAssetStage">, addAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addAssetStages">, updateAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateAssetStage">, updateAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateAssetStages">, deleteAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStages/deleteAssetStage">, deleteAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStages/deleteAssetStages">;
 export declare const assetStageReducer: import('redux').Reducer<AssetStageState>;

package/dist/store/slices/assetTypeAttachmentSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeAttachmentState = ModelState<Stored<AssetTypeAttachment>>;
+export type AssetTypeAttachmentState = ModelState<AssetTypeAttachment["uuid"], Stored<AssetTypeAttachment>>;
 export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeAttachmentState, {
-    initializeAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    initializeAssetTypeAttachments: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    addAssetTypeAttachment: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    addAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    addAssetTypeAttachments: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    setAssetTypeAttachment: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    setAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    setAssetTypeAttachments: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    updateAssetTypeAttachment: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+    updateAssetTypeAttachments: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetTypeAttachment: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeAttachments: (state: ModelState<string, Stored<AssetTypeAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypeAttachments", "assetTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeAttachmentState>>;
 export declare const initializeAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">, addAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/addAssetTypeAttachment">, addAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">, setAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">, setAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/setAssetTypeAttachments">, updateAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/updateAssetTypeAttachment">, updateAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">, deleteAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">, deleteAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
 export declare const selectAssetTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeAttachment>>;

package/dist/store/slices/assetTypeFieldValuesAttachmentSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeFieldValuesAttachmentState = ModelState<Stored<AssetTypeFieldValuesAttachment>>;
+export type AssetTypeFieldValuesAttachmentState = ModelState<AssetTypeFieldValuesAttachment["uuid"], Stored<AssetTypeFieldValuesAttachment>>;
 export declare const assetTypeFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldValuesAttachmentState, {
-    initializeAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    initializeAssetTypeFieldValuesAttachments: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    addAssetTypeFieldValuesAttachment: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    addAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    addAssetTypeFieldValuesAttachments: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    setAssetTypeFieldValuesAttachment: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    setAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    setAssetTypeFieldValuesAttachments: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    updateAssetTypeFieldValuesAttachment: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+    updateAssetTypeFieldValuesAttachments: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetTypeFieldValuesAttachment: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValuesAttachments: (state: ModelState<string, Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypeFieldValuesAttachments", "assetTypeFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldValuesAttachmentState>>;
 export declare const initializeAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/initializeAssetTypeFieldValuesAttachments">, addAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachment">, addAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachments">, setAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachment">, setAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachments">, updateAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachment">, updateAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachments">, deleteAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachment">, deleteAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachments">;
 export declare const selectAssetTypeFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValuesAttachment>>;

package/dist/store/slices/assetTypeFieldValuesSlice.d.ts

@@ -1,37 +1,43 @@
 import { Asset, AssetType, AssetTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeFieldValuesState = ModelState<Stored<AssetTypeFieldValues>>;
+export type AssetTypeFieldValuesState = ModelState<AssetTypeFieldValues["uuid"], Stored<AssetTypeFieldValues>>;
 export declare const assetTypeFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldValuesState, {
-    initializeAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    initializeAssetTypeFieldValues: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>[];
         type: string;
     }) => void;
-    addAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    addAssetTypeFieldValues: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>;
         type: string;
     }) => void;
-    addAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    addAssetTypeFieldValuesMany: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>[];
         type: string;
     }) => void;
-    setAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    setAssetTypeFieldValues: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>;
         type: string;
     }) => void;
-    setAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    setAssetTypeFieldValuesMany: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>[];
         type: string;
     }) => void;
-    updateAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    updateAssetTypeFieldValues: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>;
         type: string;
     }) => void;
-    updateAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+    updateAssetTypeFieldValuesMany: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
         payload: Stored<AssetTypeFieldValues>[];
         type: string;
     }) => void;
-    deleteAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetTypeFieldValues: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValuesMany: (state: ModelState<string, Stored<AssetTypeFieldValues>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypeFieldValues", "assetTypeFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldValuesState>>;
 export declare const initializeAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/initializeAssetTypeFieldValues">, addAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/addAssetTypeFieldValues">, addAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/addAssetTypeFieldValuesMany">, setAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/setAssetTypeFieldValues">, setAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/setAssetTypeFieldValuesMany">, updateAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/updateAssetTypeFieldValues">, updateAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/updateAssetTypeFieldValuesMany">, deleteAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValues/deleteAssetTypeFieldValues">, deleteAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValues/deleteAssetTypeFieldValuesMany">;
 export declare const selectAssetTypeFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValues>>;

package/dist/store/slices/assetTypeFieldsAttachmentSlice.d.ts

@@ -1,37 +1,43 @@
 import { AssetTypeFields, AssetTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeFieldsAttachmentState = ModelState<Stored<AssetTypeFieldsAttachment>>;
+export type AssetTypeFieldsAttachmentState = ModelState<AssetTypeFieldsAttachment["uuid"], Stored<AssetTypeFieldsAttachment>>;
 export declare const assetTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsAttachmentState, {
-    initializeAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    initializeAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    addAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>;
         type: string;
     }) => void;
-    addAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    addAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    setAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>;
         type: string;
     }) => void;
-    setAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    setAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    updateAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    updateAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypeFieldsAttachments", "assetTypeFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsAttachmentState>>;
 export declare const initializeAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/initializeAssetTypeFieldsAttachments">, addAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/addAssetTypeFieldsAttachment">, addAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/addAssetTypeFieldsAttachments">, setAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/setAssetTypeFieldsAttachment">, setAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/setAssetTypeFieldsAttachments">, updateAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachment">, updateAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachments">, deleteAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachment">, deleteAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachments">;
 export declare const selectAssetTypeFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldsAttachment>>;