@overmap-ai/core 1.0.71-fields.14 → 1.0.71-fields.15

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

@@ -1,26 +1,27 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AgentUserConversation, OvermapRootState, OvermapSelector } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AgentUserConversation, OvermapRootState, OvermapSelector } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AgentsState = ModelState<AgentUserConversation>;
-export declare const agentsSlice: import("@reduxjs/toolkit").Slice<ModelState<AgentUserConversation>, {
-    initializeConversations: <TState extends ModelState<AgentUserConversation>>(state: TState, action: {
+export declare const agentsSlice: import('@reduxjs/toolkit').Slice<ModelState<AgentUserConversation>, {
+    initializeConversations: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation[];
         type: string;
     }) => void;
-    addConversation: <TState_1 extends ModelState<AgentUserConversation>>(state: TState_1, action: {
+    addConversation: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-    setConversation: <TState_2 extends ModelState<AgentUserConversation>>(state: TState_2, action: {
+    setConversation: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-    updateConversation: <TState_3 extends ModelState<AgentUserConversation>>(state: TState_3, action: {
+    updateConversation: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-}, "agents">;
-export declare const initializeConversations: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation[], "agents/initializeConversations">, addConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, setConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, updateConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/updateConversation">;
+}, "agents", "agents", import('@reduxjs/toolkit').SliceSelectors<ModelState<AgentUserConversation>>>;
+export declare const initializeConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/initializeConversations">, addConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, setConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, updateConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/updateConversation">;
 export declare const selectConversationMapping: (state: OvermapRootState) => Record<string, AgentUserConversation>;
 export declare const selectConversations: OvermapSelector<AgentUserConversation[]>;
 export declare const selectConversation: (args: string) => (state: OvermapRootState) => AgentUserConversation | undefined;

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

@@ -1,46 +1,41 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
-import type { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { ModelState } from '../typings';
+import { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+
 export type AssetAttachmentState = ModelState<Stored<AssetAttachment>>;
-export declare const assetAttachmentSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetAttachment>>, {
-    initializeAssetAttachments: <TState extends ModelState<Stored<AssetAttachment>>>(state: TState, action: {
+export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetAttachment>>, {
+    initializeAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    addAssetAttachment: <TState_1 extends ModelState<Stored<AssetAttachment>>>(state: TState_1, action: {
+    addAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    addAssetAttachments: <TState_2 extends ModelState<Stored<AssetAttachment>>>(state: TState_2, action: {
+    addAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    setAssetAttachment: <TState_3 extends ModelState<Stored<AssetAttachment>>>(state: TState_3, action: {
+    setAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    setAssetAttachments: <TState_4 extends ModelState<Stored<AssetAttachment>>>(state: TState_4, action: {
+    setAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    updateAssetAttachment: <TState_5 extends ModelState<Stored<AssetAttachment>>>(state: TState_5, action: {
+    updateAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    updateAssetAttachments: <TState_6 extends ModelState<Stored<AssetAttachment>>>(state: TState_6, action: {
+    updateAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    deleteAssetAttachment: <TState_7 extends ModelState<Stored<AssetAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetAttachments: <TState_8 extends ModelState<Stored<AssetAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetAttachments">;
-export declare const initializeAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">, addAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/addAssetAttachment">, addAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">, setAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">, setAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/setAssetAttachments">, updateAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/updateAssetAttachment">, updateAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">, deleteAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">, deleteAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
+    deleteAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetAttachment>>>>;
+export declare const initializeAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">, addAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/addAssetAttachment">, addAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">, setAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">, setAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/setAssetAttachments">, updateAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/updateAssetAttachment">, updateAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">, deleteAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">, deleteAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
 export declare const selectAssetAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetAttachment>>;
 export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
 export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Asset, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Asset, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetState = ModelState<Stored<Asset>>;
-export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
-    initializeAssets: <TState extends ModelState<Stored<Asset>>>(state: TState, action: {
+export declare const assetSlice: import('@reduxjs/toolkit').Slice<AssetState, {
+    initializeAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    addAsset: <TState_1 extends ModelState<Stored<Asset>>>(state: TState_1, action: {
+    addAsset: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    addAssets: <TState_2 extends ModelState<Stored<Asset>>>(state: TState_2, action: {
+    addAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    setAsset: <TState_3 extends ModelState<Stored<Asset>>>(state: TState_3, action: {
+    setAsset: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    setAssets: <TState_4 extends ModelState<Stored<Asset>>>(state: TState_4, action: {
+    setAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    updateAsset: <TState_5 extends ModelState<Stored<Asset>>>(state: TState_5, action: {
+    updateAsset: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    updateAssets: <TState_6 extends ModelState<Stored<Asset>>>(state: TState_6, action: {
+    updateAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    deleteAsset: <TState_7 extends ModelState<Stored<Asset>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssets: <TState_8 extends ModelState<Stored<Asset>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assets">;
-export declare const initializeAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">, addAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">, addAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">, updateAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">, updateAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">, deleteAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/deleteAsset">, deleteAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assets/deleteAssets">, setAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">, setAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
+    deleteAsset: (state: ModelState<Stored<Asset>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssets: (state: ModelState<Stored<Asset>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assets", "assets", import('@reduxjs/toolkit').SliceSelectors<AssetState>>;
+export declare const initializeAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">, addAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">, addAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">, updateAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">, updateAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">, deleteAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assets/deleteAsset">, deleteAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assets/deleteAssets">, setAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">, setAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
 export declare const selectAssetsMapping: (state: OvermapRootState) => Record<string, Stored<Asset>>;
-export declare const selectAssets: ((state: OvermapRootState) => Stored<Asset>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<Asset>>) => Stored<Asset>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectAssets: ((state: OvermapRootState) => Stored<Asset>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<Asset>>) => Stored<Asset>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<Asset>>) => Stored<Asset>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<Asset>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<Asset>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    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>;

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

@@ -1,43 +1,54 @@
-import { Reducer } from "@reduxjs/toolkit";
-import { Asset, AssetStageCompletion, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Asset, AssetStageCompletion, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetStageCompletionState = ModelState<AssetStageCompletion>;
-export declare const assetStageCompletionSlice: import("@reduxjs/toolkit").Slice<AssetStageCompletionState, {
-    initializeAssetStageCompletions: <TState extends ModelState<AssetStageCompletion>>(state: TState, action: {
+export declare const assetStageCompletionSlice: import('@reduxjs/toolkit').Slice<AssetStageCompletionState, {
+    initializeAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion[];
         type: string;
     }) => void;
-    addAssetStageCompletion: <TState_1 extends ModelState<AssetStageCompletion>>(state: TState_1, action: {
+    addAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion;
         type: string;
     }) => void;
-    addAssetStageCompletions: <TState_2 extends ModelState<AssetStageCompletion>>(state: TState_2, action: {
+    addAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion[];
         type: string;
     }) => void;
-    updateAssetStageCompletion: <TState_3 extends ModelState<AssetStageCompletion>>(state: TState_3, action: {
+    updateAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion;
         type: string;
     }) => void;
-    updateAssetStageCompletions: <TState_4 extends ModelState<AssetStageCompletion>>(state: TState_4, action: {
+    updateAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion[];
         type: string;
     }) => void;
-    deleteAssetStageCompletion: <TState_5 extends ModelState<AssetStageCompletion>>(state: TState_5, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetStageCompletions: <TState_6 extends ModelState<AssetStageCompletion>>(state: TState_6, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetStageCompletions">;
-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">;
+    deleteAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetStageCompletions: (state: ModelState<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>>) & import("reselect").OutputSelectorFields<(args_0: Record<string, AssetStageCompletion>) => Record<string, Record<string, string>>, {
-    clearCache: () => void;
-}> & {
+export declare const selectCompletedStagesByAsset: ((state: OvermapRootState) => Record<string, Record<string, string>>) & {
     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>>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, Record<string, string>>;
+    dependencies: [(state: OvermapRootState) => Record<string, AssetStageCompletion>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectCompletedStageIdsForAsset: OvermapSelectorWithArgs<Asset, string[]>;
 export declare const selectAssetStageCompletionById: OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;

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

@@ -1,55 +1,66 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetStageState = ModelState<Stored<AssetStage>>;
-export declare const assetStageSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetStage>>, {
-    initializeAssetStages: <TState extends ModelState<Stored<AssetStage>>>(state: TState, action: {
+export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetStage>>, {
+    initializeAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    setAssetStage: <TState_1 extends ModelState<Stored<AssetStage>>>(state: TState_1, action: {
+    setAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    setAssetStages: <TState_2 extends ModelState<Stored<AssetStage>>>(state: TState_2, action: {
+    setAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    addAssetStage: <TState_3 extends ModelState<Stored<AssetStage>>>(state: TState_3, action: {
+    addAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    addAssetStages: <TState_4 extends ModelState<Stored<AssetStage>>>(state: TState_4, action: {
+    addAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    updateAssetStage: <TState_5 extends ModelState<Stored<AssetStage>>>(state: TState_5, action: {
+    updateAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    updateAssetStages: <TState_6 extends ModelState<Stored<AssetStage>>>(state: TState_6, action: {
+    updateAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    deleteAssetStage: <TState_7 extends ModelState<Stored<AssetStage>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetStages: <TState_8 extends ModelState<Stored<AssetStage>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetStages">;
-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">;
+    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>>>>;
+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('../../typings/models/store').OvermapRootState) => AssetStage[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, AssetStage>) => AssetStage[], {
-    clearCache: () => void;
-}> & {
+export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => AssetStage[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => AssetStage[];
+    dependencies: [OvermapSelector<Record<string, AssetStage>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    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 selectAssetStagesByIds: (args: string[]) => (state: import('../../typings/models/store').OvermapRootState) => Stored<AssetStage>[];
+export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../..').OvermapRootState) => Stored<AssetStage>[];
 export declare const selectStageFormIdsFromStageIds: OvermapSelectorWithArgs<string[], Record<string, string>>;

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

@@ -1,46 +1,41 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AssetTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetTypeAttachmentState = ModelState<Stored<AssetTypeAttachment>>;
-export declare const assetTypeAttachmentSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetTypeAttachment>>, {
-    initializeAssetTypeAttachments: <TState extends ModelState<Stored<AssetTypeAttachment>>>(state: TState, action: {
+export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetTypeAttachment>>, {
+    initializeAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeAttachment: <TState_1 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_1, action: {
+    addAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    addAssetTypeAttachments: <TState_2 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_2, action: {
+    addAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeAttachment: <TState_3 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_3, action: {
+    setAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    setAssetTypeAttachments: <TState_4 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_4, action: {
+    setAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeAttachment: <TState_5 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_5, action: {
+    updateAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeAttachments: <TState_6 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_6, action: {
+    updateAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeAttachment: <TState_7 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetTypeAttachments: <TState_8 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetTypeAttachments">;
-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">;
+    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>>>>;
+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>;

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AssetTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetTypeFieldValuesAttachmentState = ModelState<Stored<AssetTypeFieldValuesAttachment>>;
-export declare const assetTypeFieldValuesAttachmentSlice: import("@reduxjs/toolkit").Slice<AssetTypeFieldValuesAttachmentState, {
-    initializeAssetTypeFieldValuesAttachments: <TState extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState, action: {
+export declare const assetTypeFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldValuesAttachmentState, {
+    initializeAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeFieldValuesAttachment: <TState_1 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_1, action: {
+    addAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    addAssetTypeFieldValuesAttachments: <TState_2 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_2, action: {
+    addAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeFieldValuesAttachment: <TState_3 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_3, action: {
+    setAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    setAssetTypeFieldValuesAttachments: <TState_4 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_4, action: {
+    setAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeFieldValuesAttachment: <TState_5 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_5, action: {
+    updateAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeFieldValuesAttachments: <TState_6 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_6, action: {
+    updateAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
         payload: Stored<AssetTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeFieldValuesAttachment: <TState_7 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetTypeFieldValuesAttachments: <TState_8 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetTypeFieldValuesAttachments">;
-export declare const initializeAssetTypeFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/initializeAssetTypeFieldValuesAttachments">, addAssetTypeFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachment">, addAssetTypeFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachments">, setAssetTypeFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachment">, setAssetTypeFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachments">, updateAssetTypeFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachment">, updateAssetTypeFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachments">, deleteAssetTypeFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachment">, deleteAssetTypeFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachments">;
+    deleteAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFieldValuesAttachments", "assetTypeFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldValuesAttachmentState>>;
+export declare const initializeAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/initializeAssetTypeFieldValuesAttachments">, addAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachment">, addAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachments">, setAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachment">, setAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachments">, updateAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachment">, updateAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachments">, deleteAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachment">, deleteAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachments">;
 export declare const selectAssetTypeFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValuesAttachment>>;
-export declare const selectAssetTypeFieldValuesAttachments: ((state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetTypeFieldValuesAttachment>>) => Stored<AssetTypeFieldValuesAttachment>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectAssetTypeFieldValuesAttachments: ((state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValuesAttachment>>) => Stored<AssetTypeFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValuesAttachment>>) => Stored<AssetTypeFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldValuesAttachment | undefined>;
 export declare const selectAssetTypeFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[];