@overmap-ai/core 1.0.71-mapbox.5 → 1.0.71-mapbox.7

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 {};

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

@@ -1,46 +1,41 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
-import type { FormRevisionAttachment, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { ModelState } from '../typings';
+import { FormRevisionAttachment, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+
 export type FormRevisionAttachmentState = ModelState<Stored<FormRevisionAttachment>>;
-export declare const formRevisionAttachmentSlice: import("@reduxjs/toolkit").Slice<FormRevisionAttachmentState, {
-    initializeFormRevisionAttachments: <TState extends ModelState<Stored<FormRevisionAttachment>>>(state: TState, action: {
+export declare const formRevisionAttachmentSlice: import('@reduxjs/toolkit').Slice<FormRevisionAttachmentState, {
+    initializeFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    addFormRevisionAttachment: <TState_1 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_1, action: {
+    addFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>;
         type: string;
     }) => void;
-    addFormRevisionAttachments: <TState_2 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_2, action: {
+    addFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    setFormRevisionAttachment: <TState_3 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_3, action: {
+    setFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>;
         type: string;
     }) => void;
-    setFormRevisionAttachments: <TState_4 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_4, action: {
+    setFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    updateFormRevisionAttachment: <TState_5 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_5, action: {
+    updateFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>;
         type: string;
     }) => void;
-    updateFormRevisionAttachments: <TState_6 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_6, action: {
+    updateFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    deleteFormRevisionAttachment: <TState_7 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteFormRevisionAttachments: <TState_8 extends ModelState<Stored<FormRevisionAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "formRevisionAttachments">;
-export declare const initializeFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/initializeFormRevisionAttachments">, addFormRevisionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/addFormRevisionAttachment">, addFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/addFormRevisionAttachments">, setFormRevisionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/setFormRevisionAttachment">, setFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/setFormRevisionAttachments">, updateFormRevisionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/updateFormRevisionAttachment">, updateFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/updateFormRevisionAttachments">, deleteFormRevisionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "formRevisionAttachments/deleteFormRevisionAttachment">, deleteFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "formRevisionAttachments/deleteFormRevisionAttachments">;
+    deleteFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "formRevisionAttachments", "formRevisionAttachments", import('@reduxjs/toolkit').SliceSelectors<FormRevisionAttachmentState>>;
+export declare const initializeFormRevisionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/initializeFormRevisionAttachments">, addFormRevisionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/addFormRevisionAttachment">, addFormRevisionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/addFormRevisionAttachments">, setFormRevisionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/setFormRevisionAttachment">, setFormRevisionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/setFormRevisionAttachments">, updateFormRevisionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/updateFormRevisionAttachment">, updateFormRevisionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/updateFormRevisionAttachments">, deleteFormRevisionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formRevisionAttachments/deleteFormRevisionAttachment">, deleteFormRevisionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formRevisionAttachments/deleteFormRevisionAttachments">;
 export declare const selectFormRevisionAttachmentsMapping: OvermapSelector<FormRevisionAttachmentState["instances"]>;
 export declare const selectAttachmentsOfFormRevision: OvermapSelectorWithArgs<string, Stored<FormRevisionAttachment>[]>;
 export declare const formRevisionAttachmentReducer: Reducer<FormRevisionAttachmentState>;

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

@@ -1,43 +1,53 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Form, FormRevision, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { FormRevision, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type FormRevisionState = ModelState<Stored<FormRevision>>;
-export declare const formRevisionsSlice: import("@reduxjs/toolkit").Slice<FormRevisionState, {
-    initializeFormRevisions: <TState extends ModelState<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>>(state: TState, action: {
-        payload: Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>[];
+export declare const formRevisionsSlice: import('@reduxjs/toolkit').Slice<FormRevisionState, {
+    initializeFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    setFormRevision: <TState_1 extends ModelState<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_1, action: {
-        payload: Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>;
+    setFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addFormRevision: <TState_2 extends ModelState<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_2, action: {
-        payload: Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>;
+    addFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addFormRevisions: <TState_3 extends ModelState<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_3, action: {
-        payload: Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>[];
+    addFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    deleteFormRevision: <TState_4 extends ModelState<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_4, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteFormRevisions: <TState_5 extends ModelState<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_5, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "formRevisions">;
-export declare const setFormRevision: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>, "formRevisions/setFormRevision">, initializeFormRevisions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>[], "formRevisions/initializeFormRevisions">, addFormRevision: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>, "formRevisions/addFormRevision">, addFormRevisions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>[], "formRevisions/addFormRevisions">, deleteFormRevision: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "formRevisions/deleteFormRevision">, deleteFormRevisions: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisions">;
-export declare const selectFormRevisionMapping: (state: OvermapRootState) => Record<string, Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>;
-export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>>) => Stored<FormRevision<import("@overmap-ai/forms").ISerializedField>>[], {
-    clearCache: () => void;
-}> & {
+    deleteFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "formRevisions", "formRevisions", import('@reduxjs/toolkit').SliceSelectors<FormRevisionState>>;
+export declare const setFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>, "formRevisions/setFormRevision">, initializeFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[], "formRevisions/initializeFormRevisions">, addFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>, "formRevisions/addFormRevision">, addFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[], "formRevisions/addFormRevisions">, deleteFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formRevisions/deleteFormRevision">, deleteFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisions">;
+export declare const selectFormRevisionMapping: (state: OvermapRootState) => Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>) => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>) => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<FormRevision<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 selectFormRevisionById: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
 export declare const _selectLatestFormRevision: (formRevisions: FormRevisionState["instances"], formId: string) => Stored<FormRevision>;
 export declare const selectLatestFormRevisionOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
 export declare const selectFormRevisionsOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision>[]>;
-export declare const selectLatestFormRevisionByForm: OvermapSelector<Record<Stored<Form>["offline_id"], Stored<FormRevision>>>;
 export declare const formRevisionReducer: Reducer<FormRevisionState>;

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

@@ -1,51 +1,61 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Form } from '../../typings/models/forms';
-import type { SearchArgs } from '../../typings/search';
-import type { OvermapSelector, OvermapSelectorWithArgs } from '../../typings/store';
-import type { OvermapRootState, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Form } from '../../typings/models/forms';
+import { SearchArgs } from '../../typings/search';
+import { OvermapSelector, OvermapSelectorWithArgs } from '../../typings/store';
+import { OvermapRootState, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type FormState = ModelState<Stored<Form>>;
-export declare const formSlice: import("@reduxjs/toolkit").Slice<FormState, {
-    initializeForms: <TState extends ModelState<Stored<Form>>>(state: TState, action: {
+export declare const formSlice: import('@reduxjs/toolkit').Slice<FormState, {
+    initializeForms: (state: ModelState<Stored<Form>>, action: {
         payload: Stored<Form>[];
         type: string;
     }) => void;
-    setForm: <TState_1 extends ModelState<Stored<Form>>>(state: TState_1, action: {
+    setForm: (state: ModelState<Stored<Form>>, action: {
         payload: Stored<Form>;
         type: string;
     }) => void;
-    addForm: <TState_2 extends ModelState<Stored<Form>>>(state: TState_2, action: {
+    addForm: (state: ModelState<Stored<Form>>, action: {
         payload: Stored<Form>;
         type: string;
     }) => void;
-    addForms: <TState_3 extends ModelState<Stored<Form>>>(state: TState_3, action: {
+    addForms: (state: ModelState<Stored<Form>>, action: {
         payload: Stored<Form>[];
         type: string;
     }) => void;
-    updateForm: <TState_4 extends ModelState<Stored<Form>>>(state: TState_4, action: {
+    updateForm: (state: ModelState<Stored<Form>>, action: {
         payload: Stored<Form>;
         type: string;
     }) => void;
-    deleteForm: <TState_5 extends ModelState<Stored<Form>>>(state: TState_5, action: {
-        payload: string;
-        type: string;
-    }) => void;
-}, "forms">;
-export declare const initializeForms: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Form>[], "forms/initializeForms">, setForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Form>, "forms/setForm">, addForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Form>, "forms/addForm">, addForms: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Form>[], "forms/addForms">, updateForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Form>, "forms/updateForm">, deleteForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "forms/deleteForm">;
+    deleteForm: (state: ModelState<Stored<Form>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "forms", "forms", import('@reduxjs/toolkit').SliceSelectors<FormState>>;
+export declare const initializeForms: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>[], "forms/initializeForms">, setForm: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>, "forms/setForm">, addForm: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>, "forms/addForm">, addForms: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>[], "forms/addForms">, updateForm: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>, "forms/updateForm">, deleteForm: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "forms/deleteForm">;
 export declare const formReducer: Reducer<FormState>;
 export type FormSearchArgs = SearchArgs<{
     /** organization owner */
     organization?: number;
 }>;
 export declare const selectFormMapping: OvermapSelector<Record<Stored<Form>["offline_id"], Stored<Form>>>;
-export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<Form>>) => Stored<Form>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<Form>>) => Stored<Form>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<Form>>) => Stored<Form>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<Form>[];
+    dependencies: [OvermapSelector<Record<string, Stored<Form>>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;
 export declare const selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFormOfAssetType: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFormOfIssueType: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFormsCount: OvermapSelector<number>;
-export declare const selectGeneralFormCount: OvermapSelector<number>;
+export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;

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

@@ -1,46 +1,41 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
-import type { FormSubmissionAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { ModelState } from '../typings';
+import { FormSubmissionAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+
 export type FormSubmissionAttachmentState = ModelState<Stored<FormSubmissionAttachment>>;
-export declare const formSubmissionAttachmentSlice: import("@reduxjs/toolkit").Slice<FormSubmissionAttachmentState, {
-    initializeFormSubmissionAttachments: <TState extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState, action: {
+export declare const formSubmissionAttachmentSlice: import('@reduxjs/toolkit').Slice<FormSubmissionAttachmentState, {
+    initializeFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    addFormSubmissionAttachment: <TState_1 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_1, action: {
+    addFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>;
         type: string;
     }) => void;
-    addFormSubmissionAttachments: <TState_2 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_2, action: {
+    addFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    setFormSubmissionAttachment: <TState_3 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_3, action: {
+    setFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>;
         type: string;
     }) => void;
-    setFormSubmissionAttachments: <TState_4 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_4, action: {
+    setFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    updateFormSubmissionAttachment: <TState_5 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_5, action: {
+    updateFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>;
         type: string;
     }) => void;
-    updateFormSubmissionAttachments: <TState_6 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_6, action: {
+    updateFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    deleteFormSubmissionAttachment: <TState_7 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteFormSubmissionAttachments: <TState_8 extends ModelState<Stored<FormSubmissionAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "formSubmissionAttachments">;
-export declare const initializeFormSubmissionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/initializeFormSubmissionAttachments">, addFormSubmissionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/addFormSubmissionAttachment">, addFormSubmissionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/addFormSubmissionAttachments">, setFormSubmissionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/setFormSubmissionAttachment">, setFormSubmissionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/setFormSubmissionAttachments">, updateFormSubmissionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/updateFormSubmissionAttachment">, updateFormSubmissionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/updateFormSubmissionAttachments">, deleteFormSubmissionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "formSubmissionAttachments/deleteFormSubmissionAttachment">, deleteFormSubmissionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "formSubmissionAttachments/deleteFormSubmissionAttachments">;
+    deleteFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "formSubmissionAttachments", "formSubmissionAttachments", import('@reduxjs/toolkit').SliceSelectors<FormSubmissionAttachmentState>>;
+export declare const initializeFormSubmissionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/initializeFormSubmissionAttachments">, addFormSubmissionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/addFormSubmissionAttachment">, addFormSubmissionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/addFormSubmissionAttachments">, setFormSubmissionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/setFormSubmissionAttachment">, setFormSubmissionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/setFormSubmissionAttachments">, updateFormSubmissionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/updateFormSubmissionAttachment">, updateFormSubmissionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/updateFormSubmissionAttachments">, deleteFormSubmissionAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formSubmissionAttachments/deleteFormSubmissionAttachment">, deleteFormSubmissionAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formSubmissionAttachments/deleteFormSubmissionAttachments">;
 export declare const selectFormSubmissionAttachmentsMapping: OvermapSelector<FormSubmissionAttachmentState["instances"]>;
 export declare const selectFormSubmissionAttachemntsByIds: (args: string[]) => (state: OvermapRootState) => Stored<FormSubmissionAttachment>[];
 export declare const selectAttachmentsOfFormSubmission: OvermapSelectorWithArgs<string, Stored<FormSubmissionAttachment>[]>;

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

@@ -1,56 +1,45 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { FormSubmission, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { FormSubmission, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type FormSubmissionState = ModelState<Stored<FormSubmission>>;
-export declare const formSubmissionSlice: import("@reduxjs/toolkit").Slice<FormSubmissionState, {
-    initializeFormSubmissions: <TState extends ModelState<Stored<FormSubmission>>>(state: TState, action: {
+export declare const formSubmissionSlice: import('@reduxjs/toolkit').Slice<FormSubmissionState, {
+    initializeFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    setFormSubmission: <TState_1 extends ModelState<Stored<FormSubmission>>>(state: TState_1, action: {
+    setFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>;
         type: string;
     }) => void;
-    setFormSubmissions: <TState_2 extends ModelState<Stored<FormSubmission>>>(state: TState_2, action: {
+    setFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    addFormSubmission: <TState_3 extends ModelState<Stored<FormSubmission>>>(state: TState_3, action: {
+    addFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>;
         type: string;
     }) => void;
-    addFormSubmissions: <TState_4 extends ModelState<Stored<FormSubmission>>>(state: TState_4, action: {
+    addFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    updateFormSubmission: <TState_5 extends ModelState<Stored<FormSubmission>>>(state: TState_5, action: {
+    updateFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>;
         type: string;
     }) => void;
-    updateFormSubmissions: <TState_6 extends ModelState<Stored<FormSubmission>>>(state: TState_6, action: {
+    updateFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    deleteFormSubmission: <TState_7 extends ModelState<Stored<FormSubmission>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteFormSubmissions: <TState_8 extends ModelState<Stored<FormSubmission>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "formSubmissions">;
-export declare const initializeFormSubmissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/initializeFormSubmissions">, setFormSubmission: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/setFormSubmission">, setFormSubmissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/setFormSubmissions">, addFormSubmission: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/addFormSubmission">, addFormSubmissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/addFormSubmissions">, updateFormSubmission: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/updateFormSubmission">, updateFormSubmissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/updateFormSubmissions">, deleteFormSubmission: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "formSubmissions/deleteFormSubmission">, deleteFormSubmissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "formSubmissions/deleteFormSubmissions">;
+    deleteFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "formSubmissions", "formSubmissions", import('@reduxjs/toolkit').SliceSelectors<FormSubmissionState>>;
+export declare const initializeFormSubmissions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/initializeFormSubmissions">, setFormSubmission: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/setFormSubmission">, setFormSubmissions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/setFormSubmissions">, addFormSubmission: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/addFormSubmission">, addFormSubmissions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/addFormSubmissions">, updateFormSubmission: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/updateFormSubmission">, updateFormSubmissions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/updateFormSubmissions">, deleteFormSubmission: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formSubmissions/deleteFormSubmission">, deleteFormSubmissions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formSubmissions/deleteFormSubmissions">;
 export declare const selectFormSubmissionsMapping: OvermapSelector<FormSubmissionState["instances"]>;
 export declare const selectFormSubmissions: OvermapSelector<Stored<FormSubmission>[]>;
 export declare const selectFormSubmissionById: OvermapSelectorWithArgs<string, Stored<FormSubmission> | undefined>;
 export declare const selectFormSubmissionsOfForm: OvermapSelectorWithArgs<string, Stored<FormSubmission>[]>;
-export declare const selectFormSubmissionsByFormRevisions: OvermapSelector<Record<string, Stored<FormSubmission>[]>>;
-export declare const selectSortedFormSubmissionsOfForm: OvermapSelectorWithArgs<string, Stored<FormSubmission>[]>;
 export declare const selectFormSubmissionsOfIssue: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectAttachedFormSubmissionsOfIssue: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectFormSubmissionsByIssues: OvermapSelectorWithArgs<string[], Record<string, Stored<FormSubmission>[]>>;
 export declare const selectFormSubmissionsOfAsset: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectAttachedFormSubmissionsOfAsset: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectFormSubmissionsByAssets: OvermapSelector<Record<string, Stored<FormSubmission>[]>>;
 export declare const formSubmissionReducer: Reducer<FormSubmissionState>;

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { GeoImage, OvermapRootState, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { GeoImage, OvermapRootState, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type GeoImageSliceState = ModelState<Stored<GeoImage>>;
-export declare const geoImageSlice: import("@reduxjs/toolkit").Slice<GeoImageSliceState, {
-    initializeGeoImages: <TState extends ModelState<GeoImage>>(state: TState, action: {
+export declare const geoImageSlice: import('@reduxjs/toolkit').Slice<GeoImageSliceState, {
+    initializeGeoImages: (state: ModelState<GeoImage>, action: {
         payload: GeoImage[];
         type: string;
     }) => void;
-    setGeoImage: <TState_1 extends ModelState<GeoImage>>(state: TState_1, action: {
+    setGeoImage: (state: ModelState<GeoImage>, action: {
         payload: GeoImage;
         type: string;
     }) => void;
-    setGeoImages: <TState_2 extends ModelState<GeoImage>>(state: TState_2, action: {
+    setGeoImages: (state: ModelState<GeoImage>, action: {
         payload: GeoImage[];
         type: string;
     }) => void;
-    addGeoImage: <TState_3 extends ModelState<GeoImage>>(state: TState_3, action: {
+    addGeoImage: (state: ModelState<GeoImage>, action: {
         payload: GeoImage;
         type: string;
     }) => void;
-    addGeoImages: <TState_4 extends ModelState<GeoImage>>(state: TState_4, action: {
+    addGeoImages: (state: ModelState<GeoImage>, action: {
         payload: GeoImage[];
         type: string;
     }) => void;
-    updateGeoImage: <TState_5 extends ModelState<GeoImage>>(state: TState_5, action: {
+    updateGeoImage: (state: ModelState<GeoImage>, action: {
         payload: GeoImage;
         type: string;
     }) => void;
-    updateGeoImages: <TState_6 extends ModelState<GeoImage>>(state: TState_6, action: {
+    updateGeoImages: (state: ModelState<GeoImage>, action: {
         payload: GeoImage[];
         type: string;
     }) => void;
-    deleteGeoImage: <TState_7 extends ModelState<GeoImage>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteGeoImages: <TState_8 extends ModelState<GeoImage>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "geoImages">;
-export declare const initializeGeoImages: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage[], "geoImages/initializeGeoImages">, setGeoImage: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage, "geoImages/setGeoImage">, setGeoImages: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage[], "geoImages/setGeoImages">, addGeoImage: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage, "geoImages/addGeoImage">, addGeoImages: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage[], "geoImages/addGeoImages">, updateGeoImage: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage, "geoImages/updateGeoImage">, updateGeoImages: import("@reduxjs/toolkit").ActionCreatorWithPayload<GeoImage[], "geoImages/updateGeoImages">, deleteGeoImage: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
+    deleteGeoImage: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteGeoImages: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "geoImages", "geoImages", import('@reduxjs/toolkit').SliceSelectors<GeoImageSliceState>>;
+export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/updateGeoImages">, deleteGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
 export declare const selectGeoImageMapping: (state: OvermapRootState) => Record<string, Stored<GeoImage>>;
-export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoImage>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<GeoImage>>) => Stored<GeoImage>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoImage>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<GeoImage>>) => Stored<GeoImage>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<GeoImage>>) => Stored<GeoImage>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<GeoImage>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<GeoImage>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectGeoImageById: (id: string) => (state: OvermapRootState) => Stored<GeoImage> | undefined;
 export declare const selectGeoImagesOfProject: (args: number) => (state: OvermapRootState) => Stored<GeoImage>[];