@overmap-ai/core 1.0.71-workspace-settings.8 → 1.0.71

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

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetTypeFieldValuesState = ModelState<Stored<AssetTypeFieldValues>>;
+export declare const assetTypeFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldValuesState, {
+    initializeAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFieldValues", "assetTypeFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldValuesState>>;
+export declare const initializeAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/initializeAssetTypeFieldValues">, addAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/addAssetTypeFieldValues">, addAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/addAssetTypeFieldValuesMany">, setAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/setAssetTypeFieldValues">, setAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/setAssetTypeFieldValuesMany">, updateAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/updateAssetTypeFieldValues">, updateAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/updateAssetTypeFieldValuesMany">, deleteAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValues/deleteAssetTypeFieldValues">, deleteAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValues/deleteAssetTypeFieldValuesMany">;
+export declare const selectAssetTypeFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValues>>;
+export declare const selectAssetTypeFieldValues: ((state: OvermapRootState) => Stored<AssetTypeFieldValues>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValues>>) => Stored<AssetTypeFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValues>>) => Stored<AssetTypeFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, AssetTypeFieldValues[]>;
+export declare const selectAssetTypeValuesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
+export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, AssetTypeFieldValues | undefined>;
+export declare const assetTypeFieldValuesReducer: Reducer<AssetTypeFieldValuesState>;

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

@@ -0,0 +1,62 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetTypeFieldsAttachmentState = ModelState<Stored<AssetTypeFieldsAttachment>>;
+export declare const assetTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsAttachmentState, {
+    initializeAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFieldsAttachments", "assetTypeFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsAttachmentState>>;
+export declare const initializeAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/initializeAssetTypeFieldsAttachments">, addAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/addAssetTypeFieldsAttachment">, addAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/addAssetTypeFieldsAttachments">, setAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/setAssetTypeFieldsAttachment">, setAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/setAssetTypeFieldsAttachments">, updateAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachment">, updateAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachments">, deleteAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachment">, deleteAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachments">;
+export declare const selectAssetTypeFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldsAttachment>>;
+export declare const selectAssetTypeFieldsAttachments: ((state: OvermapRootState) => Stored<AssetTypeFieldsAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFieldsAttachment>>) => Stored<AssetTypeFieldsAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFieldsAttachment>>) => Stored<AssetTypeFieldsAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFieldsAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFieldsAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment[]>;
+export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment | undefined>;
+export declare const assetTypeFieldsAttachmentReducer: Reducer<AssetTypeFieldsAttachmentState>;

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

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetTypeFieldsState = ModelState<Stored<AssetTypeFields>>;
+export declare const assetTypeFieldsSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsState, {
+    initializeAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    addAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    setAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFields", "assetTypeFields", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsState>>;
+export declare const initializeAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/initializeAssetTypeFields">, addAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/addAssetTypeFields">, addAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/addAssetTypeFieldsMany">, setAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/setAssetTypeFields">, setAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/setAssetTypeFieldsMany">, updateAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/updateAssetTypeFields">, updateAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/updateAssetTypeFieldsMany">, deleteAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFields/deleteAssetTypeFields">, deleteAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFields/deleteAssetTypeFieldsMany">;
+export declare const selectAssetTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFields<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 selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields[]>;
+export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+export declare const assetTypeFieldsReducer: Reducer<AssetTypeFieldsState>;

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

@@ -1,46 +1,40 @@
-import type { Reducer } from "@reduxjs/toolkit";
-import type { AssetType, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetType, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type AssetTypeState = ModelState<Stored<AssetType>>;
-export declare const assetTypeSlice: import("@reduxjs/toolkit").Slice<AssetTypeState, {
-    initializeAssetTypes: <TState extends ModelState<Stored<AssetType>>>(state: TState, action: {
+export declare const assetTypeSlice: import('@reduxjs/toolkit').Slice<AssetTypeState, {
+    initializeAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    setAssetType: <TState_1 extends ModelState<Stored<AssetType>>>(state: TState_1, action: {
+    setAssetType: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    setAssetTypes: <TState_2 extends ModelState<Stored<AssetType>>>(state: TState_2, action: {
+    setAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    addAssetType: <TState_3 extends ModelState<Stored<AssetType>>>(state: TState_3, action: {
+    addAssetType: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    addAssetTypes: <TState_4 extends ModelState<Stored<AssetType>>>(state: TState_4, action: {
+    addAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    updateAssetType: <TState_5 extends ModelState<Stored<AssetType>>>(state: TState_5, action: {
+    updateAssetType: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    updateAssetTypes: <TState_6 extends ModelState<Stored<AssetType>>>(state: TState_6, action: {
+    updateAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    deleteAssetType: <TState_7 extends ModelState<Stored<AssetType>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetTypes: <TState_8 extends ModelState<Stored<AssetType>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetTypes">;
-export declare const initializeAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, setAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/setAssetType">, setAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/setAssetTypes">, addAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, addAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/addAssetTypes">, updateAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/updateAssetType">, updateAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/updateAssetTypes">, deleteAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, deleteAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetTypes/deleteAssetTypes">;
+    deleteAssetType: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypes: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypes", "assetTypes", import('@reduxjs/toolkit').SliceSelectors<AssetTypeState>>;
+export declare const initializeAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, setAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/setAssetType">, setAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/setAssetTypes">, addAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, addAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/addAssetTypes">, updateAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/updateAssetType">, updateAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/updateAssetTypes">, deleteAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, deleteAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypes/deleteAssetTypes">;
 export declare const selectAssetTypesMapping: OvermapSelector<Record<string, AssetType>>;
 export declare const selectAssetTypes: OvermapSelector<AssetType[]>;
 export declare const selectAssetTypeById: OvermapSelectorWithArgs<AssetType["offline_id"], Stored<AssetType> | undefined>;

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

@@ -1,6 +1,6 @@
-import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import type { TokenPair } from '../../sdk/typings';
-import type { BaseState } from "../../typings";
+import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { TokenPair } from 'sdk/typings';
+import { BaseState } from '../../typings';
 export interface AuthState {
     accessToken: string;
     refreshToken: string;
@@ -9,12 +9,12 @@ export interface AuthState {
 /**
  * Stores the auth state of the app (tokens, and whether user is logged in or not)
  */
-export declare const authSlice: import("@reduxjs/toolkit").Slice<AuthState, {
-    setTokens: (state: import("immer/dist/internal.js").WritableDraft<AuthState>, action: PayloadAction<TokenPair>) => void;
-    clearTokens: (state: import("immer/dist/internal.js").WritableDraft<AuthState>) => void;
-    setLoggedIn: (state: import("immer/dist/internal.js").WritableDraft<AuthState>, action: PayloadAction<boolean>) => void;
-}, "auth">;
-export declare const setTokens: import("@reduxjs/toolkit").ActionCreatorWithPayload<TokenPair, "auth/setTokens">, clearTokens: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"auth/clearTokens">, setLoggedIn: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "auth/setLoggedIn">;
+export declare const authSlice: import('@reduxjs/toolkit').Slice<AuthState, {
+    setTokens: (state: import('immer').WritableDraft<AuthState>, action: PayloadAction<TokenPair>) => void;
+    clearTokens: (state: import('immer').WritableDraft<AuthState>) => void;
+    setLoggedIn: (state: import('immer').WritableDraft<AuthState>, action: PayloadAction<boolean>) => void;
+}, "auth", "auth", import('@reduxjs/toolkit').SliceSelectors<AuthState>>;
+export declare const setTokens: import('@reduxjs/toolkit').ActionCreatorWithPayload<TokenPair, "auth/setTokens">, clearTokens: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"auth/clearTokens">, setLoggedIn: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "auth/setLoggedIn">;
 export declare const selectAccessToken: (state: BaseState) => string;
 export declare const selectIsLoggedIn: (state: BaseState) => boolean;
 export declare const authReducer: Reducer<AuthState>;

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

@@ -1,34 +1,46 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Category, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Category, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type CategoryState = ModelState<Stored<Category>>;
-export declare const categorySlice: import("@reduxjs/toolkit").Slice<CategoryState, {
-    initializeCategories: <TState extends ModelState<Stored<Category>>>(state: TState, action: {
+export declare const categorySlice: import('@reduxjs/toolkit').Slice<CategoryState, {
+    initializeCategories: (state: ModelState<Stored<Category>>, action: {
         payload: Stored<Category>[];
         type: string;
     }) => void;
-    addCategory: <TState_1 extends ModelState<Stored<Category>>>(state: TState_1, action: {
+    addCategory: (state: ModelState<Stored<Category>>, action: {
         payload: Stored<Category>;
         type: string;
     }) => void;
-    updateCategory: <TState_2 extends ModelState<Stored<Category>>>(state: TState_2, action: {
+    updateCategory: (state: ModelState<Stored<Category>>, action: {
         payload: Stored<Category>;
         type: string;
     }) => void;
-    deleteCategory: <TState_3 extends ModelState<Stored<Category>>>(state: TState_3, action: {
-        payload: string;
-        type: string;
-    }) => void;
-}, "categories">;
-export declare const initializeCategories: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>[], "categories/initializeCategories">, addCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>, "categories/addCategory">, updateCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>, "categories/updateCategory">, deleteCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "categories/deleteCategory">;
+    deleteCategory: (state: ModelState<Stored<Category>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "categories", "categories", import('@reduxjs/toolkit').SliceSelectors<CategoryState>>;
+export declare const initializeCategories: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>[], "categories/initializeCategories">, addCategory: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/addCategory">, updateCategory: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/updateCategory">, deleteCategory: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "categories/deleteCategory">;
 export declare const selectCategoryMapping: (state: OvermapRootState) => Record<string, Stored<Category>>;
-export declare const selectCategories: ((state: OvermapRootState) => Stored<Category>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<Category>>) => Stored<Category>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectCategories: ((state: OvermapRootState) => Stored<Category>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<Category>>) => Stored<Category>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<Category>>) => Stored<Category>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<Category>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<Category>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectCategoryById: OvermapSelectorWithArgs<string, Stored<Category> | undefined>;
 export declare const selectCategoriesByIds: (args: string[]) => (state: OvermapRootState) => Stored<Category>[];
-export declare const selectCategoriesOfWorkspace: OvermapSelectorWithArgs<string, Category[]>;
 export declare const selectIssueCountOfCategory: OvermapSelectorWithArgs<string | null, number>;
 export declare const categoryReducer: Reducer<CategoryState>;

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

@@ -1,46 +1,40 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
-import type { DocumentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { DocumentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type DocumentAttachmentState = ModelState<Stored<DocumentAttachment>>;
-export declare const documentAttachmentSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<DocumentAttachment>>, {
-    initializeDocumentAttachments: <TState extends ModelState<Stored<DocumentAttachment>>>(state: TState, action: {
+export declare const documentAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<DocumentAttachment>>, {
+    initializeDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    addDocumentAttachment: <TState_1 extends ModelState<Stored<DocumentAttachment>>>(state: TState_1, action: {
+    addDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>;
         type: string;
     }) => void;
-    addDocumentAttachments: <TState_2 extends ModelState<Stored<DocumentAttachment>>>(state: TState_2, action: {
+    addDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    setDocumentAttachment: <TState_3 extends ModelState<Stored<DocumentAttachment>>>(state: TState_3, action: {
+    setDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>;
         type: string;
     }) => void;
-    setDocumentAttachments: <TState_4 extends ModelState<Stored<DocumentAttachment>>>(state: TState_4, action: {
+    setDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    updateDocumentAttachment: <TState_5 extends ModelState<Stored<DocumentAttachment>>>(state: TState_5, action: {
+    updateDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>;
         type: string;
     }) => void;
-    updateDocumentAttachments: <TState_6 extends ModelState<Stored<DocumentAttachment>>>(state: TState_6, action: {
+    updateDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    deleteDocumentAttachment: <TState_7 extends ModelState<Stored<DocumentAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteDocumentAttachments: <TState_8 extends ModelState<Stored<DocumentAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "documentAttachments">;
-export declare const initializeDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">, addDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/addDocumentAttachment">, addDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">, setDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">, setDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/setDocumentAttachments">, updateDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/updateDocumentAttachment">, updateDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">, deleteDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">, deleteDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
+    deleteDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "documentAttachments", "documentAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<DocumentAttachment>>>>;
+export declare const initializeDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">, addDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/addDocumentAttachment">, addDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">, setDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">, setDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/setDocumentAttachments">, updateDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/updateDocumentAttachment">, updateDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">, deleteDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">, deleteDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
 export declare const selectDocumentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<DocumentAttachment>>;
 export declare const selectAllDocumentAttachments: OvermapSelector<Stored<DocumentAttachment>[]>;
 export declare const selectDocumentAttachmentById: OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;

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

@@ -1,5 +1,5 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Document, MovePosition, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Document, MovePosition, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 export interface DocumentState {
     documents: Record<string, Stored<Document>>;
 }
@@ -8,32 +8,48 @@ export interface MoveDocumentPayload {
     targetDocumentId: Document["offline_id"] | null;
     position: MovePosition;
 }
-export declare const documentSlice: import("@reduxjs/toolkit").Slice<DocumentState, {
-    setDocuments: (state: import("immer/dist/internal.js").WritableDraft<DocumentState>, action: {
+export declare const documentSlice: import('@reduxjs/toolkit').Slice<DocumentState, {
+    setDocuments: (state: import('immer').WritableDraft<DocumentState>, action: {
         payload: Stored<Document>[];
     }) => void;
-    addDocuments: (state: import("immer/dist/internal.js").WritableDraft<DocumentState>, action: {
+    addDocuments: (state: import('immer').WritableDraft<DocumentState>, action: {
         payload: Stored<Document>[];
     }) => void;
-    updateDocuments: (state: import("immer/dist/internal.js").WritableDraft<DocumentState>, action: {
+    updateDocuments: (state: import('immer').WritableDraft<DocumentState>, action: {
         payload: Stored<Document>[];
     }) => void;
-    moveDocument: (state: import("immer/dist/internal.js").WritableDraft<DocumentState>, action: {
+    moveDocument: (state: import('immer').WritableDraft<DocumentState>, action: {
         payload: MoveDocumentPayload;
     }) => void;
-    removeDocuments: (state: import("immer/dist/internal.js").WritableDraft<DocumentState>, action: {
+    removeDocuments: (state: import('immer').WritableDraft<DocumentState>, action: {
         payload: string[];
     }) => void;
-}, "documents">;
-export declare const setDocuments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Document>[], "documents/setDocuments">, addDocuments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Document>[], "documents/addDocuments">, updateDocuments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Document>[], "documents/updateDocuments">, moveDocument: import("@reduxjs/toolkit").ActionCreatorWithPayload<MoveDocumentPayload, "documents/moveDocument">, removeDocuments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documents/removeDocuments">;
+}, "documents", "documents", import('@reduxjs/toolkit').SliceSelectors<DocumentState>>;
+export declare const setDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/setDocuments">, addDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/addDocuments">, updateDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/updateDocuments">, moveDocument: import('@reduxjs/toolkit').ActionCreatorWithPayload<MoveDocumentPayload, "documents/moveDocument">, removeDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documents/removeDocuments">;
 export declare const selectDocumentsMapping: OvermapSelector<Record<string, Stored<Document>>>;
 export declare const selectDocuments: OvermapSelector<Stored<Document>[]>;
 export declare const selectDocumentById: OvermapSelectorWithArgs<string, Stored<Document> | undefined>;
 export declare const selectDocumentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<Document>[];
 export declare const selectAncestorIdsOfDocument: (args: string) => (state: OvermapRootState) => string[];
-export declare const selectRootDocuments: ((state: OvermapRootState) => Stored<Document>[]) & import("reselect").OutputSelectorFields<(args_0: Stored<Document>[]) => Stored<Document>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectRootDocuments: ((state: OvermapRootState) => Stored<Document>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Stored<Document>[]) => Stored<Document>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Stored<Document>[]) => Stored<Document>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<Document>[];
+    dependencies: [OvermapSelector<Stored<Document>[]>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const documentsReducer: Reducer<DocumentState>;

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

@@ -1,27 +1,40 @@
-import type { EmailDomain, OvermapRootState, OvermapSelector } from "../../typings";
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { EmailDomain, OvermapRootState, OvermapSelector } from '../../typings';
+import { ModelState } from '../typings';
 export type EmailDomainState = ModelState<EmailDomain>;
-export declare const emailDomainsSlice: import("@reduxjs/toolkit").Slice<ModelState<EmailDomain>, {
-    initializeEmailDomains: <TState extends ModelState<EmailDomain>>(state: TState, action: {
+export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<EmailDomain>, {
+    initializeEmailDomains: (state: ModelState<EmailDomain>, action: {
         payload: EmailDomain[];
         type: string;
     }) => void;
-    addEmailDomain: <TState_1 extends ModelState<EmailDomain>>(state: TState_1, action: {
+    addEmailDomain: (state: ModelState<EmailDomain>, action: {
         payload: EmailDomain;
         type: string;
     }) => void;
-    deleteEmailDomain: <TState_2 extends ModelState<EmailDomain>>(state: TState_2, action: {
-        payload: string;
-        type: string;
-    }) => void;
-}, "emailDomains">;
-export declare const initializeEmailDomains: import("@reduxjs/toolkit").ActionCreatorWithPayload<EmailDomain[], "emailDomains/initializeEmailDomains">, addEmailDomain: import("@reduxjs/toolkit").ActionCreatorWithPayload<EmailDomain, "emailDomains/addEmailDomain">, deleteEmailDomain: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
+    deleteEmailDomain: (state: ModelState<EmailDomain>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<EmailDomain>>>;
+export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain, "emailDomains/addEmailDomain">, deleteEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
 export declare const selectEmailDomainsAsMapping: OvermapSelector<Record<number, EmailDomain>>;
-export declare const selectEmailDomains: ((state: OvermapRootState) => EmailDomain[]) & import("reselect").OutputSelectorFields<(args_0: Record<number, EmailDomain>) => EmailDomain[], {
-    clearCache: () => void;
-}> & {
+export declare const selectEmailDomains: ((state: OvermapRootState) => EmailDomain[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<number, EmailDomain>) => EmailDomain[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<number, EmailDomain>) => EmailDomain[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => EmailDomain[];
+    dependencies: [OvermapSelector<Record<number, EmailDomain>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectEmailDomainsOfOrganization: (args: number) => (state: OvermapRootState) => EmailDomain[];
 export declare const emailDomainsReducer: Reducer<EmailDomainState>;

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

@@ -1,5 +1,5 @@
-import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import type { BaseState, SelectorWithArgs } from '../../typings';
+import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { BaseState, SelectorWithArgs } from 'typings';
 interface S3UploadUrl {
     url: string;
     fields: Record<string, string>;
@@ -17,10 +17,10 @@ interface S3UrlPayload {
 /**
  * Stores the auth state of the app (tokens, and whether user is logged in or not)
  */
-export declare const fileSlice: import("@reduxjs/toolkit").Slice<FileState, {
-    setUploadUrl: (state: import("immer/dist/internal.js").WritableDraft<FileState>, action: PayloadAction<S3UrlPayload>) => void;
-}, "file">;
-export declare const setUploadUrl: import("@reduxjs/toolkit").ActionCreatorWithPayload<S3UrlPayload, "file/setUploadUrl">;
+export declare const fileSlice: import('@reduxjs/toolkit').Slice<FileState, {
+    setUploadUrl: (state: import('immer').WritableDraft<FileState>, action: PayloadAction<S3UrlPayload>) => void;
+}, "file", "file", import('@reduxjs/toolkit').SliceSelectors<FileState>>;
+export declare const setUploadUrl: import('@reduxjs/toolkit').ActionCreatorWithPayload<S3UrlPayload, "file/setUploadUrl">;
 export declare const selectUploadUrl: SelectorWithArgs<BaseState, string, S3UploadUrl | undefined>;
 export declare const fileReducer: Reducer<FileState>;
 export {};