@overmap-ai/core 1.0.74-integration-improvements.0 → 1.0.74-integration-improvements.2

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

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

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

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

@@ -1,37 +1,43 @@
 import { IssueAssociation, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueAssociationSliceState = ModelState<Stored<IssueAssociation>>;
+export type IssueAssociationSliceState = ModelState<IssueAssociation["uuid"], Stored<IssueAssociation>>;
 export declare const issueAssociationSlice: import('@reduxjs/toolkit').Slice<IssueAssociationSliceState, {
-    initializeIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    initializeIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    addIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
+    addIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    addIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    addIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    setIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
+    setIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    setIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    setIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    updateIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
+    updateIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    updateIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    updateIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    deleteIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueAssociations", "issueAssociations", import('@reduxjs/toolkit').SliceSelectors<IssueAssociationSliceState>>;
 export declare const initializeIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/initializeIssueAssociations">, setIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/setIssueAssociations">, setIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/setIssueAssociation">, updateIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/updateIssueAssociation">, updateIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/updateIssueAssociations">, addIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/addIssueAssociation">, addIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/addIssueAssociations">, deleteIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAssociations/deleteIssueAssociation">, deleteIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAssociations/deleteIssueAssociations">;
 export declare const selectIssueAssociationMapping: (state: OvermapRootState) => Record<string, Stored<IssueAssociation>>;

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

@@ -1,37 +1,43 @@
 import { IssueAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueAttachmentState = ModelState<Stored<IssueAttachment>>;
+export type IssueAttachmentState = ModelState<IssueAttachment["uuid"], Stored<IssueAttachment>>;
 export declare const issueAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueAttachmentState, {
-    initializeIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    initializeIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    addIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
+    addIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    addIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    addIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    setIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
+    setIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    setIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    setIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    updateIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
+    updateIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    updateIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    updateIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    deleteIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueAttachments", "issueAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueAttachmentState>>;
 export declare const initializeIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">, addIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/addIssueAttachment">, addIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">, setIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">, setIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/setIssueAttachments">, updateIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/updateIssueAttachment">, updateIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">, deleteIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">, deleteIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
 export declare const selectIssueAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueAttachment>>;

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

@@ -1,37 +1,43 @@
 import { IssueCommentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueCommentAttachmentState = ModelState<Stored<IssueCommentAttachment>>;
+export type IssueCommentAttachmentState = ModelState<IssueCommentAttachment["uuid"], Stored<IssueCommentAttachment>>;
 export declare const issueCommentAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueCommentAttachmentState, {
-    initializeIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    initializeIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    addIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    addIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>;
         type: string;
     }) => void;
-    addIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    addIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    setIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    setIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>;
         type: string;
     }) => void;
-    setIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    setIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    updateIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    updateIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>;
         type: string;
     }) => void;
-    updateIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    updateIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    deleteIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueCommentAttachments", "issueCommentAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueCommentAttachmentState>>;
 export declare const initializeIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">, addIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/addIssueCommentAttachment">, addIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">, setIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">, setIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/setIssueCommentAttachments">, updateIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/updateIssueCommentAttachment">, updateIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">, deleteIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">, deleteIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
 export declare const selectIssueCommentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueCommentAttachment>>;

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

@@ -1,25 +1,31 @@
 import { IssueComment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueCommentState = ModelState<Stored<IssueComment>>;
+export type IssueCommentState = ModelState<IssueComment["uuid"], Stored<IssueComment>>;
 export declare const issueCommentSlice: import('@reduxjs/toolkit').Slice<IssueCommentState, {
-    addIssueComment: (state: ModelState<Stored<IssueComment>>, action: {
+    addIssueComment: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>;
         type: string;
     }) => void;
-    addIssueComments: (state: ModelState<Stored<IssueComment>>, action: {
+    addIssueComments: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>[];
         type: string;
     }) => void;
-    setIssueComment: (state: ModelState<Stored<IssueComment>>, action: {
+    setIssueComment: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>;
         type: string;
     }) => void;
-    setIssueComments: (state: ModelState<Stored<IssueComment>>, action: {
+    setIssueComments: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>[];
         type: string;
     }) => void;
-    deleteIssueComment: (state: ModelState<Stored<IssueComment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueComments: (state: ModelState<Stored<IssueComment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueComment: (state: ModelState<string, Stored<IssueComment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueComments: (state: ModelState<string, Stored<IssueComment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueComments", "issueComments", import('@reduxjs/toolkit').SliceSelectors<IssueCommentState>>;
 export declare const setIssueComments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/setIssueComments">, setIssueComment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/setIssueComment">, addIssueComment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/addIssueComment">, addIssueComments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/addIssueComments">, deleteIssueComment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueComments/deleteIssueComment">, deleteIssueComments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueComments/deleteIssueComments">;
 export declare const selectIssueCommentMapping: (state: OvermapRootState) => Record<string, Stored<IssueComment>>;

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

@@ -1,25 +1,31 @@
 import { Issue, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueState = ModelState<Stored<Issue>>;
+export type IssueState = ModelState<Issue["uuid"], Stored<Issue>>;
 export declare const issueSlice: import('@reduxjs/toolkit').Slice<IssueState, {
-    initializeIssues: (state: ModelState<Stored<Issue>>, action: {
+    initializeIssues: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>[];
         type: string;
     }) => void;
-    addIssue: (state: ModelState<Stored<Issue>>, action: {
+    addIssue: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>;
         type: string;
     }) => void;
-    addIssues: (state: ModelState<Stored<Issue>>, action: {
+    addIssues: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>[];
         type: string;
     }) => void;
-    updateIssue: (state: ModelState<Stored<Issue>>, action: {
+    updateIssue: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>;
         type: string;
     }) => void;
-    deleteIssue: (state: ModelState<Stored<Issue>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssues: (state: ModelState<Stored<Issue>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssue: (state: ModelState<string, Stored<Issue>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssues: (state: ModelState<string, Stored<Issue>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issues", "issues", import('@reduxjs/toolkit').SliceSelectors<IssueState>>;
 export declare const initializeIssues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/initializeIssues">, addIssue: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/addIssue">, addIssues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/addIssues">, updateIssue: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/updateIssue">, deleteIssue: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issues/deleteIssue">, deleteIssues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issues/deleteIssues">;
 export declare const selectIssueMapping: (state: OvermapRootState) => Record<string, Stored<Issue>>;