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

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

@@ -1,33 +1,38 @@
-import { Reducer } from '@reduxjs/toolkit';
 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: Reducer<AssetStageCompletionState>;
+export declare const assetStageCompletionReducer: import('redux').Reducer<AssetStageCompletionState>;
 export declare const selectAssetStageCompletionMapping: (state: OvermapRootState) => Record<string, Stored<AssetStageCompletion>>;
 export declare const selectAssetStageCompletions: ((state: OvermapRootState) => Stored<AssetStageCompletion>[]) & {
     clearCache: () => void;
@@ -50,5 +55,5 @@ export declare const selectAssetStageCompletions: ((state: OvermapRootState) =>
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetStageCompletionById: OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;
+export declare const selectAssetStageCompletionById: OvermapSelectorWithArgs<AssetStageCompletion["uuid"], Stored<AssetStageCompletion> | undefined>;
 export declare const selectAssetStageCompletionsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetStageCompletion>[];

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

@@ -1,43 +1,48 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { AssetProcedure, AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetStageState = ModelState<Stored<AssetStage>>;
-export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetStage>>, {
-    initializeAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
+export type AssetStageState = ModelState<AssetStage["uuid"], Stored<AssetStage>>;
+export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<AssetStageState, {
+    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;
-}, "assetStages", "assetStages", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetStage>>>>;
+    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: Reducer<AssetStageState>;
-export declare const selectStageMapping: OvermapSelector<Record<AssetStage["offline_id"], Stored<AssetStage>>>;
-export declare const selectAssetStageById: OvermapSelectorWithArgs<string, Stored<AssetStage> | undefined>;
+export declare const assetStageReducer: import('redux').Reducer<AssetStageState>;
+export declare const selectStageMapping: OvermapSelector<Record<AssetStage["uuid"], Stored<AssetStage>>>;
+export declare const selectAssetStageById: OvermapSelectorWithArgs<AssetStage["uuid"], Stored<AssetStage> | undefined>;
 export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => Stored<AssetStage>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -59,6 +64,6 @@ export declare const selectAssetStages: ((state: import('../..').OvermapRootStat
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetStagesMappingOfAssetProcedure: OvermapSelectorWithArgs<string, Record<string, Stored<AssetStage>>>;
-export declare const selectAssetStagesOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetStage>[]>;
+export declare const selectAssetStagesMappingOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Record<string, Stored<AssetStage>>>;
+export declare const selectAssetStagesOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetStage>[]>;
 export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../..').OvermapRootState) => Stored<AssetStage>[];

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

@@ -1,42 +1,47 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { AssetTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeAttachmentState = ModelState<Stored<AssetTypeAttachment>>;
-export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetTypeAttachment>>, {
-    initializeAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
+export type AssetTypeAttachmentState = ModelState<AssetTypeAttachment["uuid"], Stored<AssetTypeAttachment>>;
+export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeAttachmentState, {
+    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;
-}, "assetTypeAttachments", "assetTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetTypeAttachment>>>>;
+    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>>;
 export declare const selectAssetTypeAttachments: OvermapSelector<Stored<AssetTypeAttachment>[]>;
-export declare const selectAssetTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
+export declare const selectAssetTypeAttachmentById: OvermapSelectorWithArgs<AssetTypeAttachment["uuid"], Stored<AssetTypeAttachment> | undefined>;
 export declare const selectAttachmentsOfAssetType: (args: string) => (state: OvermapRootState) => Stored<AssetTypeAttachment>[];
-export declare const assetTypeAttachmentReducer: Reducer<AssetTypeAttachmentState>;
+export declare const assetTypeAttachmentReducer: import('redux').Reducer<AssetTypeAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>;
@@ -57,7 +62,7 @@ export declare const selectAssetTypeFieldValuesAttachments: ((state: OvermapRoot
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment> | undefined>;
+export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<AssetTypeFieldValuesAttachment["uuid"], Stored<AssetTypeFieldValuesAttachment> | undefined>;
 export declare const selectAssetTypeFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[];
-export declare const selectAttachmentsOfAssetTypeFieldValues: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment>[]>;
-export declare const assetTypeFieldValuesAttachmentReducer: Reducer<AssetTypeFieldValuesAttachmentState>;
+export declare const selectAttachmentsOfAssetTypeFieldValues: OvermapSelectorWithArgs<AssetTypeFieldValues["uuid"], Stored<AssetTypeFieldValuesAttachment>[]>;
+export declare const assetTypeFieldValuesAttachmentReducer: import('redux').Reducer<AssetTypeFieldValuesAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>;
@@ -57,7 +62,7 @@ export declare const selectAssetTypeFieldValues: ((state: OvermapRootState) => S
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
-export declare const selectAssetTypeValuesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
-export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues> | undefined>;
-export declare const assetTypeFieldValuesReducer: Reducer<AssetTypeFieldValuesState>;
+export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<AssetTypeFieldValues>[]>;
+export declare const selectAssetTypeValuesOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetTypeFieldValues>[]>;
+export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<AssetTypeFieldValues["uuid"], Stored<AssetTypeFieldValues> | undefined>;
+export declare const assetTypeFieldValuesReducer: import('redux').Reducer<AssetTypeFieldValuesState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>;
@@ -57,6 +62,6 @@ export declare const selectAssetTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment>[]>;
-export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment> | undefined>;
-export declare const assetTypeFieldsAttachmentReducer: Reducer<AssetTypeFieldsAttachmentState>;
+export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<AssetTypeFields["uuid"], Stored<AssetTypeFieldsAttachment>[]>;
+export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<AssetTypeFieldsAttachment["uuid"], Stored<AssetTypeFieldsAttachment> | undefined>;
+export declare const assetTypeFieldsAttachmentReducer: import('redux').Reducer<AssetTypeFieldsAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { AssetType, AssetTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeFieldsState = ModelState<Stored<AssetTypeFields>>;
+export type AssetTypeFieldsState = ModelState<AssetTypeFields["uuid"], Stored<AssetTypeFields>>;
 export declare const assetTypeFieldsSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsState, {
-    initializeAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    initializeAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    addAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    setAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    setAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    updateAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    updateAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    updateAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    updateAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    deleteAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypeFields", "assetTypeFields", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsState>>;
 export declare const initializeAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/initializeAssetTypeFields">, addAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/addAssetTypeFields">, addAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/addAssetTypeFieldsMany">, setAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/setAssetTypeFields">, setAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/setAssetTypeFieldsMany">, updateAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/updateAssetTypeFields">, updateAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/updateAssetTypeFieldsMany">, deleteAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFields/deleteAssetTypeFields">, deleteAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFields/deleteAssetTypeFieldsMany">;
 export declare const selectAssetTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>;
@@ -57,7 +62,7 @@ export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFields>[]>;
-export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFields> | undefined>;
-export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, Stored<AssetTypeFields> | undefined>;
-export declare const assetTypeFieldsReducer: Reducer<AssetTypeFieldsState>;
+export declare const selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetTypeFields>[]>;
+export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetTypeFields> | undefined>;
+export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<AssetTypeFields["uuid"], Stored<AssetTypeFields> | undefined>;
+export declare const assetTypeFieldsReducer: import('redux').Reducer<AssetTypeFieldsState>;

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

@@ -1,42 +1,47 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { AssetType, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeState = ModelState<Stored<AssetType>>;
+export type AssetTypeState = ModelState<AssetType["uuid"], Stored<AssetType>>;
 export declare const assetTypeSlice: import('@reduxjs/toolkit').Slice<AssetTypeState, {
-    initializeAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    initializeAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    setAssetType: (state: ModelState<Stored<AssetType>>, action: {
+    setAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    setAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    setAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    addAssetType: (state: ModelState<Stored<AssetType>>, action: {
+    addAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    addAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    addAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    updateAssetType: (state: ModelState<Stored<AssetType>>, action: {
+    updateAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    updateAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    updateAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    deleteAssetType: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypes: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypes", "assetTypes", import('@reduxjs/toolkit').SliceSelectors<AssetTypeState>>;
 export declare const initializeAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, setAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/setAssetType">, setAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/setAssetTypes">, addAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, addAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/addAssetTypes">, updateAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/updateAssetType">, updateAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/updateAssetTypes">, deleteAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, deleteAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypes/deleteAssetTypes">;
 export declare const selectAssetTypesMapping: OvermapSelector<Record<string, Stored<AssetType>>>;
 export declare const selectAssetTypes: OvermapSelector<Stored<AssetType>[]>;
-export declare const selectAssetTypeById: OvermapSelectorWithArgs<AssetType["offline_id"], Stored<AssetType> | undefined>;
+export declare const selectAssetTypeById: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetType> | undefined>;
 export declare const selectAssetTypesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetType>[];
-export declare const assetTypeReducer: Reducer<AssetTypeState>;
+export declare const assetTypeReducer: import('redux').Reducer<AssetTypeState>;

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

@@ -1,5 +1,5 @@
-import { PayloadAction, Reducer } from '@reduxjs/toolkit';
-import { TokenPair } from '../../sdk/typings';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { TokenPair } from '../../sdk';
 import { BaseState } from '../../typings';
 export interface AuthState {
     accessToken: string;
@@ -17,4 +17,4 @@ export declare const authSlice: import('@reduxjs/toolkit').Slice<AuthState, {
 export declare const setTokens: import('@reduxjs/toolkit').ActionCreatorWithPayload<TokenPair, "auth/setTokens">, clearTokens: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"auth/clearTokens">, setLoggedIn: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "auth/setLoggedIn">;
 export declare const selectAccessToken: (state: BaseState) => string;
 export declare const selectIsLoggedIn: (state: BaseState) => boolean;
-export declare const authReducer: Reducer<AuthState>;
+export declare const authReducer: import('redux').Reducer<AuthState>;