@overmap-ai/core 1.0.74-guest-access.0 → 1.0.74-master.1

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

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetProcedure, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureState = ModelState<Stored<AssetProcedure>>;
+export declare const assetProcedureSlice: import('@reduxjs/toolkit').Slice<AssetProcedureState, {
+    initializeAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+        payload: Stored<AssetProcedure>[];
+        type: string;
+    }) => void;
+    addAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: {
+        payload: Stored<AssetProcedure>;
+        type: string;
+    }) => void;
+    addAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+        payload: Stored<AssetProcedure>[];
+        type: string;
+    }) => void;
+    setAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: {
+        payload: Stored<AssetProcedure>;
+        type: string;
+    }) => void;
+    setAssetProcedures: (state: ModelState<Stored<AssetProcedure>>, action: {
+        payload: Stored<AssetProcedure>[];
+        type: string;
+    }) => void;
+    updateAssetProcedure: (state: ModelState<Stored<AssetProcedure>>, action: {
+        payload: Stored<AssetProcedure>;
+        type: string;
+    }) => void;
+    updateAssetProcedures: (state: ModelState<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;
+}, "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>>;
+export declare const selectAssetProcedures: ((state: OvermapRootState) => Stored<AssetProcedure>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedure>>) => Stored<AssetProcedure>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedure>>) => Stored<AssetProcedure>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedure>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedure>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    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 selectAssetProceduresByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedure>[];
+export declare const assetProcedureReducer: Reducer<AssetProcedureState>;

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

@@ -57,8 +57,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, Asset[]>;
-export declare const selectAssetById: OvermapSelectorWithArgs<string, Asset | undefined>;
+export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<string, Stored<Asset>[]>;
+export declare const selectAssetById: OvermapSelectorWithArgs<string, 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>;

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

@@ -1,46 +1,47 @@
 import { Reducer } from '@reduxjs/toolkit';
 import { AssetStageCompletion, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetStageCompletionState = ModelState<AssetStageCompletion>;
+export type AssetStageCompletionState = ModelState<Stored<AssetStageCompletion>>;
 export declare const assetStageCompletionSlice: import('@reduxjs/toolkit').Slice<AssetStageCompletionState, {
-    initializeAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
-        payload: AssetStageCompletion[];
+    initializeAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+        payload: Stored<AssetStageCompletion>[];
         type: string;
     }) => void;
-    addAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: {
-        payload: AssetStageCompletion;
+    addAssetStageCompletion: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+        payload: Stored<AssetStageCompletion>;
         type: string;
     }) => void;
-    addAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
-        payload: AssetStageCompletion[];
+    addAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+        payload: Stored<AssetStageCompletion>[];
         type: string;
     }) => void;
-    updateAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: {
-        payload: AssetStageCompletion;
+    updateAssetStageCompletion: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+        payload: Stored<AssetStageCompletion>;
         type: string;
     }) => void;
-    updateAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
-        payload: AssetStageCompletion[];
+    updateAssetStageCompletions: (state: ModelState<Stored<AssetStageCompletion>>, action: {
+        payload: Stored<AssetStageCompletion>[];
         type: string;
     }) => void;
-    deleteAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: import('@reduxjs/toolkit').PayloadAction<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;
 }, "assetStageCompletions", "assetStageCompletions", import('@reduxjs/toolkit').SliceSelectors<AssetStageCompletionState>>;
-export declare const initializeAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/initializeAssetStageCompletions">, addAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/addAssetStageCompletion">, addAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/addAssetStageCompletions">, updateAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/updateAssetStageCompletion">, updateAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/updateAssetStageCompletions">, deleteAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStageCompletions/deleteAssetStageCompletion">, deleteAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStageCompletions/deleteAssetStageCompletions">;
-export declare const selectAssetStageCompletionMapping: (state: OvermapRootState) => Record<string, AssetStageCompletion>;
-export declare const selectCompletedStagesByAsset: ((state: OvermapRootState) => Record<string, Record<string, string>>) & {
+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 selectAssetStageCompletionMapping: (state: OvermapRootState) => Record<string, Stored<AssetStageCompletion>>;
+export declare const selectAssetStageCompletions: ((state: OvermapRootState) => Stored<AssetStageCompletion>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: Record<string, AssetStageCompletion>) => Record<string, Record<string, string>>;
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, AssetStageCompletion>) => Record<string, Record<string, string>>) & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetStageCompletion>>) => Stored<AssetStageCompletion>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetStageCompletion>>) => Stored<AssetStageCompletion>[]) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => Record<string, Record<string, string>>;
-    dependencies: [(state: OvermapRootState) => Record<string, AssetStageCompletion>];
+    lastResult: () => Stored<AssetStageCompletion>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetStageCompletion>>];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;
@@ -50,5 +51,4 @@ export declare const selectCompletedStagesByAsset: ((state: OvermapRootState) =>
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectAssetStageCompletionById: OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;
-export declare const selectAssetStageCompletionsByIds: (args: string[]) => (state: OvermapRootState) => AssetStageCompletion[];
-export declare const assetStageCompletionReducer: Reducer<AssetStageCompletionState>;
+export declare const selectAssetStageCompletionsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetStageCompletion>[];

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

@@ -36,21 +36,21 @@ export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<ModelStat
 }, "assetStages", "assetStages", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetStage>>>>;
 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"], AssetStage>>;
-export declare const selectAssetStageById: OvermapSelectorWithArgs<string, AssetStage | undefined>;
-export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => AssetStage[]) & {
+export declare const selectStageMapping: OvermapSelector<Record<AssetStage["offline_id"], Stored<AssetStage>>>;
+export declare const selectAssetStageById: OvermapSelectorWithArgs<string, Stored<AssetStage> | undefined>;
+export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => Stored<AssetStage>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[];
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[]) & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetStage>>) => Stored<AssetStage>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetStage>>) => Stored<AssetStage>[]) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => AssetStage[];
-    dependencies: [OvermapSelector<Record<string, AssetStage>>];
+    lastResult: () => Stored<AssetStage>[];
+    dependencies: [OvermapSelector<Record<string, Stored<AssetStage>>>];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;
@@ -59,6 +59,6 @@ export declare const selectAssetStages: ((state: import('../..').OvermapRootStat
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeStagesMapping: OvermapSelectorWithArgs<string, Record<string, AssetStage>>;
-export declare const selectStagesOfAssetType: OvermapSelectorWithArgs<string, AssetStage[]>;
+export declare const selectAssetStagesMappingOfAssetProcedure: OvermapSelectorWithArgs<string, Record<string, Stored<AssetStage>>>;
+export declare const selectAssetStagesOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetStage>[]>;
 export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../..').OvermapRootState) => Stored<AssetStage>[];

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

@@ -39,8 +39,4 @@ export declare const selectAssetTypeAttachmentMapping: (state: OvermapRootState)
 export declare const selectAssetTypeAttachments: OvermapSelector<Stored<AssetTypeAttachment>[]>;
 export declare const selectAssetTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
 export declare const selectAttachmentsOfAssetType: (args: string) => (state: OvermapRootState) => Stored<AssetTypeAttachment>[];
-export declare const selectAttachmentsOfAssetTypeByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<AssetTypeAttachment>[];
-    imageAttachments: Stored<AssetTypeAttachment>[];
-};
 export declare const assetTypeAttachmentReducer: Reducer<AssetTypeAttachmentState>;

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

@@ -57,7 +57,7 @@ export declare const selectAssetTypeFieldValuesAttachments: ((state: OvermapRoot
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldValuesAttachment | undefined>;
+export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, 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>;

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

@@ -57,7 +57,7 @@ export declare const selectAssetTypeFieldValues: ((state: OvermapRootState) => S
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, AssetTypeFieldValues[]>;
+export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
 export declare const selectAssetTypeValuesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
-export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, AssetTypeFieldValues | undefined>;
+export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues> | undefined>;
 export declare const assetTypeFieldValuesReducer: Reducer<AssetTypeFieldValuesState>;

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

@@ -57,6 +57,6 @@ export declare const selectAssetTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment[]>;
-export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment | undefined>;
+export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment>[]>;
+export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment> | undefined>;
 export declare const assetTypeFieldsAttachmentReducer: Reducer<AssetTypeFieldsAttachmentState>;

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

@@ -57,7 +57,7 @@ export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields[]>;
-export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
-export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+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>;

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

@@ -35,8 +35,8 @@ export declare const assetTypeSlice: import('@reduxjs/toolkit').Slice<AssetTypeS
     deleteAssetTypes: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<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, AssetType>>;
-export declare const selectAssetTypes: OvermapSelector<AssetType[]>;
+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 selectAssetTypesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetType>[];
 export declare const assetTypeReducer: Reducer<AssetTypeState>;

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

@@ -39,8 +39,4 @@ export declare const selectDocumentAttachmentMapping: (state: OvermapRootState)
 export declare const selectAllDocumentAttachments: OvermapSelector<Stored<DocumentAttachment>[]>;
 export declare const selectDocumentAttachmentById: OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
 export declare const selectAttachmentsOfDocument: (args: string) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
-export declare const selectAttachmentsOfDocumentByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<DocumentAttachment>[];
-    imageAttachments: Stored<DocumentAttachment>[];
-};
 export declare const documentAttachmentReducer: Reducer<DocumentAttachmentState>;

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

@@ -1,19 +1,19 @@
 import { Reducer } from '@reduxjs/toolkit';
-import { EmailDomain, OvermapRootState, OvermapSelector } from '../../typings';
+import { EmailDomain, OvermapRootState, OvermapSelector, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type EmailDomainState = ModelState<EmailDomain>;
-export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<EmailDomain>, {
-    initializeEmailDomains: (state: ModelState<EmailDomain>, action: {
-        payload: EmailDomain[];
+export type EmailDomainState = ModelState<Stored<EmailDomain>>;
+export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<EmailDomain>>, {
+    initializeEmailDomains: (state: ModelState<Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>[];
         type: string;
     }) => void;
-    addEmailDomain: (state: ModelState<EmailDomain>, action: {
-        payload: EmailDomain;
+    addEmailDomain: (state: ModelState<Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>;
         type: string;
     }) => void;
-    deleteEmailDomain: (state: ModelState<EmailDomain>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<EmailDomain>>>;
-export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain, "emailDomains/addEmailDomain">, deleteEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
+    deleteEmailDomain: (state: ModelState<Stored<EmailDomain>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<EmailDomain>>>>;
+export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<EmailDomain>[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<EmailDomain>, "emailDomains/addEmailDomain">, deleteEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
 export declare const selectEmailDomainsAsMapping: OvermapSelector<Record<number, EmailDomain>>;
 export declare const selectEmailDomains: ((state: OvermapRootState) => EmailDomain[]) & {
     clearCache: () => void;

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

@@ -46,7 +46,6 @@ export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<F
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectFormRevisionById: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
-export declare const _selectLatestFormRevision: (formRevisions: FormRevisionState["instances"], formId: string) => Stored<FormRevision>;
 export declare const selectLatestFormRevisionOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
 export declare const selectFormRevisionsOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision>[]>;
 export declare const formRevisionReducer: Reducer<FormRevisionState>;

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

@@ -54,4 +54,3 @@ export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[])
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;

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

@@ -3,38 +3,38 @@ import { GeoImage, OvermapRootState, Stored } from '../../typings';
 import { ModelState } from '../typings';
 export type GeoImageSliceState = ModelState<Stored<GeoImage>>;
 export declare const geoImageSlice: import('@reduxjs/toolkit').Slice<GeoImageSliceState, {
-    initializeGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    initializeGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    setGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    setGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    setGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    setGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    addGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    addGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    addGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    addGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    updateGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    updateGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    updateGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    updateGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    deleteGeoImage: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteGeoImages: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteGeoImage: (state: ModelState<Stored<GeoImage>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteGeoImages: (state: ModelState<Stored<GeoImage>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "geoImages", "geoImages", import('@reduxjs/toolkit').SliceSelectors<GeoImageSliceState>>;
-export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/updateGeoImages">, deleteGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
+export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/updateGeoImages">, deleteGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
 export declare const selectGeoImageMapping: (state: OvermapRootState) => Record<string, Stored<GeoImage>>;
 export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoImage>[]) & {
     clearCache: () => void;

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

@@ -1,5 +1,11 @@
 export * from './agentsSlice';
 export * from './assetAttachmentSlice';
+export * from './assetProcedureFieldsAttachmentSlice';
+export * from './assetProcedureFieldsSlice';
+export * from './assetProcedureFieldValuesAttachmentSlice';
+export * from './assetProcedureFieldValuesSlice';
+export * from './assetProcedureInstanceSlice';
+export * from './assetProcedureSlice';
 export * from './assetSlice';
 export * from './assetStageCompletionSlice';
 export * from './assetStageSlice';
@@ -23,8 +29,10 @@ export * from './formSubmissionSlice';
 export * from './geoImageSlice';
 export * from './issueAssociationSlice';
 export * from './issueAttachmentSlice';
+export * from './issueCommentAttachmentSlice';
 export * from './issueCommentSlice';
 export * from './issueSlice';
+export * from './issueTypeAttachmentSlice';
 export * from './issueTypeFieldsAttachmentSlice';
 export * from './issueTypeFieldsSlice';
 export * from './issueTypeFieldValuesAttachmentSlice';

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

@@ -39,8 +39,4 @@ export declare const selectIssueAttachmentMapping: (state: OvermapRootState) =>
 export declare const selectIssueAttachments: OvermapSelector<Stored<IssueAttachment>[]>;
 export declare const selectAttachmentsOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueAttachment>[];
 export declare const selectIssueAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-export declare const selectAttachmentsOfIssueByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<IssueAttachment>[];
-    imageAttachments: Stored<IssueAttachment>[];
-};
 export declare const issueAttachmentReducer: Reducer<IssueAttachmentState>;

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

@@ -0,0 +1,42 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueCommentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueCommentAttachmentState = ModelState<Stored<IssueCommentAttachment>>;
+export declare const issueCommentAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<IssueCommentAttachment>>, {
+    initializeIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    addIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>;
+        type: string;
+    }) => void;
+    addIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    setIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>;
+        type: string;
+    }) => void;
+    setIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>;
+        type: string;
+    }) => void;
+    updateIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueCommentAttachments", "issueCommentAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<IssueCommentAttachment>>>>;
+export declare const initializeIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">, addIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/addIssueCommentAttachment">, addIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">, setIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">, setIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/setIssueCommentAttachments">, updateIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/updateIssueCommentAttachment">, updateIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">, deleteIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">, deleteIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
+export declare const selectIssueCommentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueCommentAttachment>>;
+export declare const selectIssueCommentAttachments: OvermapSelector<Stored<IssueCommentAttachment>[]>;
+export declare const selectIssueCommentAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
+export declare const selectAttachmentsOfIssueComment: (args: string) => (state: OvermapRootState) => Stored<IssueCommentAttachment>[];
+export declare const issueCommentAttachmentReducer: Reducer<IssueCommentAttachmentState>;

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

@@ -0,0 +1,42 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeAttachmentState = ModelState<Stored<IssueTypeAttachment>>;
+export declare const issueTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<IssueTypeAttachment>>, {
+    initializeIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeAttachments", "issueTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<IssueTypeAttachment>>>>;
+export declare const initializeIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">, addIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/addIssueTypeAttachment">, addIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">, setIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">, setIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/setIssueTypeAttachments">, updateIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/updateIssueTypeAttachment">, updateIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">, deleteIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">, deleteIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+export declare const selectIssueTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeAttachment>>;
+export declare const selectIssueTypeAttachments: OvermapSelector<Stored<IssueTypeAttachment>[]>;
+export declare const selectIssueTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+export declare const selectAttachmentsOfIssueType: (args: string) => (state: OvermapRootState) => Stored<IssueTypeAttachment>[];
+export declare const issueTypeAttachmentReducer: Reducer<IssueTypeAttachmentState>;

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

@@ -57,6 +57,6 @@ export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment[]>;
-export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment | undefined>;
+export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment>[]>;
+export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment> | undefined>;
 export declare const issueTypeFieldsAttachmentReducer: Reducer<IssueTypeFieldsAttachmentState>;

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

@@ -58,7 +58,7 @@ export declare const selectIssueTypeFields: ((state: OvermapRootState) => Stored
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields>[]>;
-export declare const selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, IssueTypeFields | undefined>;
+export declare const selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
 export declare const selectIssueTypeValuesOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues>[]>;
 export declare const selectIssueTypeFieldsById: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
 export declare const issueTypeFieldsReducer: Reducer<IssueTypeFieldsState>;

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

@@ -1,22 +1,22 @@
 import { Reducer } from '@reduxjs/toolkit';
-import { License, OvermapSelector, OvermapSelectorWithArgs } from '../../typings';
+import { License, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type LicenseState = ModelState<License>;
+export type LicenseState = ModelState<Stored<License>>;
 export declare const licenseSlice: import('@reduxjs/toolkit').Slice<LicenseState, {
-    initializeLicences: (state: ModelState<License>, action: {
-        payload: License[];
+    initializeLicences: (state: ModelState<Stored<License>>, action: {
+        payload: Stored<License>[];
         type: string;
     }) => void;
-    addLicenses: (state: ModelState<License>, action: {
-        payload: License[];
+    addLicenses: (state: ModelState<Stored<License>>, action: {
+        payload: Stored<License>[];
         type: string;
     }) => void;
-    updateLicense: (state: ModelState<License>, action: {
-        payload: License;
+    updateLicense: (state: ModelState<Stored<License>>, action: {
+        payload: Stored<License>;
         type: string;
     }) => void;
 }, "license", "license", import('@reduxjs/toolkit').SliceSelectors<LicenseState>>;
-export declare const initializeLicences: import('@reduxjs/toolkit').ActionCreatorWithPayload<License[], "license/initializeLicences">, addLicenses: import('@reduxjs/toolkit').ActionCreatorWithPayload<License[], "license/addLicenses">, updateLicense: import('@reduxjs/toolkit').ActionCreatorWithPayload<License, "license/updateLicense">;
+export declare const initializeLicences: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<License>[], "license/initializeLicences">, addLicenses: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<License>[], "license/addLicenses">, updateLicense: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<License>, "license/updateLicense">;
 export declare const selectLicenses: OvermapSelector<Record<string, License>>;
 export declare const selectLicense: OvermapSelectorWithArgs<string, License | undefined>;
 export declare const selectLicenseForProject: OvermapSelectorWithArgs<number, License | undefined>;