@overmap-ai/core 1.0.74-remove-workspaces.0 → 1.0.74-updates.1

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

@@ -46,7 +46,6 @@ export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<F
     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>;

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

@@ -31,7 +31,7 @@ export type FormSearchArgs = SearchArgs<{
     /** organization owner */
     organization?: number;
 }>;
-export declare const selectFormMapping: OvermapSelector<Record<Stored<Form>["offline_id"], Stored<Form>>>;
+export declare const selectFormMapping: OvermapSelector<Record<Stored<Form>["uuid"], Stored<Form>>>;
 export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -54,4 +54,3 @@ export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[])
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;

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

@@ -3,38 +3,38 @@ import { GeoImage, OvermapRootState, Stored } from '../../typings';
 import { ModelState } from '../typings';
 export type GeoImageSliceState = ModelState<Stored<GeoImage>>;
 export declare const geoImageSlice: import('@reduxjs/toolkit').Slice<GeoImageSliceState, {
-    initializeGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    initializeGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    setGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    setGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    setGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    setGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    addGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    addGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    addGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    addGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    updateGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    updateGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    updateGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    updateGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    deleteGeoImage: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteGeoImages: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<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;
 }, "geoImages", "geoImages", import('@reduxjs/toolkit').SliceSelectors<GeoImageSliceState>>;
-export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/updateGeoImages">, deleteGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
+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>>;
 export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoImage>[]) & {
     clearCache: () => void;
@@ -58,5 +58,5 @@ export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoIm
     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 selectGeoImagesOfProject: (args: string) => (state: OvermapRootState) => Stored<GeoImage>[];
 export declare const geoImageReducer: Reducer<GeoImageSliceState>;

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

@@ -1,5 +1,11 @@
 export * from './agentsSlice';
 export * from './assetAttachmentSlice';
+export * from './assetProcedureFieldsAttachmentSlice';
+export * from './assetProcedureFieldsSlice';
+export * from './assetProcedureFieldValuesAttachmentSlice';
+export * from './assetProcedureFieldValuesSlice';
+export * from './assetProcedureInstanceSlice';
+export * from './assetProcedureSlice';
 export * from './assetSlice';
 export * from './assetStageCompletionSlice';
 export * from './assetStageSlice';
@@ -23,8 +29,10 @@ export * from './formSubmissionSlice';
 export * from './geoImageSlice';
 export * from './issueAssociationSlice';
 export * from './issueAttachmentSlice';
+export * from './issueCommentAttachmentSlice';
 export * from './issueCommentSlice';
 export * from './issueSlice';
+export * from './issueTypeAttachmentSlice';
 export * from './issueTypeFieldsAttachmentSlice';
 export * from './issueTypeFieldsSlice';
 export * from './issueTypeFieldValuesAttachmentSlice';

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

@@ -39,8 +39,4 @@ export declare const selectIssueAttachmentMapping: (state: OvermapRootState) =>
 export declare const selectIssueAttachments: OvermapSelector<Stored<IssueAttachment>[]>;
 export declare const selectAttachmentsOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueAttachment>[];
 export declare const selectIssueAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-export declare const selectAttachmentsOfIssueByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<IssueAttachment>[];
-    imageAttachments: Stored<IssueAttachment>[];
-};
 export declare const issueAttachmentReducer: Reducer<IssueAttachmentState>;

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

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

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

@@ -0,0 +1,42 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeAttachmentState = ModelState<Stored<IssueTypeAttachment>>;
+export declare const issueTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<IssueTypeAttachment>>, {
+    initializeIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeAttachments", "issueTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<IssueTypeAttachment>>>>;
+export declare const initializeIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">, addIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/addIssueTypeAttachment">, addIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">, setIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">, setIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/setIssueTypeAttachments">, updateIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/updateIssueTypeAttachment">, updateIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">, deleteIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">, deleteIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+export declare const selectIssueTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeAttachment>>;
+export declare const selectIssueTypeAttachments: OvermapSelector<Stored<IssueTypeAttachment>[]>;
+export declare const selectIssueTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+export declare const selectAttachmentsOfIssueType: (args: string) => (state: OvermapRootState) => Stored<IssueTypeAttachment>[];
+export declare const issueTypeAttachmentReducer: Reducer<IssueTypeAttachmentState>;

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

@@ -57,6 +57,6 @@ export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment[]>;
-export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment | undefined>;
+export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment>[]>;
+export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment> | undefined>;
 export declare const issueTypeFieldsAttachmentReducer: Reducer<IssueTypeFieldsAttachmentState>;

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

@@ -58,7 +58,7 @@ export declare const selectIssueTypeFields: ((state: OvermapRootState) => Stored
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields>[]>;
-export declare const selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, IssueTypeFields | undefined>;
+export declare const selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
 export declare const selectIssueTypeValuesOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues>[]>;
 export declare const selectIssueTypeFieldsById: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
 export declare const issueTypeFieldsReducer: Reducer<IssueTypeFieldsState>;

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

@@ -26,7 +26,7 @@ export declare const selectIssueTypeMapping: OvermapSelector<IssueTypeState["ins
 export declare const selectIssueTypes: OvermapSelector<Stored<IssueType>[]>;
 export declare const selectIssueTypeById: OvermapSelectorWithArgs<string, Stored<IssueType> | undefined>;
 export declare const selectIssueTypesByIds: OvermapSelectorWithArgs<string[], Stored<IssueType>[]>;
-export declare const selectIssueTypesOfOrganization: OvermapSelectorWithArgs<Organization["id"], Stored<IssueType>[]>;
-export declare const selectIssuesOfIssueType: OvermapSelectorWithArgs<IssueType["offline_id"], Stored<Issue>[]>;
-export declare const selectIssuesOfIssueTypeCount: OvermapSelectorWithArgs<IssueType["offline_id"], number>;
+export declare const selectIssueTypesOfOrganization: OvermapSelectorWithArgs<Organization["uuid"], Stored<IssueType>[]>;
+export declare const selectIssuesOfIssueType: OvermapSelectorWithArgs<IssueType["uuid"], Stored<Issue>[]>;
+export declare const selectIssuesOfIssueTypeCount: OvermapSelectorWithArgs<IssueType["uuid"], number>;
 export declare const issueTypeReducer: Reducer<IssueTypeState>;

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

@@ -1,25 +1,25 @@
 import { Reducer } from '@reduxjs/toolkit';
-import { License, OvermapSelector, OvermapSelectorWithArgs } from '../../typings';
+import { License, OvermapSelector, OvermapSelectorWithArgs, Project, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type LicenseState = ModelState<License>;
+export type LicenseState = ModelState<Stored<License>>;
 export declare const licenseSlice: import('@reduxjs/toolkit').Slice<LicenseState, {
-    initializeLicences: (state: ModelState<License>, action: {
-        payload: License[];
+    initializeLicences: (state: ModelState<Stored<License>>, action: {
+        payload: Stored<License>[];
         type: string;
     }) => void;
-    addLicenses: (state: ModelState<License>, action: {
-        payload: License[];
+    addLicenses: (state: ModelState<Stored<License>>, action: {
+        payload: Stored<License>[];
         type: string;
     }) => void;
-    updateLicense: (state: ModelState<License>, action: {
-        payload: License;
+    updateLicense: (state: ModelState<Stored<License>>, action: {
+        payload: Stored<License>;
         type: string;
     }) => void;
 }, "license", "license", import('@reduxjs/toolkit').SliceSelectors<LicenseState>>;
-export declare const initializeLicences: import('@reduxjs/toolkit').ActionCreatorWithPayload<License[], "license/initializeLicences">, addLicenses: import('@reduxjs/toolkit').ActionCreatorWithPayload<License[], "license/addLicenses">, updateLicense: import('@reduxjs/toolkit').ActionCreatorWithPayload<License, "license/updateLicense">;
+export declare const initializeLicences: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<License>[], "license/initializeLicences">, addLicenses: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<License>[], "license/addLicenses">, updateLicense: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<License>, "license/updateLicense">;
 export declare const selectLicenses: OvermapSelector<Record<string, License>>;
 export declare const selectLicense: OvermapSelectorWithArgs<string, License | undefined>;
-export declare const selectLicenseForProject: OvermapSelectorWithArgs<number, License | undefined>;
+export declare const selectLicenseForProject: OvermapSelectorWithArgs<Project["uuid"], License | undefined>;
 export declare const selectActiveStatusLicenses: OvermapSelector<License[]>;
 export declare const selectLicensesForProjectsMapping: OvermapSelector<Record<number, License>>;
 export declare const licenseReducer: Reducer<LicenseState>;

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

@@ -1,22 +1,22 @@
 import { Reducer } from '@reduxjs/toolkit';
-import { OrganizationAccess, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, User } from '../../typings';
+import { OrganizationAccess, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored, User } from '../../typings';
 import { ModelState } from '../typings';
-export type OrganizationAccessState = ModelState<OrganizationAccess>;
+export type OrganizationAccessState = ModelState<Stored<OrganizationAccess>>;
 export declare const organizationAccessSlice: import('@reduxjs/toolkit').Slice<OrganizationAccessState, {
-    initializeOrganizationAccesses: (state: ModelState<OrganizationAccess>, action: {
-        payload: OrganizationAccess[];
+    initializeOrganizationAccesses: (state: ModelState<Stored<OrganizationAccess>>, action: {
+        payload: Stored<OrganizationAccess>[];
         type: string;
     }) => void;
-    updateOrganizationAccess: (state: ModelState<OrganizationAccess>, action: {
-        payload: OrganizationAccess;
+    updateOrganizationAccess: (state: ModelState<Stored<OrganizationAccess>>, action: {
+        payload: Stored<OrganizationAccess>;
         type: string;
     }) => void;
-    deleteOrganizationAccess: (state: ModelState<OrganizationAccess>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteOrganizationAccess: (state: ModelState<Stored<OrganizationAccess>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
 }, "organizationAccess", "organizationAccess", import('@reduxjs/toolkit').SliceSelectors<OrganizationAccessState>>;
-export declare const initializeOrganizationAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/initializeOrganizationAccesses">, updateOrganizationAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess, "organizationAccess/updateOrganizationAccess">, deleteOrganizationAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "organizationAccess/deleteOrganizationAccess">;
-export declare const selectOrganizationAccesses: (state: OvermapRootState) => Record<string, OrganizationAccess>;
+export declare const initializeOrganizationAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<OrganizationAccess>[], "organizationAccess/initializeOrganizationAccesses">, updateOrganizationAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<OrganizationAccess>, "organizationAccess/updateOrganizationAccess">, deleteOrganizationAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "organizationAccess/deleteOrganizationAccess">;
+export declare const selectOrganizationAccesses: (state: OvermapRootState) => Record<string, Stored<OrganizationAccess>>;
 export declare const selectOrganizationAccessById: OvermapSelectorWithArgs<string, OrganizationAccess | undefined>;
 export declare const selectActiveOrganizationAccess: OvermapSelector<OrganizationAccess | null>;
 export declare const selectOrganizationAccessForUser: OvermapSelectorWithArgs<User, OrganizationAccess | undefined>;
-export declare const selectOrganizationAccessUserMapping: (state: OvermapRootState) => Record<number, OrganizationAccess>;
+export declare const selectOrganizationAccessUserMapping: (state: OvermapRootState) => Record<string, Stored<OrganizationAccess>>;
 export declare const organizationAccessReducer: Reducer<OrganizationAccessState>;

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

@@ -1,12 +1,41 @@
-import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { Reducer } from '@reduxjs/toolkit';
 import { License, Organization, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Project, User } from '../../typings';
-export interface OrganizationState {
-    organizations: Record<number, Organization>;
+import { ModelState } from '../typings';
+export interface OrganizationState extends ModelState<Organization> {
 }
 export declare const organizationSlice: import('@reduxjs/toolkit').Slice<OrganizationState, {
-    setOrganizations: (state: import('immer').WritableDraft<OrganizationState>, action: PayloadAction<Organization[]>) => void;
+    initializeOrganizations: (state: ModelState<Organization>, action: {
+        payload: Organization[];
+        type: string;
+    }) => void;
+    setOrganizations: (state: ModelState<Organization>, action: {
+        payload: Organization[];
+        type: string;
+    }) => void;
+    setOrganization: (state: ModelState<Organization>, action: {
+        payload: Organization;
+        type: string;
+    }) => void;
+    addOrganizations: (state: ModelState<Organization>, action: {
+        payload: Organization[];
+        type: string;
+    }) => void;
+    addOrganization: (state: ModelState<Organization>, action: {
+        payload: Organization;
+        type: string;
+    }) => void;
+    updateOrganizations: (state: ModelState<Organization>, action: {
+        payload: Organization[];
+        type: string;
+    }) => void;
+    updateOrganization: (state: ModelState<Organization>, action: {
+        payload: Organization;
+        type: string;
+    }) => void;
+    deleteOrganization: (state: ModelState<Organization>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteOrganizations: (state: ModelState<Organization>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "organizations", "organizations", import('@reduxjs/toolkit').SliceSelectors<OrganizationState>>;
-export declare const setOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/setOrganizations">;
+export declare const initializeOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/initializeOrganizations">, setOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/setOrganizations">, setOrganization: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization, "organizations/setOrganization">, addOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/addOrganizations">, addOrganization: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization, "organizations/addOrganization">, updateOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/updateOrganizations">, updateOrganization: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization, "organizations/updateOrganization">, deleteOrganization: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "organizations/deleteOrganization">, deleteOrganizations: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "organizations/deleteOrganizations">;
 export declare const selectOrganizationsMapping: OvermapSelector<Record<number, Organization>>;
 export declare const selectOrganizations: ((state: OvermapRootState) => Organization[]) & {
     clearCache: () => void;
@@ -31,9 +60,9 @@ export declare const selectOrganizations: ((state: OvermapRootState) => Organiza
 };
 export declare const selectOrganizationById: OvermapSelectorWithArgs<number, Organization | undefined>;
 export declare const selectOrganizationsWithAccess: OvermapSelector<Organization[]>;
-export declare const selectOrganizationUsersIds: OvermapSelector<number[]>;
+export declare const selectOrganizationUsersIds: OvermapSelector<User["uuid"][]>;
 export declare const selectProjectsOfOrganization: OvermapSelectorWithArgs<number, Project[]>;
 export declare const selectLicensesOfOrganization: OvermapSelectorWithArgs<number, License[]>;
-export declare const selectOrganizationUsersAsMapping: OvermapSelector<Record<number, User>>;
+export declare const selectOrganizationUsersAsMapping: OvermapSelector<Record<User["uuid"], User>>;
 export declare const selectSortedOrganizationUsers: OvermapSelector<User[]>;
 export declare const organizationReducer: Reducer<OrganizationState>;

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

@@ -1,21 +1,21 @@
 import { Reducer } from '@reduxjs/toolkit';
 import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, ProjectAccess, Stored, User } from '../../typings';
 import { ModelState } from '../typings';
-export type ProjectAccessState = ModelState<ProjectAccess>;
+export type ProjectAccessState = ModelState<Stored<ProjectAccess>>;
 export declare const projectAccessSlice: import('@reduxjs/toolkit').Slice<ProjectAccessState, {
-    initializeProjectAccesses: (state: ModelState<ProjectAccess>, action: {
-        payload: ProjectAccess[];
+    initializeProjectAccesses: (state: ModelState<Stored<ProjectAccess>>, action: {
+        payload: Stored<ProjectAccess>[];
         type: string;
     }) => void;
-    updateProjectAccess: (state: ModelState<ProjectAccess>, action: {
-        payload: ProjectAccess;
+    updateProjectAccess: (state: ModelState<Stored<ProjectAccess>>, action: {
+        payload: Stored<ProjectAccess>;
         type: string;
     }) => void;
-    deleteProjectAccess: (state: ModelState<ProjectAccess>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteProjectAccesses: (state: ModelState<ProjectAccess>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteProjectAccess: (state: ModelState<Stored<ProjectAccess>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteProjectAccesses: (state: ModelState<Stored<ProjectAccess>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "projectAccess", "projectAccess", import('@reduxjs/toolkit').SliceSelectors<ProjectAccessState>>;
-export declare const initializeProjectAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProjectAccess[], "projectAccess/initializeProjectAccesses">, updateProjectAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProjectAccess, "projectAccess/updateProjectAccess">, deleteProjectAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAccess/deleteProjectAccess">, deleteProjectAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAccess/deleteProjectAccesses">;
-export declare const selectProjectAccessMapping: (state: OvermapRootState) => Record<string, ProjectAccess>;
+export declare const initializeProjectAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>[], "projectAccess/initializeProjectAccesses">, updateProjectAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>, "projectAccess/updateProjectAccess">, deleteProjectAccess: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAccess/deleteProjectAccess">, deleteProjectAccesses: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAccess/deleteProjectAccesses">;
+export declare const selectProjectAccessMapping: (state: OvermapRootState) => Record<string, Stored<ProjectAccess>>;
 export declare const selectProjectAccesses: OvermapSelector<Stored<ProjectAccess>[]>;
 export declare const selectProjectAccessById: OvermapSelectorWithArgs<string, ProjectAccess | undefined>;
 export declare const selectProjectAccessForUser: OvermapSelectorWithArgs<User, ProjectAccess | undefined>;

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

@@ -38,9 +38,5 @@ export declare const initializeProjectAttachments: import('@reduxjs/toolkit').Ac
 export declare const selectProjectAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<ProjectAttachment>>;
 export declare const selectAllProjectAttachments: OvermapSelector<Stored<ProjectAttachment>[]>;
 export declare const selectProjectAttachmentById: OvermapSelectorWithArgs<string, ProjectAttachment | undefined>;
-export declare const selectAttachmentsOfProject: (args: number) => (state: OvermapRootState) => Stored<ProjectAttachment>[];
-export declare const selectAttachmentsOfProjectByType: (args: number) => (state: OvermapRootState) => {
-    fileAttachments: Stored<ProjectAttachment>[];
-    imageAttachments: Stored<ProjectAttachment>[];
-};
+export declare const selectAttachmentsOfProject: (args: string) => (state: OvermapRootState) => Stored<ProjectAttachment>[];
 export declare const projectAttachmentReducer: Reducer<ProjectAttachmentState>;

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

@@ -1,26 +1,66 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { OvermapSelector, OvermapSelectorWithArgs, Project, User } from '../../typings';
-export interface ProjectState {
-    projects: Record<number, Project>;
+import { PayloadAction, Reducer } from '@reduxjs/toolkit';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Project, User } from '../../typings';
+import { ModelState } from '../typings';
+export interface ProjectState extends ModelState<Project> {
 }
 export declare const projectSlice: import('@reduxjs/toolkit').Slice<ProjectState, {
-    setProjects: (state: import('immer').WritableDraft<ProjectState>, action: {
+    initializeProjects: (state: ModelState<Project>, action: {
         payload: Project[];
+        type: string;
     }) => void;
-    updateProject: (state: import('immer').WritableDraft<ProjectState>, action: {
+    setProjects: (state: ModelState<Project>, action: {
+        payload: Project[];
+        type: string;
+    }) => void;
+    setProject: (state: ModelState<Project>, action: {
         payload: Project;
+        type: string;
+    }) => void;
+    addProjects: (state: ModelState<Project>, action: {
+        payload: Project[];
+        type: string;
     }) => void;
-    deleteProject: (state: import('immer').WritableDraft<ProjectState>, action: {
+    addProject: (state: ModelState<Project>, action: {
         payload: Project;
+        type: string;
     }) => void;
-    acceptProjectInvite: (state: import('immer').WritableDraft<ProjectState>, action: {
-        payload: number;
+    updateProjects: (state: ModelState<Project>, action: {
+        payload: Project[];
+        type: string;
+    }) => void;
+    updateProject: (state: ModelState<Project>, action: {
+        payload: Project;
+        type: string;
     }) => void;
+    deleteProject: (state: ModelState<Project>, action: PayloadAction<string>) => void;
+    deleteProjects: (state: ModelState<Project>, action: PayloadAction<string[]>) => void;
+    acceptProjectInvite: (state: import('immer').WritableDraft<ProjectState>, action: PayloadAction<Project["uuid"]>) => void;
 }, "projects", "projects", import('@reduxjs/toolkit').SliceSelectors<ProjectState>>;
-export declare const setProjects: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/setProjects">, updateProject: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/updateProject">, deleteProject: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/deleteProject">, acceptProjectInvite: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "projects/acceptProjectInvite">;
+export declare const initializeProjects: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/initializeProjects">, setProjects: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/setProjects">, setProject: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/setProject">, addProjects: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/addProjects">, addProject: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/addProject">, updateProjects: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/updateProjects">, updateProject: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/updateProject">, deleteProject: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projects/deleteProject">, deleteProjects: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projects/deleteProjects">, acceptProjectInvite: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projects/acceptProjectInvite">;
 export declare const projectReducer: Reducer<ProjectState>;
-export declare const selectProjectMapping: OvermapSelector<Record<number, Project>>;
+export declare const selectProjectMapping: OvermapSelector<Record<Project["uuid"], Project>>;
+export declare const selectProjects: ((state: OvermapRootState) => Project[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Project>) => Project[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Project>) => Project[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Project[];
+    dependencies: [OvermapSelector<Record<string, Project>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
 export declare const selectProjectById: OvermapSelectorWithArgs<number, Project | undefined>;
-export declare const selectProjectUsersIds: OvermapSelector<number[]>;
+export declare const selectProjectUsersIds: OvermapSelector<User["uuid"][]>;
 export declare const selectProjectUsersAsMapping: OvermapSelector<Record<number, User>>;
 export declare const selectSortedProjectUsers: OvermapSelector<User[]>;

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

@@ -26,6 +26,6 @@ export declare const selectTeamsMapping: OvermapSelector<TeamState["instances"]>
 export declare const selectTeams: OvermapSelector<Stored<Team>[]>;
 export declare const selectTeamById: OvermapSelectorWithArgs<string, Stored<Team> | undefined>;
 export declare const selectTeamsByIds: OvermapSelectorWithArgs<string[], Stored<Team>[]>;
-export declare const selectTeamsOfOrganization: OvermapSelectorWithArgs<Organization["id"], Stored<Team>[]>;
-export declare const selectTeamsOfUser: OvermapSelectorWithArgs<User["id"], Stored<Team>[]>;
+export declare const selectTeamsOfOrganization: OvermapSelectorWithArgs<Organization["uuid"], Stored<Team>[]>;
+export declare const selectTeamsOfUser: OvermapSelectorWithArgs<User["uuid"], Stored<Team>[]>;
 export declare const teamReducer: Reducer<TeamState>;

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

@@ -1,25 +1,53 @@
 import { PayloadAction, Reducer } from '@reduxjs/toolkit';
 import { OvermapRootState, OvermapSelectorWithArgs, User } from '../../typings';
-export interface UserState {
+import { ModelState } from '../typings';
+export interface UserState extends ModelState<User> {
     currentUser: User | null;
-    users: Record<number, User>;
 }
 export declare const userSlice: import('@reduxjs/toolkit').Slice<UserState, {
-    setUsers: (state: import('immer').WritableDraft<UserState>, action: PayloadAction<User[]>) => void;
-    addUsers: (state: import('immer').WritableDraft<UserState>, action: PayloadAction<User[]>) => void;
+    initializeUsers: (state: ModelState<User>, action: {
+        payload: User[];
+        type: string;
+    }) => void;
+    setUsers: (state: ModelState<User>, action: {
+        payload: User[];
+        type: string;
+    }) => void;
+    setUser: (state: ModelState<User>, action: {
+        payload: User;
+        type: string;
+    }) => void;
+    addUsers: (state: ModelState<User>, action: {
+        payload: User[];
+        type: string;
+    }) => void;
+    addUser: (state: ModelState<User>, action: {
+        payload: User;
+        type: string;
+    }) => void;
+    updateUsers: (state: ModelState<User>, action: {
+        payload: User[];
+        type: string;
+    }) => void;
+    updateUser: (state: ModelState<User>, action: {
+        payload: User;
+        type: string;
+    }) => void;
+    deleteUser: (state: ModelState<User>, action: PayloadAction<string>) => void;
+    deleteUsers: (state: ModelState<User>, action: PayloadAction<string[]>) => void;
+    removeUser: (state: ModelState<User>, action: PayloadAction<string>) => void;
     setCurrentUser: (state: import('immer').WritableDraft<UserState>, action: PayloadAction<User | null>) => void;
     setProfilePicture: (state: import('immer').WritableDraft<UserState>, action: PayloadAction<{
         file?: string;
         file_sha1?: string;
     }>) => void;
-    removeUser: (state: import('immer').WritableDraft<UserState>, action: PayloadAction<number>) => void;
 }, "users", "users", import('@reduxjs/toolkit').SliceSelectors<UserState>>;
-export declare const setCurrentUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<User | null, "users/setCurrentUser">, setProfilePicture: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+export declare const initializeUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/initializeUsers">, setUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/setUsers">, setUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<User, "users/setUser">, addUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/addUsers">, addUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<User, "users/addUser">, updateUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/updateUsers">, updateUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<User, "users/updateUser">, deleteUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "users/deleteUser">, deleteUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "users/deleteUsers">, removeUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "users/removeUser">, setCurrentUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<User | null, "users/setCurrentUser">, setProfilePicture: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
     file?: string;
     file_sha1?: string;
-}, "users/setProfilePicture">, setUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/setUsers">, addUsers: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/addUsers">, removeUser: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "users/removeUser">;
+}, "users/setProfilePicture">;
 export declare const userReducer: Reducer<UserState>;
 export declare const selectCurrentUser: (state: OvermapRootState) => User | null;
-export declare const selectUsersMapping: (state: OvermapRootState) => Record<number, User>;
+export declare const selectUsersMapping: (state: OvermapRootState) => Record<string, User>;
 export declare const selectUserById: OvermapSelectorWithArgs<number, User | undefined>;
 export declare const selectUsersByIds: (args: number[]) => (state: OvermapRootState) => User[];