@overmap-ai/core 1.0.74-gcs.2 → 1.0.74-geojson-layers.1

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

@@ -1,37 +1,43 @@
 import { AssetTypeFields, AssetTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeFieldsAttachmentState = ModelState<Stored<AssetTypeFieldsAttachment>>;
+export type AssetTypeFieldsAttachmentState = ModelState<AssetTypeFieldsAttachment["uuid"], Stored<AssetTypeFieldsAttachment>>;
 export declare const assetTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsAttachmentState, {
-    initializeAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    initializeAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    addAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>;
         type: string;
     }) => void;
-    addAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    addAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    setAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>;
         type: string;
     }) => void;
-    setAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    setAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    updateAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+    updateAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
         payload: Stored<AssetTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetTypeFieldsAttachment: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsAttachments: (state: ModelState<string, Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypeFieldsAttachments", "assetTypeFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsAttachmentState>>;
 export declare const initializeAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/initializeAssetTypeFieldsAttachments">, addAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/addAssetTypeFieldsAttachment">, addAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/addAssetTypeFieldsAttachments">, setAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/setAssetTypeFieldsAttachment">, setAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/setAssetTypeFieldsAttachments">, updateAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachment">, updateAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachments">, deleteAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachment">, deleteAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachments">;
 export declare const selectAssetTypeFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldsAttachment>>;

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

@@ -1,53 +1,59 @@
 import { AssetType, AssetTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeFieldsState = ModelState<Stored<AssetTypeFields>>;
+export type AssetTypeFieldsState = ModelState<AssetTypeFields["uuid"], Stored<AssetTypeFields>>;
 export declare const assetTypeFieldsSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsState, {
-    initializeAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    initializeAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>[];
         type: string;
     }) => void;
-    addAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+    addAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>;
         type: string;
     }) => void;
-    addAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    addAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>[];
         type: string;
     }) => void;
-    setAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+    setAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>;
         type: string;
     }) => void;
-    setAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    setAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>[];
         type: string;
     }) => void;
-    updateAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+    updateAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>;
         type: string;
     }) => void;
-    updateAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    updateAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: Stored<AssetTypeFields>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields>>, action: {
+        payload: string[];
         type: string;
     }) => void;
-    deleteAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "assetTypeFields", "assetTypeFields", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsState>>;
-export declare const initializeAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/initializeAssetTypeFields">, addAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/addAssetTypeFields">, addAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/addAssetTypeFieldsMany">, setAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/setAssetTypeFields">, setAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/setAssetTypeFieldsMany">, updateAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/updateAssetTypeFields">, updateAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/updateAssetTypeFieldsMany">, deleteAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFields/deleteAssetTypeFields">, deleteAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFields/deleteAssetTypeFieldsMany">;
-export declare const selectAssetTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>;
-export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+export declare const initializeAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>[], "assetTypeFields/initializeAssetTypeFields">, addAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>, "assetTypeFields/addAssetTypeFields">, addAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>[], "assetTypeFields/addAssetTypeFieldsMany">, setAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>, "assetTypeFields/setAssetTypeFields">, setAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>[], "assetTypeFields/setAssetTypeFieldsMany">, updateAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>, "assetTypeFields/updateAssetTypeFields">, updateAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields>[], "assetTypeFields/updateAssetTypeFieldsMany">, deleteAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFields/deleteAssetTypeFields">, deleteAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFields/deleteAssetTypeFieldsMany">;
+export declare const selectAssetTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFields>>;
+export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored<AssetTypeFields>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFields>>) => Stored<AssetTypeFields>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFields>>) => Stored<AssetTypeFields>[]) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
-    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>];
+    lastResult: () => Stored<AssetTypeFields>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFields>>];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;

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

@@ -1,37 +1,43 @@
 import { AssetType, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetTypeState = ModelState<Stored<AssetType>>;
+export type AssetTypeState = ModelState<AssetType["uuid"], Stored<AssetType>>;
 export declare const assetTypeSlice: import('@reduxjs/toolkit').Slice<AssetTypeState, {
-    initializeAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    initializeAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    setAssetType: (state: ModelState<Stored<AssetType>>, action: {
+    setAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    setAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    setAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    addAssetType: (state: ModelState<Stored<AssetType>>, action: {
+    addAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    addAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    addAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    updateAssetType: (state: ModelState<Stored<AssetType>>, action: {
+    updateAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>;
         type: string;
     }) => void;
-    updateAssetTypes: (state: ModelState<Stored<AssetType>>, action: {
+    updateAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
         payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    deleteAssetType: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetTypes: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetType: (state: ModelState<string, Stored<AssetType>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypes: (state: ModelState<string, Stored<AssetType>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetTypes", "assetTypes", import('@reduxjs/toolkit').SliceSelectors<AssetTypeState>>;
 export declare const initializeAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, setAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/setAssetType">, setAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/setAssetTypes">, addAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, addAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/addAssetTypes">, updateAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/updateAssetType">, updateAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/updateAssetTypes">, deleteAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, deleteAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypes/deleteAssetTypes">;
 export declare const selectAssetTypesMapping: OvermapSelector<Record<string, Stored<AssetType>>>;

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

@@ -1,20 +1,23 @@
 import { Category, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type CategoryState = ModelState<Stored<Category>>;
+export type CategoryState = ModelState<Category["uuid"], Stored<Category>>;
 export declare const categorySlice: import('@reduxjs/toolkit').Slice<CategoryState, {
-    initializeCategories: (state: ModelState<Stored<Category>>, action: {
+    initializeCategories: (state: ModelState<string, Stored<Category>>, action: {
         payload: Stored<Category>[];
         type: string;
     }) => void;
-    addCategory: (state: ModelState<Stored<Category>>, action: {
+    addCategory: (state: ModelState<string, Stored<Category>>, action: {
         payload: Stored<Category>;
         type: string;
     }) => void;
-    updateCategory: (state: ModelState<Stored<Category>>, action: {
+    updateCategory: (state: ModelState<string, Stored<Category>>, action: {
         payload: Stored<Category>;
         type: string;
     }) => void;
-    deleteCategory: (state: ModelState<Stored<Category>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteCategory: (state: ModelState<string, Stored<Category>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
 }, "categories", "categories", import('@reduxjs/toolkit').SliceSelectors<CategoryState>>;
 export declare const initializeCategories: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>[], "categories/initializeCategories">, addCategory: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/addCategory">, updateCategory: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/updateCategory">, deleteCategory: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "categories/deleteCategory">;
 export declare const selectCategoryMapping: (state: OvermapRootState) => Record<string, Stored<Category>>;

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

@@ -1,37 +1,43 @@
 import { DocumentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type DocumentAttachmentState = ModelState<Stored<DocumentAttachment>>;
+export type DocumentAttachmentState = ModelState<DocumentAttachment["uuid"], Stored<DocumentAttachment>>;
 export declare const documentAttachmentSlice: import('@reduxjs/toolkit').Slice<DocumentAttachmentState, {
-    initializeDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    initializeDocumentAttachments: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    addDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    addDocumentAttachment: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>;
         type: string;
     }) => void;
-    addDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    addDocumentAttachments: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    setDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    setDocumentAttachment: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>;
         type: string;
     }) => void;
-    setDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    setDocumentAttachments: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    updateDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    updateDocumentAttachment: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>;
         type: string;
     }) => void;
-    updateDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
+    updateDocumentAttachments: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
         payload: Stored<DocumentAttachment>[];
         type: string;
     }) => void;
-    deleteDocumentAttachment: (state: ModelState<Stored<DocumentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteDocumentAttachment: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteDocumentAttachments: (state: ModelState<string, Stored<DocumentAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "documentAttachments", "documentAttachments", import('@reduxjs/toolkit').SliceSelectors<DocumentAttachmentState>>;
 export declare const initializeDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">, addDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/addDocumentAttachment">, addDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">, setDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">, setDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/setDocumentAttachments">, updateDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/updateDocumentAttachment">, updateDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">, deleteDocumentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">, deleteDocumentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
 export declare const selectDocumentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<DocumentAttachment>>;

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

@@ -0,0 +1,42 @@
+import { EmailDomain, OvermapRootState, OvermapSelector, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type EmailDomainState = ModelState<EmailDomain["uuid"], Stored<EmailDomain>>;
+export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<EmailDomainState, {
+    initializeEmailDomains: (state: ModelState<string, Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>[];
+        type: string;
+    }) => void;
+    addEmailDomain: (state: ModelState<string, Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>;
+        type: string;
+    }) => void;
+    deleteEmailDomain: (state: ModelState<string, Stored<EmailDomain>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<EmailDomainState>>;
+export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<EmailDomain>[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<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[]) & {
+    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: string) => (state: OvermapRootState) => Stored<EmailDomain>[];
+export declare const emailDomainsReducer: import('redux').Reducer<EmailDomainState>;

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

@@ -1,37 +1,43 @@
 import { FormRevision, FormRevisionAttachment, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type FormRevisionAttachmentState = ModelState<Stored<FormRevisionAttachment>>;
+export type FormRevisionAttachmentState = ModelState<FormRevisionAttachment["uuid"], Stored<FormRevisionAttachment>>;
 export declare const formRevisionAttachmentSlice: import('@reduxjs/toolkit').Slice<FormRevisionAttachmentState, {
-    initializeFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    initializeFormRevisionAttachments: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    addFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    addFormRevisionAttachment: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>;
         type: string;
     }) => void;
-    addFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    addFormRevisionAttachments: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    setFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    setFormRevisionAttachment: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>;
         type: string;
     }) => void;
-    setFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    setFormRevisionAttachments: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    updateFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    updateFormRevisionAttachment: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>;
         type: string;
     }) => void;
-    updateFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: {
+    updateFormRevisionAttachments: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
         payload: Stored<FormRevisionAttachment>[];
         type: string;
     }) => void;
-    deleteFormRevisionAttachment: (state: ModelState<Stored<FormRevisionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteFormRevisionAttachments: (state: ModelState<Stored<FormRevisionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteFormRevisionAttachment: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteFormRevisionAttachments: (state: ModelState<string, Stored<FormRevisionAttachment>>, action: {
+        payload: string[];
+        type: 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"]>;

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

@@ -1,41 +1,47 @@
 import { Form, FormRevision, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type FormRevisionState = ModelState<Stored<FormRevision>>;
+export type FormRevisionState = ModelState<FormRevision["uuid"], Stored<FormRevision>>;
 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>>[];
+    initializeFormRevisions: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>[];
         type: string;
     }) => void;
-    setFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
+    setFormRevision: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>;
         type: string;
     }) => void;
-    addFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
+    addFormRevision: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>;
         type: string;
     }) => void;
-    addFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
+    addFormRevisions: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>[];
+        type: string;
+    }) => void;
+    deleteFormRevision: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteFormRevisions: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: string[];
         type: string;
     }) => 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>>[]) & {
+export declare const setFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>, "formRevisions/setFormRevision">, initializeFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>[], "formRevisions/initializeFormRevisions">, addFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>, "formRevisions/addFormRevision">, addFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>[], "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>>;
+export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<FormRevision>[]) & {
     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>>[]) & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<FormRevision>>) => Stored<FormRevision>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<FormRevision>>) => Stored<FormRevision>[]) & {
         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>>>];
+    lastResult: () => Stored<FormRevision>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<FormRevision>>];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;

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

@@ -1,28 +1,31 @@
 import { Form, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type FormState = ModelState<Stored<Form>>;
+export type FormState = ModelState<Form["uuid"], Stored<Form>>;
 export declare const formSlice: import('@reduxjs/toolkit').Slice<FormState, {
-    initializeForms: (state: ModelState<Stored<Form>>, action: {
+    initializeForms: (state: ModelState<string, Stored<Form>>, action: {
         payload: Stored<Form>[];
         type: string;
     }) => void;
-    setForm: (state: ModelState<Stored<Form>>, action: {
+    setForm: (state: ModelState<string, Stored<Form>>, action: {
         payload: Stored<Form>;
         type: string;
     }) => void;
-    addForm: (state: ModelState<Stored<Form>>, action: {
+    addForm: (state: ModelState<string, Stored<Form>>, action: {
         payload: Stored<Form>;
         type: string;
     }) => void;
-    addForms: (state: ModelState<Stored<Form>>, action: {
+    addForms: (state: ModelState<string, Stored<Form>>, action: {
         payload: Stored<Form>[];
         type: string;
     }) => void;
-    updateForm: (state: ModelState<Stored<Form>>, action: {
+    updateForm: (state: ModelState<string, Stored<Form>>, action: {
         payload: Stored<Form>;
         type: string;
     }) => void;
-    deleteForm: (state: ModelState<Stored<Form>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteForm: (state: ModelState<string, Stored<Form>>, action: {
+        payload: string;
+        type: 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: import('redux').Reducer<FormState>;

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

@@ -1,37 +1,43 @@
 import { FormSubmission, FormSubmissionAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type FormSubmissionAttachmentState = ModelState<Stored<FormSubmissionAttachment>>;
+export type FormSubmissionAttachmentState = ModelState<FormSubmissionAttachment["uuid"], Stored<FormSubmissionAttachment>>;
 export declare const formSubmissionAttachmentSlice: import('@reduxjs/toolkit').Slice<FormSubmissionAttachmentState, {
-    initializeFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    initializeFormSubmissionAttachments: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    addFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    addFormSubmissionAttachment: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>;
         type: string;
     }) => void;
-    addFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    addFormSubmissionAttachments: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    setFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    setFormSubmissionAttachment: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>;
         type: string;
     }) => void;
-    setFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    setFormSubmissionAttachments: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    updateFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    updateFormSubmissionAttachment: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>;
         type: string;
     }) => void;
-    updateFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: {
+    updateFormSubmissionAttachments: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
         payload: Stored<FormSubmissionAttachment>[];
         type: string;
     }) => void;
-    deleteFormSubmissionAttachment: (state: ModelState<Stored<FormSubmissionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteFormSubmissionAttachments: (state: ModelState<Stored<FormSubmissionAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteFormSubmissionAttachment: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteFormSubmissionAttachments: (state: ModelState<string, Stored<FormSubmissionAttachment>>, action: {
+        payload: string[];
+        type: 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"]>;