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

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

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

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

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

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

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

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,39 +1,50 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { FormRevision, OvermapRootState, 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>;

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

@@ -1,47 +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 selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
 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,46 +1,41 @@
-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>;