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

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

@@ -0,0 +1,62 @@
+import { AssetProcedureFieldValues, AssetProcedureFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldValuesAttachmentState = ModelState<Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const assetProcedureFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesAttachmentState, {
+    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFieldValuesAttachments", "assetProcedureFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesAttachmentState>>;
+export declare const initializeAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/initializeAssetProcedureFieldValuesAttachments">, addAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachment">, addAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachments">, setAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachment">, setAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachments">, updateAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachment">, updateAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachments">, deleteAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachment">, deleteAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachments">;
+export declare const selectAssetProcedureFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const selectAssetProcedureFieldValuesAttachments: ((state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldValuesAttachmentById: OvermapSelectorWithArgs<AssetProcedureFieldValuesAttachment["uuid"], Stored<AssetProcedureFieldValuesAttachment> | undefined>;
+export declare const selectAssetProcedureFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[];
+export declare const selectAttachmentsOfAssetProcedureFieldValues: OvermapSelectorWithArgs<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValuesAttachment>[]>;
+export declare const assetProcedureFieldValuesAttachmentReducer: import('redux').Reducer<AssetProcedureFieldValuesAttachmentState>;

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

@@ -0,0 +1,62 @@
+import { Asset, AssetProcedureFieldValues, AssetProcedureInstance, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldValuesState = ModelState<Stored<AssetProcedureFieldValues>>;
+export declare const assetProcedureFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesState, {
+    initializeAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFieldValues", "assetProcedureFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesState>>;
+export declare const initializeAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/initializeAssetProcedureFieldValues">, addAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/addAssetProcedureFieldValues">, addAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/addAssetProcedureFieldValuesMany">, setAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/setAssetProcedureFieldValues">, setAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/setAssetProcedureFieldValuesMany">, updateAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/updateAssetProcedureFieldValues">, updateAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/updateAssetProcedureFieldValuesMany">, deleteAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldValues/deleteAssetProcedureFieldValues">, deleteAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldValues/deleteAssetProcedureFieldValuesMany">;
+export declare const selectAssetProcedureFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValues>>;
+export declare const selectAssetProcedureFieldValues: ((state: OvermapRootState) => Stored<AssetProcedureFieldValues>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValues>>) => Stored<AssetProcedureFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValues>>) => Stored<AssetProcedureFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldValuesOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<AssetProcedureFieldValues>[]>;
+export declare const selectFieldValuesOfAssetProcedureInstance: OvermapSelectorWithArgs<AssetProcedureInstance["uuid"], Stored<AssetProcedureFieldValues>[]>;
+export declare const selectAssetProcedureFieldValuesById: OvermapSelectorWithArgs<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValues> | undefined>;
+export declare const assetProcedureFieldValuesReducer: import('redux').Reducer<AssetProcedureFieldValuesState>;

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

@@ -0,0 +1,61 @@
+import { AssetProcedureFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldsAttachmentState = ModelState<Stored<AssetProcedureFieldsAttachment>>;
+export declare const assetProcedureFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsAttachmentState, {
+    initializeAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFieldsAttachments", "assetProcedureFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsAttachmentState>>;
+export declare const initializeAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/initializeAssetProcedureFieldsAttachments">, addAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachment">, addAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachments">, setAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachment">, setAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachments">, updateAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachment">, updateAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachments">, deleteAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachment">, deleteAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachments">;
+export declare const selectAssetProcedureFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldsAttachment>>;
+export declare const selectAssetProcedureFieldsAttachments: ((state: OvermapRootState) => Stored<AssetProcedureFieldsAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldsAttachment>>) => Stored<AssetProcedureFieldsAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldsAttachment>>) => Stored<AssetProcedureFieldsAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldsAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldsAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAttachmentsOfAssetProcedureFields: OvermapSelectorWithArgs<AssetProcedureFieldsAttachment["uuid"], Stored<AssetProcedureFieldsAttachment>[]>;
+export declare const selectAssetProcedureFieldsAttachmentById: OvermapSelectorWithArgs<AssetProcedureFieldsAttachment["uuid"], Stored<AssetProcedureFieldsAttachment> | undefined>;
+export declare const assetProcedureFieldsAttachmentReducer: import('redux').Reducer<AssetProcedureFieldsAttachmentState>;

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

@@ -0,0 +1,62 @@
+import { AssetProcedure, AssetProcedureFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldsState = ModelState<Stored<AssetProcedureFields>>;
+export declare const assetProcedureFieldsSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsState, {
+    initializeAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFields", "assetProcedureFields", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsState>>;
+export declare const initializeAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/initializeAssetProcedureFields">, addAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/addAssetProcedureFields">, addAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/addAssetProcedureFieldsMany">, setAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/setAssetProcedureFields">, setAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/setAssetProcedureFieldsMany">, updateAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/updateAssetProcedureFields">, updateAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/updateAssetProcedureFieldsMany">, deleteAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFields/deleteAssetProcedureFields">, deleteAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFields/deleteAssetProcedureFieldsMany">;
+export declare const selectAssetProcedureFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectAssetProcedureFields: ((state: OvermapRootState) => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedureFields>[]>;
+export declare const selectLatestAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedureFields> | undefined>;
+export declare const selectAssetProcedureFieldsById: OvermapSelectorWithArgs<AssetProcedureFields["uuid"], Stored<AssetProcedureFields> | undefined>;
+export declare const assetProcedureFieldsReducer: import('redux').Reducer<AssetProcedureFieldsState>;

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

@@ -0,0 +1,63 @@
+import { AssetProcedure, AssetProcedureInstance, AssetType, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureInstanceState = ModelState<Stored<AssetProcedureInstance>>;
+export declare const assetProcedureInstanceSlice: import('@reduxjs/toolkit').Slice<AssetProcedureInstanceState, {
+    initializeAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    addAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>;
+        type: string;
+    }) => void;
+    addAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    setAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>;
+        type: string;
+    }) => void;
+    setAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>;
+        type: string;
+    }) => void;
+    updateAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureInstances", "assetProcedureInstances", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureInstanceState>>;
+export declare const initializeAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/initializeAssetProcedureInstances">, addAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/addAssetProcedureInstance">, addAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/addAssetProcedureInstances">, updateAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/updateAssetProcedureInstance">, updateAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/updateAssetProcedureInstances">, deleteAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureInstances/deleteAssetProcedureInstance">, deleteAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureInstances/deleteAssetProcedureInstances">, setAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/setAssetProcedureInstance">, setAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/setAssetProcedureInstances">;
+export declare const selectAssetProcedureInstancesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureInstance>>;
+export declare const selectAssetProcedureInstances: ((state: OvermapRootState) => Stored<AssetProcedureInstance>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureInstance>>) => Stored<AssetProcedureInstance>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureInstance>>) => Stored<AssetProcedureInstance>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureInstance>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureInstance>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureInstancesOfAssetProcedure: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedureInstance>[]>;
+export declare const selectAssetProcedureInstancesOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetProcedureInstance>[]>;
+export declare const selectAssetProcedureInstanceById: OvermapSelectorWithArgs<AssetProcedureInstance["uuid"], Stored<AssetProcedureInstance> | undefined>;
+export declare const selectAssetProcedureInstancesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureInstance>[];
+export declare const assetProcedureInstanceReducer: import('redux').Reducer<AssetProcedureInstanceState>;

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

@@ -0,0 +1,62 @@
+import { AssetProcedure, Organization, 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<Organization["uuid"], Stored<AssetProcedure>[]>;
+export declare const selectAssetProcedureById: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedure> | undefined>;
+export declare const selectAssetProceduresByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedure>[];
+export declare const assetProcedureReducer: import('redux').Reducer<AssetProcedureState>;

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

@@ -1,5 +1,4 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { Asset, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { Asset, AssetType, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
 export type AssetState = ModelState<Stored<Asset>>;
 export declare const assetSlice: import('@reduxjs/toolkit').Slice<AssetState, {
@@ -57,8 +56,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<AssetType["uuid"], Stored<Asset>[]>;
+export declare const selectAssetById: OvermapSelectorWithArgs<Asset["uuid"], Stored<Asset> | undefined>;
 export declare const selectAssetsByIds: (args: string[]) => (state: OvermapRootState) => Stored<Asset>[];
-export declare const selectNumberOfAssetsOfAssetType: OvermapSelectorWithArgs<string, number>;
-export declare const assetReducer: Reducer<AssetState>;
+export declare const selectNumberOfAssetsOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], number>;
+export declare const assetReducer: import('redux').Reducer<AssetState>;

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

@@ -1,46 +1,46 @@
-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: import('redux').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;
@@ -49,6 +49,5 @@ export declare const selectCompletedStagesByAsset: ((state: OvermapRootState) =>
     argsMemoize: typeof import('reselect').weakMapMemoize;
     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 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,8 +1,7 @@
-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>>, {
+export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<AssetStageState, {
     initializeAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
@@ -33,24 +32,24 @@ export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<ModelStat
     }) => 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>>>>;
+}, "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"], AssetStage>>;
-export declare const selectAssetStageById: OvermapSelectorWithArgs<string, AssetStage | undefined>;
-export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => AssetStage[]) & {
+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;
     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 +58,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<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,8 +1,7 @@
-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>>, {
+export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeAttachmentState, {
     initializeAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
@@ -33,14 +32,10 @@ export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<
     }) => 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>>>>;
+}, "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 selectAttachmentsOfAssetTypeByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<AssetTypeAttachment>[];
-    imageAttachments: Stored<AssetTypeAttachment>[];
-};
-export declare const assetTypeAttachmentReducer: Reducer<AssetTypeAttachmentState>;
+export declare const assetTypeAttachmentReducer: import('redux').Reducer<AssetTypeAttachmentState>;