@overmap-ai/core 1.0.74-procedures.3 → 1.0.74-standardizations.0

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

@@ -1,21 +1,23 @@
-import { Reducer } from '@reduxjs/toolkit';
 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>>;
@@ -40,7 +42,7 @@ export declare const selectCategories: ((state: OvermapRootState) => Stored<Cate
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectCategoryById: OvermapSelectorWithArgs<string, Stored<Category> | undefined>;
+export declare const selectCategoryById: OvermapSelectorWithArgs<Category["uuid"], Stored<Category> | undefined>;
 export declare const selectCategoriesByIds: (args: string[]) => (state: OvermapRootState) => Stored<Category>[];
 export declare const selectIssueCountOfCategory: OvermapSelectorWithArgs<string | null, number>;
-export declare const categoryReducer: Reducer<CategoryState>;
+export declare const categoryReducer: import('redux').Reducer<CategoryState>;

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

@@ -1,42 +1,47 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { DocumentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type DocumentAttachmentState = ModelState<Stored<DocumentAttachment>>;
-export declare const documentAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<DocumentAttachment>>, {
-    initializeDocumentAttachments: (state: ModelState<Stored<DocumentAttachment>>, action: {
+export type DocumentAttachmentState = ModelState<DocumentAttachment["uuid"], Stored<DocumentAttachment>>;
+export declare const documentAttachmentSlice: import('@reduxjs/toolkit').Slice<DocumentAttachmentState, {
+    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;
-}, "documentAttachments", "documentAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<DocumentAttachment>>>>;
+    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>>;
 export declare const selectAllDocumentAttachments: OvermapSelector<Stored<DocumentAttachment>[]>;
-export declare const selectDocumentAttachmentById: OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
+export declare const selectDocumentAttachmentById: OvermapSelectorWithArgs<DocumentAttachment["uuid"], Stored<DocumentAttachment> | undefined>;
 export declare const selectAttachmentsOfDocument: (args: string) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
-export declare const documentAttachmentReducer: Reducer<DocumentAttachmentState>;
+export declare const documentAttachmentReducer: import('redux').Reducer<DocumentAttachmentState>;

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

@@ -1,11 +1,10 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { Document, MovePosition, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 export interface DocumentState {
     documents: Record<string, Stored<Document>>;
 }
 export interface MoveDocumentPayload {
-    documentId: Document["offline_id"];
-    targetDocumentId: Document["offline_id"] | null;
+    documentId: Document["uuid"];
+    targetDocumentId: Document["uuid"] | null;
     position: MovePosition;
 }
 export declare const documentSlice: import('@reduxjs/toolkit').Slice<DocumentState, {
@@ -28,7 +27,7 @@ export declare const documentSlice: import('@reduxjs/toolkit').Slice<DocumentSta
 export declare const setDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/setDocuments">, addDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/addDocuments">, updateDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/updateDocuments">, moveDocument: import('@reduxjs/toolkit').ActionCreatorWithPayload<MoveDocumentPayload, "documents/moveDocument">, removeDocuments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documents/removeDocuments">;
 export declare const selectDocumentsMapping: OvermapSelector<Record<string, Stored<Document>>>;
 export declare const selectDocuments: OvermapSelector<Stored<Document>[]>;
-export declare const selectDocumentById: OvermapSelectorWithArgs<string, Stored<Document> | undefined>;
+export declare const selectDocumentById: OvermapSelectorWithArgs<Document["uuid"], Stored<Document> | undefined>;
 export declare const selectDocumentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<Document>[];
 export declare const selectAncestorIdsOfDocument: (args: string) => (state: OvermapRootState) => string[];
 export declare const selectRootDocuments: ((state: OvermapRootState) => Stored<Document>[]) & {
@@ -52,4 +51,4 @@ export declare const selectRootDocuments: ((state: OvermapRootState) => Stored<D
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const documentsReducer: Reducer<DocumentState>;
+export declare const documentsReducer: import('redux').Reducer<DocumentState>;

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

@@ -1,18 +1,20 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { EmailDomain, OvermapRootState, OvermapSelector, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type EmailDomainState = ModelState<Stored<EmailDomain>>;
-export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<EmailDomain>>, {
-    initializeEmailDomains: (state: ModelState<Stored<EmailDomain>>, action: {
+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<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;
-}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<EmailDomain>>>>;
+    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[]) & {
@@ -36,5 +38,5 @@ export declare const selectEmailDomains: ((state: OvermapRootState) => EmailDoma
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectEmailDomainsOfOrganization: (args: number) => (state: OvermapRootState) => EmailDomain[];
-export declare const emailDomainsReducer: Reducer<EmailDomainState>;
+export declare const selectEmailDomainsOfOrganization: (args: string) => (state: OvermapRootState) => Stored<EmailDomain>[];
+export declare const emailDomainsReducer: import('redux').Reducer<EmailDomainState>;

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

@@ -1,4 +1,4 @@
-import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { PayloadAction } from '@reduxjs/toolkit';
 import { BaseState, SelectorWithArgs } from '../../typings';
 interface S3UploadUrl {
     url: string;
@@ -22,5 +22,5 @@ export declare const fileSlice: import('@reduxjs/toolkit').Slice<FileState, {
 }, "file", "file", import('@reduxjs/toolkit').SliceSelectors<FileState>>;
 export declare const setUploadUrl: import('@reduxjs/toolkit').ActionCreatorWithPayload<S3UrlPayload, "file/setUploadUrl">;
 export declare const selectUploadUrl: SelectorWithArgs<BaseState, string, S3UploadUrl | undefined>;
-export declare const fileReducer: Reducer<FileState>;
+export declare const fileReducer: import('redux').Reducer<FileState>;
 export {};

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

@@ -1,40 +1,45 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { FormRevisionAttachment, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+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"]>;
-export declare const selectAttachmentsOfFormRevision: OvermapSelectorWithArgs<string, Stored<FormRevisionAttachment>[]>;
-export declare const formRevisionAttachmentReducer: Reducer<FormRevisionAttachmentState>;
+export declare const selectAttachmentsOfFormRevision: OvermapSelectorWithArgs<FormRevision["uuid"], Stored<FormRevisionAttachment>[]>;
+export declare const formRevisionAttachmentReducer: import('redux').Reducer<FormRevisionAttachmentState>;

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

@@ -1,26 +1,31 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { FormRevision, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+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>>>;
@@ -45,7 +50,7 @@ export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<F
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectFormRevisionById: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
-export declare const selectLatestFormRevisionOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
-export declare const selectFormRevisionsOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision>[]>;
-export declare const formRevisionReducer: Reducer<FormRevisionState>;
+export declare const selectFormRevisionById: OvermapSelectorWithArgs<FormRevision["uuid"], Stored<FormRevision> | undefined>;
+export declare const selectLatestFormRevisionOfForm: OvermapSelectorWithArgs<Form["uuid"], Stored<FormRevision> | undefined>;
+export declare const selectFormRevisionsOfForm: OvermapSelectorWithArgs<Form["uuid"], Stored<FormRevision>[]>;
+export declare const formRevisionReducer: import('redux').Reducer<FormRevisionState>;

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

@@ -1,37 +1,35 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { Form, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, SearchArgs, Stored } from '../../typings';
+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: Reducer<FormState>;
-export type FormSearchArgs = SearchArgs<{
-    /** organization owner */
-    organization?: number;
-}>;
-export declare const selectFormMapping: OvermapSelector<Record<Stored<Form>["offline_id"], Stored<Form>>>;
+export declare const formReducer: import('redux').Reducer<FormState>;
+export declare const selectFormMapping: OvermapSelector<Record<Stored<Form>["uuid"], Stored<Form>>>;
 export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -53,4 +51,4 @@ export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[])
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
+export declare const selectFormById: OvermapSelectorWithArgs<Form["uuid"], Stored<Form> | undefined>;

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

@@ -1,41 +1,46 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { FormSubmissionAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+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"]>;
 export declare const selectFormSubmissionAttachemntsByIds: (args: string[]) => (state: OvermapRootState) => Stored<FormSubmissionAttachment>[];
-export declare const selectAttachmentsOfFormSubmission: OvermapSelectorWithArgs<string, Stored<FormSubmissionAttachment>[]>;
-export declare const formSubmissionAttachmentReducer: Reducer<FormSubmissionAttachmentState>;
+export declare const selectAttachmentsOfFormSubmission: OvermapSelectorWithArgs<FormSubmission["uuid"], Stored<FormSubmissionAttachment>[]>;
+export declare const formSubmissionAttachmentReducer: import('redux').Reducer<FormSubmissionAttachmentState>;

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

@@ -1,44 +1,49 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { FormSubmission, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+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"]>;
 export declare const selectFormSubmissions: OvermapSelector<Stored<FormSubmission>[]>;
-export declare const selectFormSubmissionById: OvermapSelectorWithArgs<string, Stored<FormSubmission> | undefined>;
-export declare const selectFormSubmissionsOfForm: OvermapSelectorWithArgs<string, Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionById: OvermapSelectorWithArgs<FormSubmission["uuid"], Stored<FormSubmission> | undefined>;
+export declare const selectFormSubmissionsOfForm: OvermapSelectorWithArgs<Form["uuid"], Stored<FormSubmission>[]>;
 export declare const selectFormSubmissionsOfIssue: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
 export declare const selectFormSubmissionsOfAsset: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const formSubmissionReducer: Reducer<FormSubmissionState>;
+export declare const formSubmissionReducer: import('redux').Reducer<FormSubmissionState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { GeoImage, OvermapRootState, Stored } from '../../typings';
+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>>;
@@ -57,6 +62,6 @@ export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoIm
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectGeoImageById: (id: string) => (state: OvermapRootState) => Stored<GeoImage> | undefined;
-export declare const selectGeoImagesOfProject: (args: number) => (state: OvermapRootState) => Stored<GeoImage>[];
-export declare const geoImageReducer: Reducer<GeoImageSliceState>;
+export declare const selectGeoImageById: OvermapSelectorWithArgs<GeoImage["uuid"], Stored<GeoImage> | undefined>;
+export declare const selectGeoImagesOfProject: (args: string) => (state: OvermapRootState) => Stored<GeoImage>[];
+export declare const geoImageReducer: import('redux').Reducer<GeoImageSliceState>;