@overmap-ai/core 1.0.71-mapbox.4 → 1.0.71-mapbox.6

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/assetTypeSlice.d.ts

@@ -1,46 +1,41 @@
-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,7 @@
-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 +10,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,31 +1,45 @@
-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>[];

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

@@ -1,46 +1,41 @@
-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 { ModelState } from '../typings';
+import { DocumentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } 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,6 @@
-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 +9,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,41 @@
-import type { EmailDomain, OvermapRootState, OvermapSelector } from "../../typings";
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
+import { EmailDomain, OvermapRootState, OvermapSelector } from '../../typings';
+import { Reducer } from '@reduxjs/toolkit';
+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,6 @@
-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 +18,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 {};