@overmap-ai/core 1.0.74-procedures.3 → 1.0.74-standardizations.0

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

@@ -1,42 +1,47 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetAttachmentState = ModelState<Stored<AssetAttachment>>;
-export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetAttachment>>, {
-    initializeAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+export type AssetAttachmentState = ModelState<AssetAttachment["uuid"], Stored<AssetAttachment>>;
+export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetAttachmentState, {
+    initializeAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    addAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
+    addAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    addAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    addAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    setAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
+    setAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    setAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    setAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    updateAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
+    updateAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    updateAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    updateAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    deleteAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
-}, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetAttachment>>>>;
+    deleteAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetAttachmentState>>;
 export declare const initializeAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">, addAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/addAssetAttachment">, addAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">, setAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">, setAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/setAssetAttachments">, updateAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/updateAssetAttachment">, updateAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">, deleteAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">, deleteAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
 export declare const selectAssetAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetAttachment>>;
 export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
-export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
+export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<AssetAttachment["uuid"], Stored<AssetAttachment> | undefined>;
 export declare const selectAttachmentsOfAsset: (args: string) => (state: OvermapRootState) => Stored<AssetAttachment>[];
-export declare const assetAttachmentReducer: Reducer<AssetAttachmentState>;
+export declare const assetAttachmentReducer: import('redux').Reducer<AssetAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetProcedureFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { AssetProcedureFieldValues, AssetProcedureFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldValuesAttachmentState = ModelState<Stored<AssetProcedureFieldValuesAttachment>>;
+export type AssetProcedureFieldValuesAttachmentState = ModelState<AssetProcedureFieldValuesAttachment["uuid"], Stored<AssetProcedureFieldValuesAttachment>>;
 export declare const assetProcedureFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesAttachmentState, {
-    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    addAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    addAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>;
         type: string;
     }) => void;
-    addAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    addAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    setAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    setAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>;
         type: string;
     }) => void;
-    setAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    setAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    updateAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    updateAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    updateAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFieldValuesAttachments", "assetProcedureFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesAttachmentState>>;
 export declare const initializeAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/initializeAssetProcedureFieldValuesAttachments">, addAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachment">, addAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachments">, setAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachment">, setAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachments">, updateAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachment">, updateAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachments">, deleteAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachment">, deleteAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachments">;
 export declare const selectAssetProcedureFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>;
@@ -57,7 +62,7 @@ export declare const selectAssetProcedureFieldValuesAttachments: ((state: Overma
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetProcedureFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValuesAttachment> | undefined>;
+export declare const selectAssetProcedureFieldValuesAttachmentById: OvermapSelectorWithArgs<AssetProcedureFieldValuesAttachment["uuid"], Stored<AssetProcedureFieldValuesAttachment> | undefined>;
 export declare const selectAssetProcedureFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[];
-export declare const selectAttachmentsOfAssetProcedureFieldValues: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValuesAttachment>[]>;
-export declare const assetProcedureFieldValuesAttachmentReducer: Reducer<AssetProcedureFieldValuesAttachmentState>;
+export declare const selectAttachmentsOfAssetProcedureFieldValues: OvermapSelectorWithArgs<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValuesAttachment>[]>;
+export declare const assetProcedureFieldValuesAttachmentReducer: import('redux').Reducer<AssetProcedureFieldValuesAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetProcedureFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { Asset, AssetProcedureFieldValues, AssetProcedureInstance, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldValuesState = ModelState<Stored<AssetProcedureFieldValues>>;
+export type AssetProcedureFieldValuesState = ModelState<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValues>>;
 export declare const assetProcedureFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesState, {
-    initializeAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    initializeAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    addAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    addAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>;
         type: string;
     }) => void;
-    addAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    addAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    setAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    setAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>;
         type: string;
     }) => void;
-    setAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    setAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    updateAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    updateAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    updateAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFieldValues", "assetProcedureFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesState>>;
 export declare const initializeAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/initializeAssetProcedureFieldValues">, addAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/addAssetProcedureFieldValues">, addAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/addAssetProcedureFieldValuesMany">, setAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/setAssetProcedureFieldValues">, setAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/setAssetProcedureFieldValuesMany">, updateAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/updateAssetProcedureFieldValues">, updateAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/updateAssetProcedureFieldValuesMany">, deleteAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldValues/deleteAssetProcedureFieldValues">, deleteAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldValues/deleteAssetProcedureFieldValuesMany">;
 export declare const selectAssetProcedureFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValues>>;
@@ -57,7 +62,7 @@ export declare const selectAssetProcedureFieldValues: ((state: OvermapRootState)
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetProcedureFieldValuesOfAsset: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues>[]>;
-export declare const selectFieldValuesOfAssetProcedureInstance: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues>[]>;
-export declare const selectAssetProcedureFieldValuesById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues> | undefined>;
-export declare const assetProcedureFieldValuesReducer: Reducer<AssetProcedureFieldValuesState>;
+export declare const selectAssetProcedureFieldValuesOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<AssetProcedureFieldValues>[]>;
+export declare const selectFieldValuesOfAssetProcedureInstance: OvermapSelectorWithArgs<AssetProcedureInstance["uuid"], Stored<AssetProcedureFieldValues>[]>;
+export declare const selectAssetProcedureFieldValuesById: OvermapSelectorWithArgs<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValues> | undefined>;
+export declare const assetProcedureFieldValuesReducer: import('redux').Reducer<AssetProcedureFieldValuesState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { AssetProcedureFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldsAttachmentState = ModelState<Stored<AssetProcedureFieldsAttachment>>;
+export type AssetProcedureFieldsAttachmentState = ModelState<AssetProcedureFieldsAttachment["uuid"], Stored<AssetProcedureFieldsAttachment>>;
 export declare const assetProcedureFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsAttachmentState, {
-    initializeAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    initializeAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    addAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    addAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>;
         type: string;
     }) => void;
-    addAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    addAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    setAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    setAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>;
         type: string;
     }) => void;
-    setAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    setAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    updateAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    updateAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    updateAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFieldsAttachments", "assetProcedureFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsAttachmentState>>;
 export declare const initializeAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/initializeAssetProcedureFieldsAttachments">, addAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachment">, addAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachments">, setAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachment">, setAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachments">, updateAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachment">, updateAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachments">, deleteAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachment">, deleteAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachments">;
 export declare const selectAssetProcedureFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldsAttachment>>;
@@ -57,6 +62,6 @@ export declare const selectAssetProcedureFieldsAttachments: ((state: OvermapRoot
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfAssetProcedureFields: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldsAttachment>[]>;
-export declare const selectAssetProcedureFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldsAttachment> | undefined>;
-export declare const assetProcedureFieldsAttachmentReducer: Reducer<AssetProcedureFieldsAttachmentState>;
+export declare const selectAttachmentsOfAssetProcedureFields: OvermapSelectorWithArgs<AssetProcedureFieldsAttachment["uuid"], Stored<AssetProcedureFieldsAttachment>[]>;
+export declare const selectAssetProcedureFieldsAttachmentById: OvermapSelectorWithArgs<AssetProcedureFieldsAttachment["uuid"], Stored<AssetProcedureFieldsAttachment> | undefined>;
+export declare const assetProcedureFieldsAttachmentReducer: import('redux').Reducer<AssetProcedureFieldsAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetProcedureFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>>;
@@ -57,7 +62,7 @@ export declare const selectAssetProcedureFields: ((state: OvermapRootState) => S
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureFields>[]>;
-export declare const selectLatestAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureFields> | undefined>;
-export declare const selectAssetProcedureFieldsById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFields> | undefined>;
-export declare const assetProcedureFieldsReducer: Reducer<AssetProcedureFieldsState>;
+export declare const selectAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedureFields>[]>;
+export declare const selectLatestAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedureFields> | undefined>;
+export declare const selectAssetProcedureFieldsById: OvermapSelectorWithArgs<AssetProcedureFields["uuid"], Stored<AssetProcedureFields> | undefined>;
+export declare const assetProcedureFieldsReducer: import('redux').Reducer<AssetProcedureFieldsState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetProcedureInstance, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>;
@@ -57,8 +62,8 @@ export declare const selectAssetProcedureInstances: ((state: OvermapRootState) =
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetProcedureInstancesOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureInstance>[]>;
-export declare const selectAssetProcedureInstancesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetProcedureInstance>[]>;
-export declare const selectAssetProcedureInstanceById: OvermapSelectorWithArgs<string, Stored<AssetProcedureInstance> | undefined>;
+export declare const selectAssetProcedureInstancesOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedureInstance>[]>;
+export declare const selectAssetProcedureInstancesOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetProcedureInstance>[]>;
+export declare const selectAssetProcedureInstanceById: OvermapSelectorWithArgs<AssetProcedureInstance["uuid"], Stored<AssetProcedureInstance> | undefined>;
 export declare const selectAssetProcedureInstancesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureInstance>[];
-export declare const assetProcedureInstanceReducer: Reducer<AssetProcedureInstanceState>;
+export declare const assetProcedureInstanceReducer: import('redux').Reducer<AssetProcedureInstanceState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetProcedure, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>;
@@ -57,7 +62,7 @@ export declare const selectAssetProcedures: ((state: OvermapRootState) => Stored
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetProceduresOfOrganization: OvermapSelectorWithArgs<number, Stored<AssetProcedure>[]>;
-export declare const selectAssetProcedureById: OvermapSelectorWithArgs<string, Stored<AssetProcedure> | undefined>;
+export declare const selectAssetProceduresOfOrganization: OvermapSelectorWithArgs<Organization["uuid"], Stored<AssetProcedure>[]>;
+export declare const selectAssetProcedureById: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedure> | undefined>;
 export declare const selectAssetProceduresByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedure>[];
-export declare const assetProcedureReducer: Reducer<AssetProcedureState>;
+export declare const assetProcedureReducer: import('redux').Reducer<AssetProcedureState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { Asset, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>;
@@ -57,8 +62,8 @@ export declare const selectAssets: ((state: OvermapRootState) => Stored<Asset>[]
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<string, Stored<Asset>[]>;
-export declare const selectAssetById: OvermapSelectorWithArgs<string, Stored<Asset> | undefined>;
+export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<Asset>[]>;
+export declare const selectAssetById: OvermapSelectorWithArgs<Asset["uuid"], Stored<Asset> | undefined>;
 export declare const selectAssetsByIds: (args: string[]) => (state: OvermapRootState) => Stored<Asset>[];
-export declare const selectNumberOfAssetsOfAssetType: OvermapSelectorWithArgs<string, number>;
-export declare const assetReducer: Reducer<AssetState>;
+export declare const selectNumberOfAssetsOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], number>;
+export declare const assetReducer: import('redux').Reducer<AssetState>;