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

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type IssueTypeFieldValuesState = ModelState<Stored<IssueTypeFieldValues>>;
-export declare const issueTypeFieldValuesSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldValuesState, {
-    initializeIssueTypeFieldValues: <TState extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState, action: {
+export declare const issueTypeFieldValuesSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldValuesState, {
+    initializeIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    addIssueTypeFieldValues: <TState_1 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_1, action: {
+    addIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>;
         type: string;
     }) => void;
-    addIssueTypeFieldValuesMany: <TState_2 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_2, action: {
+    addIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    setIssueTypeFieldValues: <TState_3 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_3, action: {
+    setIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>;
         type: string;
     }) => void;
-    setIssueTypeFieldValuesMany: <TState_4 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_4, action: {
+    setIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    updateIssueTypeFieldValues: <TState_5 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_5, action: {
+    updateIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>;
         type: string;
     }) => void;
-    updateIssueTypeFieldValuesMany: <TState_6 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_6, action: {
+    updateIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    deleteIssueTypeFieldValues: <TState_7 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueTypeFieldValuesMany: <TState_8 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueTypeFieldValues">;
-export declare const initializeIssueTypeFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/initializeIssueTypeFieldValues">, addIssueTypeFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/addIssueTypeFieldValues">, addIssueTypeFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/addIssueTypeFieldValuesMany">, setIssueTypeFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/setIssueTypeFieldValues">, setIssueTypeFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/setIssueTypeFieldValuesMany">, updateIssueTypeFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/updateIssueTypeFieldValues">, updateIssueTypeFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/updateIssueTypeFieldValuesMany">, deleteIssueTypeFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueTypeFieldValues/deleteIssueTypeFieldValues">, deleteIssueTypeFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "issueTypeFieldValues/deleteIssueTypeFieldValuesMany">;
+    deleteIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeFieldValues", "issueTypeFieldValues", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldValuesState>>;
+export declare const initializeIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/initializeIssueTypeFieldValues">, addIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/addIssueTypeFieldValues">, addIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/addIssueTypeFieldValuesMany">, setIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/setIssueTypeFieldValues">, setIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/setIssueTypeFieldValuesMany">, updateIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/updateIssueTypeFieldValues">, updateIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/updateIssueTypeFieldValuesMany">, deleteIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldValues/deleteIssueTypeFieldValues">, deleteIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldValues/deleteIssueTypeFieldValuesMany">;
 export declare const selectIssueTypeFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValues>>;
-export declare const selectIssueTypeFieldValues: ((state: OvermapRootState) => Stored<IssueTypeFieldValues>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectIssueTypeFieldValues: ((state: OvermapRootState) => Stored<IssueTypeFieldValues>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectIssueTypeFieldValuesOfIssue: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues>[]>;
 export declare const selectIssueTypeFieldValuesById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues> | undefined>;

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { IssueTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type IssueTypeFieldsAttachmentState = ModelState<Stored<IssueTypeFieldsAttachment>>;
-export declare const issueTypeFieldsAttachmentSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldsAttachmentState, {
-    initializeIssueTypeFieldsAttachments: <TState extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState, action: {
+export declare const issueTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldsAttachmentState, {
+    initializeIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    addIssueTypeFieldsAttachment: <TState_1 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_1, action: {
+    addIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>;
         type: string;
     }) => void;
-    addIssueTypeFieldsAttachments: <TState_2 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_2, action: {
+    addIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    setIssueTypeFieldsAttachment: <TState_3 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_3, action: {
+    setIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>;
         type: string;
     }) => void;
-    setIssueTypeFieldsAttachments: <TState_4 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_4, action: {
+    setIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    updateIssueTypeFieldsAttachment: <TState_5 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_5, action: {
+    updateIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>;
         type: string;
     }) => void;
-    updateIssueTypeFieldsAttachments: <TState_6 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_6, action: {
+    updateIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    deleteIssueTypeFieldsAttachment: <TState_7 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueTypeFieldsAttachments: <TState_8 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueTypeFieldsAttachments">;
-export declare const initializeIssueTypeFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">, addIssueTypeFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">, addIssueTypeFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">, setIssueTypeFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">, setIssueTypeFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">, updateIssueTypeFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">, updateIssueTypeFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachments">, deleteIssueTypeFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachment">, deleteIssueTypeFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachments">;
+    deleteIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeFieldsAttachments", "issueTypeFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldsAttachmentState>>;
+export declare const initializeIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">, addIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">, addIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">, setIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">, setIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">, updateIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">, updateIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachments">, deleteIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachment">, deleteIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachments">;
 export declare const selectIssueTypeFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldsAttachment>>;
-export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState) => Stored<IssueTypeFieldsAttachment>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFieldsAttachment>>) => Stored<IssueTypeFieldsAttachment>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState) => Stored<IssueTypeFieldsAttachment>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldsAttachment>>) => Stored<IssueTypeFieldsAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldsAttachment>>) => Stored<IssueTypeFieldsAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldsAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldsAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment[]>;
 export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment | undefined>;

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { IssueTypeFields, IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFields, IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type IssueTypeFieldsState = ModelState<Stored<IssueTypeFields>>;
-export declare const issueTypeFieldsSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldsState, {
-    initializeIssueTypeFields: <TState extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+export declare const issueTypeFieldsSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldsState, {
+    initializeIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    addIssueTypeFields: <TState_1 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_1, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+    addIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addIssueTypeFieldsMany: <TState_2 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_2, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+    addIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    setIssueTypeFields: <TState_3 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_3, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+    setIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    setIssueTypeFieldsMany: <TState_4 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_4, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+    setIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    updateIssueTypeFields: <TState_5 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_5, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+    updateIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    updateIssueTypeFieldsMany: <TState_6 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_6, action: {
-        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+    updateIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    deleteIssueTypeFields: <TState_7 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueTypeFieldsMany: <TState_8 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueTypeFields">;
-export declare const initializeIssueTypeFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[], "issueTypeFields/initializeIssueTypeFields">, addIssueTypeFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>, "issueTypeFields/addIssueTypeFields">, addIssueTypeFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[], "issueTypeFields/addIssueTypeFieldsMany">, setIssueTypeFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>, "issueTypeFields/setIssueTypeFields">, setIssueTypeFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[], "issueTypeFields/setIssueTypeFieldsMany">, updateIssueTypeFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>, "issueTypeFields/updateIssueTypeFields">, updateIssueTypeFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[], "issueTypeFields/updateIssueTypeFieldsMany">, deleteIssueTypeFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueTypeFields/deleteIssueTypeFields">, deleteIssueTypeFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "issueTypeFields/deleteIssueTypeFieldsMany">;
-export declare const selectIssueTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>;
-export declare const selectIssueTypeFields: ((state: OvermapRootState) => Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>) => Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[], {
-    clearCache: () => void;
-}> & {
+    deleteIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeFields", "issueTypeFields", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldsState>>;
+export declare const initializeIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/initializeIssueTypeFields">, addIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>, "issueTypeFields/addIssueTypeFields">, addIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/addIssueTypeFieldsMany">, setIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>, "issueTypeFields/setIssueTypeFields">, setIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/setIssueTypeFieldsMany">, updateIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>, "issueTypeFields/updateIssueTypeFields">, updateIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/updateIssueTypeFieldsMany">, deleteIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFields/deleteIssueTypeFields">, deleteIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFields/deleteIssueTypeFieldsMany">;
+export declare const selectIssueTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectIssueTypeFields: ((state: OvermapRootState) => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFields<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 selectIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields>[]>;
 export declare const selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, IssueTypeFields | undefined>;

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

@@ -1,30 +1,28 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Issue, IssueType, Organization, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Issue, IssueType, Organization, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type IssueTypeState = ModelState<Stored<IssueType>>;
-export declare const issueTypeSlice: import("@reduxjs/toolkit").Slice<IssueTypeState, {
-    initializeIssueTypes: <TState extends ModelState<Stored<IssueType>>>(state: TState, action: {
+export declare const issueTypeSlice: import('@reduxjs/toolkit').Slice<IssueTypeState, {
+    initializeIssueTypes: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>[];
         type: string;
     }) => void;
-    setIssueType: <TState_1 extends ModelState<Stored<IssueType>>>(state: TState_1, action: {
+    setIssueType: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>;
         type: string;
     }) => void;
-    addIssueType: <TState_2 extends ModelState<Stored<IssueType>>>(state: TState_2, action: {
+    addIssueType: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>;
         type: string;
     }) => void;
-    updateIssueType: <TState_3 extends ModelState<Stored<IssueType>>>(state: TState_3, action: {
+    updateIssueType: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>;
         type: string;
     }) => void;
-    removeIssueType: <TState_4 extends ModelState<Stored<IssueType>>>(state: TState_4, action: {
-        payload: string;
-        type: string;
-    }) => void;
-}, "issueTypes">;
-export declare const initializeIssueTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/initializeIssueTypes">, setIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/setIssueType">, addIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/addIssueType">, updateIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/updateIssueType">, removeIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueTypes/removeIssueType">;
+    removeIssueType: (state: ModelState<Stored<IssueType>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "issueTypes", "issueTypes", import('@reduxjs/toolkit').SliceSelectors<IssueTypeState>>;
+export declare const initializeIssueTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/initializeIssueTypes">, setIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/setIssueType">, addIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/addIssueType">, updateIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/updateIssueType">, removeIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypes/removeIssueType">;
 export declare const selectIssueTypeMapping: OvermapSelector<IssueTypeState["instances"]>;
 export declare const selectIssueTypes: OvermapSelector<Stored<IssueType>[]>;
 export declare const selectIssueTypeById: OvermapSelectorWithArgs<string, Stored<IssueType> | undefined>;

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

@@ -1,34 +1,29 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { IssueUpdate, OvermapRootState, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueUpdate, OvermapRootState, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type IssueUpdateState = ModelState<Stored<IssueUpdate>>;
-export declare const issueUpdateSlice: import("@reduxjs/toolkit").Slice<IssueUpdateState, {
-    initializeIssueUpdates: <TState extends ModelState<Stored<IssueUpdate>>>(state: TState, action: {
+export declare const issueUpdateSlice: import('@reduxjs/toolkit').Slice<IssueUpdateState, {
+    initializeIssueUpdates: (state: ModelState<Stored<IssueUpdate>>, action: {
         payload: Stored<IssueUpdate>[];
         type: string;
     }) => void;
-    setIssueUpdate: <TState_1 extends ModelState<Stored<IssueUpdate>>>(state: TState_1, action: {
+    setIssueUpdate: (state: ModelState<Stored<IssueUpdate>>, action: {
         payload: Stored<IssueUpdate>;
         type: string;
     }) => void;
-    addIssueUpdate: <TState_2 extends ModelState<Stored<IssueUpdate>>>(state: TState_2, action: {
+    addIssueUpdate: (state: ModelState<Stored<IssueUpdate>>, action: {
         payload: Stored<IssueUpdate>;
         type: string;
     }) => void;
-    addIssueUpdates: <TState_3 extends ModelState<Stored<IssueUpdate>>>(state: TState_3, action: {
+    addIssueUpdates: (state: ModelState<Stored<IssueUpdate>>, action: {
         payload: Stored<IssueUpdate>[];
         type: string;
     }) => void;
-    deleteIssueUpdate: <TState_4 extends ModelState<Stored<IssueUpdate>>>(state: TState_4, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueUpdates: <TState_5 extends ModelState<Stored<IssueUpdate>>>(state: TState_5, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueUpdates">;
-export declare const initializeIssueUpdates: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueUpdate>[], "issueUpdates/initializeIssueUpdates">, setIssueUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueUpdate>, "issueUpdates/setIssueUpdate">, addIssueUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueUpdate>, "issueUpdates/addIssueUpdate">, addIssueUpdates: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueUpdate>[], "issueUpdates/addIssueUpdates">, deleteIssueUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueUpdates/deleteIssueUpdate">, deleteIssueUpdates: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "issueUpdates/deleteIssueUpdates">;
+    deleteIssueUpdate: (state: ModelState<Stored<IssueUpdate>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueUpdates: (state: ModelState<Stored<IssueUpdate>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueUpdates", "issueUpdates", import('@reduxjs/toolkit').SliceSelectors<IssueUpdateState>>;
+export declare const initializeIssueUpdates: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueUpdate>[], "issueUpdates/initializeIssueUpdates">, setIssueUpdate: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueUpdate>, "issueUpdates/setIssueUpdate">, addIssueUpdate: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueUpdate>, "issueUpdates/addIssueUpdate">, addIssueUpdates: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueUpdate>[], "issueUpdates/addIssueUpdates">, deleteIssueUpdate: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueUpdates/deleteIssueUpdate">, deleteIssueUpdates: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueUpdates/deleteIssueUpdates">;
 export declare const selectIssueUpdateMapping: (state: OvermapRootState) => Record<string, Stored<IssueUpdate>>;
 export declare const selectIssueUpdatesOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueUpdate>[];
 export declare const issueUpdateReducer: Reducer<IssueUpdateState>;

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

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

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

@@ -1,23 +1,21 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../../typings';
-import type { OrganizationAccess, User } from '../../typings/models';
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../../typings';
+import { OrganizationAccess, User } from '../../typings/models';
+import { ModelState } from '../typings';
+
 export type OrganizationAccessState = ModelState<OrganizationAccess>;
-export declare const organizationAccessSlice: import("@reduxjs/toolkit").Slice<OrganizationAccessState, {
-    initializeOrganizationAccesses: <TState extends ModelState<OrganizationAccess>>(state: TState, action: {
+export declare const organizationAccessSlice: import('@reduxjs/toolkit').Slice<OrganizationAccessState, {
+    initializeOrganizationAccesses: (state: ModelState<OrganizationAccess>, action: {
         payload: OrganizationAccess[];
         type: string;
     }) => void;
-    updateOrganizationAccess: <TState_1 extends ModelState<OrganizationAccess>>(state: TState_1, action: {
+    updateOrganizationAccess: (state: ModelState<OrganizationAccess>, action: {
         payload: OrganizationAccess;
         type: string;
     }) => void;
-    deleteOrganizationAccess: <TState_2 extends ModelState<OrganizationAccess>>(state: TState_2, action: {
-        payload: string;
-        type: string;
-    }) => void;
-}, "organizationAccess">;
-export declare const initializeOrganizationAccesses: import("@reduxjs/toolkit").ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/initializeOrganizationAccesses">, updateOrganizationAccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<OrganizationAccess, "organizationAccess/updateOrganizationAccess">, deleteOrganizationAccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "organizationAccess/deleteOrganizationAccess">;
+    deleteOrganizationAccess: (state: ModelState<OrganizationAccess>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "organizationAccess", "organizationAccess", import('@reduxjs/toolkit').SliceSelectors<OrganizationAccessState>>;
+export declare const initializeOrganizationAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/initializeOrganizationAccesses">, updateOrganizationAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess, "organizationAccess/updateOrganizationAccess">, deleteOrganizationAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "organizationAccess/deleteOrganizationAccess">;
 export declare const selectOrganizationAccesses: (state: OvermapRootState) => Record<string, OrganizationAccess>;
 export declare const selectOrganizationAccessById: OvermapSelectorWithArgs<string, OrganizationAccess | undefined>;
 export declare const selectActiveOrganizationAccess: OvermapSelector<OrganizationAccess | null>;

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

@@ -1,18 +1,35 @@
-import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import type { OvermapSelector, OvermapSelectorWithArgs } from '../../typings/store';
-import type { License, Organization, OvermapRootState, Project, User } from "../../typings";
+import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { OvermapSelector, OvermapSelectorWithArgs } from '../../typings/store';
+import { License, Organization, OvermapRootState, Project, User } from '../../typings';
+
 export interface OrganizationState {
     organizations: Record<number, Organization>;
 }
-export declare const organizationSlice: import("@reduxjs/toolkit").Slice<OrganizationState, {
-    setOrganizations: (state: import("immer/dist/internal.js").WritableDraft<OrganizationState>, action: PayloadAction<Organization[]>) => void;
-}, "organizations">;
-export declare const setOrganizations: import("@reduxjs/toolkit").ActionCreatorWithPayload<Organization[], "organizations/setOrganizations">;
+export declare const organizationSlice: import('@reduxjs/toolkit').Slice<OrganizationState, {
+    setOrganizations: (state: import('immer').WritableDraft<OrganizationState>, action: PayloadAction<Organization[]>) => void;
+}, "organizations", "organizations", import('@reduxjs/toolkit').SliceSelectors<OrganizationState>>;
+export declare const setOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/setOrganizations">;
 export declare const selectOrganizationsMapping: OvermapSelector<Record<number, Organization>>;
-export declare const selectOrganizations: ((state: OvermapRootState) => Organization[]) & import("reselect").OutputSelectorFields<(args_0: Record<number, Organization>) => Organization[], {
-    clearCache: () => void;
-}> & {
+export declare const selectOrganizations: ((state: OvermapRootState) => Organization[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<number, Organization>) => Organization[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<number, Organization>) => Organization[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Organization[];
+    dependencies: [OvermapSelector<Record<number, Organization>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectOrganizationById: OvermapSelectorWithArgs<number, Organization | undefined>;
 export declare const selectOrganizationsWithAccess: OvermapSelector<Organization[]>;

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

@@ -1,8 +1,8 @@
-import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import type { FullOfflineAction } from "../store";
-import type { RequestDetails } from "../../sdk";
-import { SDKRequest } from "../../sdk";
-import type { OvermapRootState } from "../../typings";
+import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { FullOfflineAction } from '../store';
+import { RequestDetails, SDKRequest } from '../../sdk';
+import { OvermapRootState } from '../../typings';
+
 export declare const createOfflineAction: (request: SDKRequest, baseUrl: string, serviceName: string) => FullOfflineAction;
 export interface OutboxState {
     /** A list of requests marked for deletion. Once the offline slice encounters one of these, */
@@ -16,26 +16,26 @@ export interface OutboxState {
  * "dump" no-op actions for enqueueing requests to the outbox. At the same time, we can use this slice to keep track of
  * requests that have been marked for deletion, so that we can skip them instead of sending the request.
  */
-export declare const outboxSlice: import("@reduxjs/toolkit").Slice<OutboxState, {
+export declare const outboxSlice: import('@reduxjs/toolkit').Slice<OutboxState, {
     enqueueRequest: {
-        reducer: (state: import("immer/dist/internal.js").WritableDraft<OutboxState>, _action: PayloadAction<RequestDetails>) => import("immer/dist/internal.js").WritableDraft<OutboxState>;
+        reducer: (state: import('immer').WritableDraft<OutboxState>, _action: PayloadAction<RequestDetails>) => import('immer').WritableDraft<OutboxState>;
         prepare: (payload: SDKRequest & {
             BASE_URL: string;
             serviceName: string;
         }) => FullOfflineAction;
     };
-    markForDeletion(state: import("immer/dist/internal.js").WritableDraft<OutboxState>, action: PayloadAction<string>): void;
-    markAsDeleted(state: import("immer/dist/internal.js").WritableDraft<OutboxState>, action: PayloadAction<string>): void;
-    _setLatestRetryTime: (state: import("immer/dist/internal.js").WritableDraft<OutboxState>, action: PayloadAction<number>) => void;
-}, "outbox">;
+    markForDeletion(state: import('immer').WritableDraft<OutboxState>, action: PayloadAction<string>): void;
+    markAsDeleted(state: import('immer').WritableDraft<OutboxState>, action: PayloadAction<string>): void;
+    _setLatestRetryTime: (state: import('immer').WritableDraft<OutboxState>, action: PayloadAction<number>) => void;
+}, "outbox", "outbox", import('@reduxjs/toolkit').SliceSelectors<OutboxState>>;
 export declare const selectDeletedRequests: (state: OvermapRootState) => string[];
 export declare const selectLatestRetryTime: (state: OvermapRootState) => number;
-export declare const enqueueRequest: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: Omit<RequestDetails, "uuid"> & {
-    uuid?: string | undefined;
+export declare const enqueueRequest: import('@reduxjs/toolkit').ActionCreatorWithPreparedPayload<[payload: Omit<RequestDetails, "uuid"> & {
+    uuid?: string;
 } & {
     BASE_URL: string;
     serviceName: string;
 }], RequestDetails, "outbox/enqueueRequest", never, {
-    offline: import("../store").FullOfflineMetadata;
-}>, markForDeletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "outbox/markForDeletion">, markAsDeleted: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "outbox/markAsDeleted">, _setLatestRetryTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "outbox/_setLatestRetryTime">;
+    offline: import('..').FullOfflineMetadata;
+}>, markForDeletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "outbox/markForDeletion">, markAsDeleted: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "outbox/markAsDeleted">, _setLatestRetryTime: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "outbox/_setLatestRetryTime">;
 export declare const outboxReducer: Reducer<OutboxState>;