@overmap-ai/core 1.0.75-more-clean-ups.0 → 1.0.76

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

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

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

@@ -1,42 +1,47 @@
-import { Reducer } from '@reduxjs/toolkit';
 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, AssetType>>;
-export declare const selectAssetTypes: OvermapSelector<AssetType[]>;
-export declare const selectAssetTypeById: OvermapSelectorWithArgs<AssetType["offline_id"], Stored<AssetType> | undefined>;
+export declare const selectAssetTypesMapping: OvermapSelector<Record<string, Stored<AssetType>>>;
+export declare const selectAssetTypes: OvermapSelector<Stored<AssetType>[]>;
+export declare const selectAssetTypeById: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetType> | undefined>;
 export declare const selectAssetTypesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetType>[];
-export declare const assetTypeReducer: Reducer<AssetTypeState>;
+export declare const assetTypeReducer: import('redux').Reducer<AssetTypeState>;

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

@@ -1,5 +1,5 @@
-import { PayloadAction, Reducer } from '@reduxjs/toolkit';
-import { TokenPair } from '../../sdk/typings';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { TokenPair } from '../../sdk';
 import { BaseState } from '../../typings';
 export interface AuthState {
     accessToken: string;
@@ -17,4 +17,4 @@ export declare const authSlice: import('@reduxjs/toolkit').Slice<AuthState, {
 export declare const setTokens: import('@reduxjs/toolkit').ActionCreatorWithPayload<TokenPair, "auth/setTokens">, clearTokens: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"auth/clearTokens">, setLoggedIn: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "auth/setLoggedIn">;
 export declare const selectAccessToken: (state: BaseState) => string;
 export declare const selectIsLoggedIn: (state: BaseState) => boolean;
-export declare const authReducer: Reducer<AuthState>;
+export declare const authReducer: import('redux').Reducer<AuthState>;

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,46 +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 selectAttachmentsOfDocumentByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<DocumentAttachment>[];
-    imageAttachments: 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,19 +1,21 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { EmailDomain, OvermapRootState, OvermapSelector } from '../../typings';
+import { EmailDomain, OvermapRootState, OvermapSelector, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type EmailDomainState = ModelState<EmailDomain>;
-export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<EmailDomain>, {
-    initializeEmailDomains: (state: ModelState<EmailDomain>, action: {
-        payload: EmailDomain[];
+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<EmailDomain>, action: {
-        payload: EmailDomain;
+    addEmailDomain: (state: ModelState<string, Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>;
         type: string;
     }) => void;
-    deleteEmailDomain: (state: ModelState<EmailDomain>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<EmailDomain>>>;
-export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain, "emailDomains/addEmailDomain">, deleteEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
+    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;
@@ -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,42 +1,47 @@
-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: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
+    initializeFormRevisions: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>[];
         type: string;
     }) => void;
-    setFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
+    setFormRevision: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>;
         type: string;
     }) => void;
-    addFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>;
+    addFormRevision: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>;
         type: string;
     }) => void;
-    addFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: {
-        payload: Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
+    addFormRevisions: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: Stored<FormRevision>[];
+        type: string;
+    }) => void;
+    deleteFormRevision: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteFormRevisions: (state: ModelState<string, Stored<FormRevision>>, action: {
+        payload: string[];
         type: string;
     }) => void;
-    deleteFormRevision: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteFormRevisions: (state: ModelState<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "formRevisions", "formRevisions", import('@reduxjs/toolkit').SliceSelectors<FormRevisionState>>;
-export declare const setFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>, "formRevisions/setFormRevision">, initializeFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[], "formRevisions/initializeFormRevisions">, addFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>, "formRevisions/addFormRevision">, addFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[], "formRevisions/addFormRevisions">, deleteFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formRevisions/deleteFormRevision">, deleteFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisions">;
-export declare const selectFormRevisionMapping: (state: OvermapRootState) => Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>;
-export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[]) & {
+export declare const setFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>, "formRevisions/setFormRevision">, initializeFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>[], "formRevisions/initializeFormRevisions">, addFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>, "formRevisions/addFormRevision">, addFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevision>[], "formRevisions/addFormRevisions">, deleteFormRevision: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formRevisions/deleteFormRevision">, deleteFormRevisions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisions">;
+export declare const selectFormRevisionMapping: (state: OvermapRootState) => Record<string, Stored<FormRevision>>;
+export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<FormRevision>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>) => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>) => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<FormRevision>>) => Stored<FormRevision>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<FormRevision>>) => Stored<FormRevision>[]) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>[];
-    dependencies: [(state: OvermapRootState) => Record<string, Stored<FormRevision<import('@overmap-ai/forms').ISerializedField>>>];
+    lastResult: () => Stored<FormRevision>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<FormRevision>>];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;
@@ -45,8 +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 _selectLatestFormRevision: (formRevisions: FormRevisionState["instances"], formId: string) => Stored<FormRevision>;
-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,5 +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 selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;
+export declare const selectFormById: OvermapSelectorWithArgs<Form["uuid"], Stored<Form> | undefined>;