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

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

@@ -1,37 +1,43 @@
 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: {
+    initializeAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    addAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    setAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    setAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    updateAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    updateAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    updateAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    updateAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
         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;
+    deleteAssetTypeFields: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsMany: (state: ModelState<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string[];
+        type: 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>>>;

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,25 +1,31 @@
 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: {
+    initializeFormRevisions: (state: ModelState<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
         type: string;
     }) => void;
-    setFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    setFormRevision: (state: ModelState<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addFormRevision: (state: ModelState<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
         type: string;
     }) => void;
-    addFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+    addFormRevisions: (state: ModelState<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
         payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
         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;
+    deleteFormRevision: (state: ModelState<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteFormRevisions: (state: ModelState<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: string[];
+        type: 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>>>;

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"]>;

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

@@ -1,37 +1,43 @@
 import { Form, FormSubmission, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type FormSubmissionState = ModelState<Stored<FormSubmission>>;
+export type FormSubmissionState = ModelState<FormSubmission["uuid"], Stored<FormSubmission>>;
 export declare const formSubmissionSlice: import('@reduxjs/toolkit').Slice<FormSubmissionState, {
-    initializeFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
+    initializeFormSubmissions: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    setFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: {
+    setFormSubmission: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>;
         type: string;
     }) => void;
-    setFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
+    setFormSubmissions: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    addFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: {
+    addFormSubmission: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>;
         type: string;
     }) => void;
-    addFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
+    addFormSubmissions: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    updateFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: {
+    updateFormSubmission: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>;
         type: string;
     }) => void;
-    updateFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: {
+    updateFormSubmissions: (state: ModelState<string, Stored<FormSubmission>>, action: {
         payload: Stored<FormSubmission>[];
         type: string;
     }) => void;
-    deleteFormSubmission: (state: ModelState<Stored<FormSubmission>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteFormSubmissions: (state: ModelState<Stored<FormSubmission>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteFormSubmission: (state: ModelState<string, Stored<FormSubmission>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteFormSubmissions: (state: ModelState<string, Stored<FormSubmission>>, action: {
+        payload: string[];
+        type: 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"]>;

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

@@ -1,37 +1,43 @@
 import { GeoImage, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type GeoImageSliceState = ModelState<Stored<GeoImage>>;
+export type GeoImageSliceState = ModelState<GeoImage["uuid"], Stored<GeoImage>>;
 export declare const geoImageSlice: import('@reduxjs/toolkit').Slice<GeoImageSliceState, {
-    initializeGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+    initializeGeoImages: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    setGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+    setGeoImage: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    setGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+    setGeoImages: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    addGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+    addGeoImage: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    addGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+    addGeoImages: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    updateGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+    updateGeoImage: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    updateGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+    updateGeoImages: (state: ModelState<string, Stored<GeoImage>>, action: {
         payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    deleteGeoImage: (state: ModelState<Stored<GeoImage>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteGeoImages: (state: ModelState<Stored<GeoImage>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteGeoImage: (state: ModelState<string, Stored<GeoImage>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteGeoImages: (state: ModelState<string, Stored<GeoImage>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "geoImages", "geoImages", import('@reduxjs/toolkit').SliceSelectors<GeoImageSliceState>>;
 export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<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>>;