@overmap-ai/core 1.0.78-gcs.3 → 1.0.78-gcs.4

package/dist/sdk/services/FormSubmissionAttachmentService.d.ts

@@ -1,31 +1,31 @@
-import { FormSubmission, FormSubmissionAttachment, Organization } from '../../typings';
+import { FormSubmissionAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class FormSubmissionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormSubmissionAttachment["uuid"], FormSubmissionAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class FormSubmissionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<FormSubmissionAttachment["uuid"], FormSubmissionAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
-        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>, "formSubmissionAttachments/addFormSubmissionAttachment">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/addFormSubmissionAttachments">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>, "formSubmissionAttachments/setFormSubmissionAttachment">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/setFormSubmissionAttachments">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>, "formSubmissionAttachments/updateFormSubmissionAttachment">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/updateFormSubmissionAttachments">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/addFormSubmissionAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/addFormSubmissionAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/setFormSubmissionAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/setFormSubmissionAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>, "formSubmissionAttachments/updateFormSubmissionAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/updateFormSubmissionAttachments">;
         deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formSubmissionAttachments/deleteFormSubmissionAttachment">;
         deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formSubmissionAttachments/deleteFormSubmissionAttachments">;
-        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/initializeFormSubmissionAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/initializeFormSubmissionAttachments">;
     };
     selectors: {
-        selectById: (uuid: string) => (state: any) => import('../..').Stored<FormSubmissionAttachment> | undefined;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormSubmissionAttachment>[];
+        selectById: (uuid: string) => (state: any) => Stored<FormSubmissionAttachment> | undefined;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormSubmissionAttachment>[];
     };
-    bulkAdd(payloads: {
-        submissionUuid: FormSubmission["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<FormSubmissionAttachment>>;
+    protected getId(model: Stored<FormSubmissionAttachment>): string;
+    protected getBlockers(model: Stored<FormSubmissionAttachment>): string[];
+    protected getBlocks(model: Stored<FormSubmissionAttachment>): string[];
+    protected buildModel(data: Payload<FormSubmissionAttachment>): Submitted<FormSubmissionAttachment>;
+    protected buildPayload(model: Submitted<FormSubmissionAttachment>): object;
+    protected buildBulkPayload(model: Submitted<FormSubmissionAttachment>): object;
     bulkDelete(uuids: FormSubmissionAttachment["uuid"][]): Promise<void>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormSubmissionAttachment[]>;
 }

package/dist/sdk/services/GeoImageService.d.ts

@@ -1,9 +1,9 @@
-import { BulkGeoImagePayload, GeoImage, GeoImagePayload, Project, Stored, UUID } from '../../typings';
+import { GeoImage, GeoImagePayload, Payload, Project, Stored, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class GeoImageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<GeoImage["uuid"], GeoImage, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class GeoImageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<GeoImage["uuid"], GeoImage, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -21,9 +21,12 @@ export declare abstract class GeoImageService<TState extends OvermapRootState, T
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<GeoImage> | undefined>;
         selectByIds: (uuids: string[]) => (state: any) => Stored<GeoImage>[];
     };
-    add(payload: GeoImagePayload): Promise<OptimisticModelResult<GeoImage>>;
-    bulkAdd(payloads: BulkGeoImagePayload[], projectUuid: Project["uuid"]): Promise<OptimisticMultipleModelResult<GeoImage>>;
+    protected getId(model: Stored<GeoImage>): GeoImage["uuid"];
+    protected getBlockers(model: Stored<GeoImage>): string[];
+    protected getBlocks(model: Stored<GeoImage>): string[];
+    protected buildModel(data: Payload<GeoImage>): Submitted<GeoImage>;
+    protected buildPayload(model: Submitted<GeoImage>): object;
+    protected buildBulkPayload(model: Submitted<GeoImage>): object;
     update(payload: UUID<Partial<Pick<GeoImagePayload, "title" | "description">>>): OptimisticModelResult<GeoImage>;
-    delete(uuid: GeoImage["uuid"]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<GeoImage[]>;
 }

package/dist/sdk/services/IssueAssociationService.d.ts

@@ -1,6 +1,6 @@
 import { IssueAssociation, Payload, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult } from '../typings';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
 import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
 export declare abstract class IssueAssociationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueAssociation["uuid"], IssueAssociation, TState, TSDK> {
@@ -22,6 +22,7 @@ export declare abstract class IssueAssociationService<TState extends OvermapRoot
         selectByIds: (uuids: string[]) => (state: any) => Stored<IssueAssociation>[];
     };
     add(payload: Payload<IssueAssociation>): OptimisticModelResult<IssueAssociation>;
+    bulkAdd(payloads: Payload<IssueAssociation>[]): OptimisticMultipleModelResult<IssueAssociation>;
     delete(uuid: IssueAssociation["uuid"]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAssociation[]>;
 }

package/dist/sdk/services/IssueAttachmentService.d.ts

@@ -1,9 +1,8 @@
-import { FilePayload, Issue, IssueAttachment, Project, Stored, Submitted } from '../../typings';
+import { IssueAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
-export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, IssueAttachment["uuid"], IssueAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueAttachment["uuid"], IssueAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -22,18 +21,10 @@ export declare abstract class IssueAttachmentService<TState extends OvermapRootS
         selectByIds: (uuids: string[]) => (state: any) => Stored<IssueAttachment>[];
     };
     protected getId(model: Stored<IssueAttachment>): IssueAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<IssueAttachment>;
-    protected buildPayload(model: Submitted<IssueAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        issue: string;
-    };
-    bulkAdd(payloads: {
-        issueUuid: Issue["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
-    delete(uuid: IssueAttachment["uuid"]): Promise<void>;
+    protected getBlockers(model: Stored<IssueAttachment>): string[];
+    protected getBlocks(model: Stored<IssueAttachment>): string[];
+    protected buildModel(data: Payload<IssueAttachment>): Submitted<IssueAttachment>;
+    protected buildPayload(model: Submitted<IssueAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueAttachment>): object;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAttachment[]>;
 }

package/dist/sdk/services/IssueCommentAttachmentService.d.ts

@@ -1,9 +1,8 @@
-import { FilePayload, IssueComment, IssueCommentAttachment, Project, Stored, Submitted } from '../../typings';
+import { IssueCommentAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
-export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, IssueCommentAttachment["uuid"], IssueCommentAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueCommentAttachment["uuid"], IssueCommentAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -22,18 +21,10 @@ export declare abstract class IssueCommentAttachmentService<TState extends Overm
         selectByIds: (uuids: string[]) => (state: any) => Stored<IssueCommentAttachment>[];
     };
     protected getId(model: Stored<IssueCommentAttachment>): IssueCommentAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<IssueCommentAttachment>;
-    protected buildPayload(model: Submitted<IssueCommentAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        issue_comment: string;
-    };
-    bulkAdd(payloads: {
-        issueCommentUuid: IssueComment["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueCommentAttachment>>;
-    delete(uuid: IssueCommentAttachment["uuid"]): Promise<void>;
+    protected getBlockers(model: Stored<IssueCommentAttachment>): string[];
+    protected getBlocks(model: Stored<IssueCommentAttachment>): string[];
+    protected buildModel(data: Payload<IssueCommentAttachment>): Submitted<IssueCommentAttachment>;
+    protected buildPayload(model: Submitted<IssueCommentAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueCommentAttachment>): object;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueCommentAttachment[]>;
 }

package/dist/sdk/services/IssueService.d.ts

@@ -25,5 +25,6 @@ export declare abstract class IssueService<TState extends OvermapRootState, TSDK
     update(payload: UUID<Partial<Payload<Issue>>>): OptimisticModelResult<Issue>;
     bulkUpdate(payloads: UUID<Partial<Payload<Issue>>>[], batchSize?: number): [Stored<Issue>[], Promise<Created<Issue>[]>[]];
     delete(uuid: Issue["uuid"]): Promise<undefined>;
+    bulkDelete(uuids: Issue["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Issue[]>;
 }

package/dist/sdk/services/IssueTypeAttachmentService.d.ts

@@ -1,9 +1,8 @@
-import { FilePayload, IssueType, IssueTypeAttachment, Organization, Stored, Submitted } from '../../typings';
+import { IssueTypeAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
-export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, IssueTypeAttachment["uuid"], IssueTypeAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueTypeAttachment["uuid"], IssueTypeAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -22,18 +21,10 @@ export declare abstract class IssueTypeAttachmentService<TState extends OvermapR
         selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeAttachment>[];
     };
     protected getId(model: Stored<IssueTypeAttachment>): IssueTypeAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<IssueTypeAttachment>;
-    protected buildPayload(model: Submitted<IssueTypeAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        issue_type: string;
-    };
-    bulkAdd(payloads: {
-        issueTypeUuid: IssueType["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueTypeAttachment>>;
-    delete(uuid: IssueTypeAttachment["uuid"]): Promise<void>;
+    protected getBlockers(model: Stored<IssueTypeAttachment>): string[];
+    protected getBlocks(model: Stored<IssueTypeAttachment>): string[];
+    protected buildModel(data: Payload<IssueTypeAttachment>): Submitted<IssueTypeAttachment>;
+    protected buildPayload(model: Submitted<IssueTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueTypeAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeAttachment[]>;
 }

package/dist/sdk/services/IssueTypeFieldValuesAttachmentService.d.ts

@@ -1,31 +1,31 @@
-import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, Project } from '../../typings';
+import { IssueTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeFieldValuesAttachment["uuid"], IssueTypeFieldValuesAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueTypeFieldValuesAttachment["uuid"], IssueTypeFieldValuesAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
-        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachment">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachments">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachment">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachments">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachment">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachments">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachments">;
         deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldValuesAttachments/deleteIssueTypeFieldValuesAttachment">;
         deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldValuesAttachments/deleteIssueTypeFieldValuesAttachments">;
-        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/initializeIssueTypeFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/initializeIssueTypeFieldValuesAttachments">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<IssueTypeFieldValuesAttachment> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<IssueTypeFieldValuesAttachment>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldValuesAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldValuesUuid: IssueTypeFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldValuesAttachment>>;
+    protected getId(model: Stored<IssueTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<IssueTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<IssueTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<IssueTypeFieldValuesAttachment>): Submitted<IssueTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<IssueTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueTypeFieldValuesAttachment>): object;
     bulkDelete(uuids: IssueTypeFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldValuesAttachment[]>;
 }

package/dist/sdk/services/IssueTypeFieldsAttachmentService.d.ts

@@ -1,30 +1,30 @@
-import { IssueTypeFields, IssueTypeFieldsAttachment, Organization } from '../../typings';
+import { IssueTypeFieldsAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeFieldsAttachment["uuid"], IssueTypeFieldsAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueTypeFieldsAttachment["uuid"], IssueTypeFieldsAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
-        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachments">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachments">;
         deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachment">;
         deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachments">;
-        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<IssueTypeFieldsAttachment> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<IssueTypeFieldsAttachment>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldsAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldsRevisionUuid: IssueTypeFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldsAttachment>>;
+    protected getId(model: Stored<IssueTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<IssueTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<IssueTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<IssueTypeFieldsAttachment>): Submitted<IssueTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<IssueTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueTypeFieldsAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldsAttachment[]>;
 }

package/dist/sdk/services/ProjectAttachmentService.d.ts

@@ -1,9 +1,8 @@
-import { FilePayload, Organization, Project, ProjectAttachment, Stored, Submitted } from '../../typings';
+import { Organization, Payload, ProjectAttachment, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, ProjectAttachment["uuid"], ProjectAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProjectAttachment["uuid"], ProjectAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -22,18 +21,10 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
         selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectAttachment>[];
     };
     protected getId(model: Stored<ProjectAttachment>): ProjectAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<ProjectAttachment>;
-    protected buildPayload(model: Submitted<ProjectAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        project: string;
-    };
-    bulkAdd(payloads: {
-        projectUuid: Project["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
+    protected getBlockers(model: Stored<ProjectAttachment>): string[];
+    protected getBlocks(model: Stored<ProjectAttachment>): string[];
+    protected buildModel(data: Payload<ProjectAttachment>): Submitted<ProjectAttachment>;
+    protected buildPayload(model: Submitted<ProjectAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProjectAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProjectAttachment[]>;
 }

package/dist/sdk/services/ProjectFileService.d.ts

@@ -1,28 +1,32 @@
-import { Project, ProjectFile } from '../../typings';
+import { Payload, Project, ProjectFile, Stored, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticGenericResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProjectFile["uuid"], ProjectFile, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProjectFile["uuid"], ProjectFile, TState, TSDK> {
     name: string;
     url: string;
     actions: {
-        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/addProjectFile">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/addProjectFiles">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/setProjectFile">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/setProjectFiles">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/updateProjectFile">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/updateProjectFiles">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/addProjectFile">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/addProjectFiles">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/setProjectFile">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/setProjectFiles">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/updateProjectFile">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/updateProjectFiles">;
         deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectFiles/deleteProjectFile">;
         deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectFiles/deleteProjectFiles">;
-        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProjectFile> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProjectFile>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectFile> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectFile>[];
     };
-    saveExisting(file: ProjectFile): Promise<ProjectFile>;
-    saveActive(): OptimisticGenericResult<ProjectFile>;
-    delete(uuid: ProjectFile["uuid"]): Promise<undefined>;
+    protected getId(model: Stored<ProjectFile>): ProjectFile["uuid"];
+    protected getBlockers(model: Stored<ProjectFile>): string[];
+    protected getBlocks(model: Stored<ProjectFile>): string[];
+    protected buildModel(data: Payload<ProjectFile>): Submitted<ProjectFile>;
+    protected buildPayload(model: Submitted<ProjectFile>): object;
+    protected buildBulkPayload(model: Submitted<ProjectFile>): object;
+    update(payload: UUID<Partial<Pick<ProjectFile, "bounds" | "canvas_bounds" | "z_index">>>): OptimisticModelResult<ProjectFile>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProjectFile[]>;
 }

package/dist/sdk/services/index.d.ts

@@ -64,4 +64,4 @@ export * from './TeamService';
 export * from './UserService';
 export * from './BaseModelApiService';
 export * from './BaseOfflineModelApiService';
-export * from './BaseOfflineAttachmentModelService';
+export * from './BaseOfflineFileModelApiService';

package/dist/sdk/typings.d.ts

@@ -1,10 +1,9 @@
 import { Store } from '@reduxjs/toolkit';
 import { BaseState } from '../store';
-import { Created, Model, Stored, Submitted } from '../typings';
+import { Created, GetS3UrlResponse, Model, RequiredFileModel, Stored } from '../typings';
 import { HttpMethod } from '../enums';
 import { DeferredPromise } from '../utils';
 import { BaseSDK } from './base';
-import { GetS3UrlResponse, GetS3UrlSuccessResponse } from './services';
 export type OvermapSDKConstructor<TState extends BaseState, TSDK extends BaseSDK<TState>> = new (store: Store<TState>) => TSDK;
 export interface TokenPair {
     accessToken: string;
@@ -65,7 +64,17 @@ export type OptimisticModelResult<TModel extends Model> = [Stored<TModel>, Promi
 /**
  * Analogous to `OptimisticModelResult<TModel>`, but for multiple model instances.
  */
-export type OptimisticMultipleModelResult<TModel extends Model> = [Submitted<TModel>[], Promise<Created<TModel>[]>];
+export type OptimisticMultipleModelResult<TModel extends Model> = [Stored<TModel>[], Promise<Created<TModel>[]>];
+export type OptimisticFileModelResult<TModel extends RequiredFileModel> = [
+    Stored<TModel>,
+    Promise<Created<TModel>>,
+    Promise<string>
+];
+export type OptimisticMultipleFileModelResult<TModel extends RequiredFileModel> = [
+    Stored<TModel>[],
+    Promise<Created<TModel>[]>,
+    Promise<string[]>
+];
 /**
  * Used in situations such as deleting a model, where nothing is expected in return.
  * @deprecated Use `Promise<undefined>` directly instead.
@@ -80,4 +89,3 @@ export type PaginatedResult<T> = {
     previous: string | null;
     results: T;
 };
-export type PresignedUrlsResponse = Record<string, GetS3UrlSuccessResponse>;

package/dist/store/adapters/selectionAdapter.d.ts

@@ -1,13 +1,12 @@
 import { PayloadAction } from '@reduxjs/toolkit';
 import { SelectionState } from './typings';
-export interface SelectionAdapter<TSelection> {
-    selectOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
-    selectMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    unselectOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
-    unselectMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    toggleOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
-    toggleMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    initializeSelection: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    getInitialState: <TState extends object>(state: TState) => TState & SelectionState<TSelection>;
+export interface SelectionAdapter<TKey extends PropertyKey, TSelection> {
+    selectOne: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection>) => void;
+    selectMany: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
+    unselectOne: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection>) => void;
+    unselectMany: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
+    toggleOne: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection>) => void;
+    toggleMany: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
+    initializeSelection: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
 }
-export declare function createSelectionAdapter<TSelection>(): SelectionAdapter<TSelection>;
+export declare function createSelectionAdapter<TKey extends PropertyKey, TSelection>(key: TKey): SelectionAdapter<TKey, TSelection>;

package/dist/store/adapters/typings.d.ts

@@ -2,9 +2,7 @@ import { PayloadAction, ActionCreatorWithPayload } from '@reduxjs/toolkit';
 export interface ModelState<TId extends number | string | symbol, TModel> {
     instances: Record<TId, TModel>;
 }
-export interface SelectionState<TSelection> {
-    selection: TSelection[];
-}
+export type SelectionState<TKey extends PropertyKey, TSelection> = Record<TKey, TSelection[]>;
 export type InitializePayloadAction<TModel> = PayloadAction<TModel[]>;
 export type AddOnePayloadAction<TModel> = PayloadAction<TModel>;
 export type AddManyPayloadAction<TModel> = PayloadAction<TModel[]>;

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

@@ -14,9 +14,6 @@ interface S3UrlPayload {
     url: string;
     fields: Record<string, string>;
 }
-/**
- * Stores the auth state of the app (tokens, and whether user is logged in or not)
- */
 export declare const fileSlice: import('@reduxjs/toolkit').Slice<FileState, {
     setUploadUrl: (state: import('immer').WritableDraft<FileState>, action: PayloadAction<S3UrlPayload>) => void;
 }, "file", "file", import('@reduxjs/toolkit').SliceSelectors<FileState>>;

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

@@ -107,6 +107,9 @@ export declare const selectIssueAssociations: ((state: {
 export declare const selectIssueAssociationById: OvermapSelectorWithArgs<IssueAssociation["uuid"], Stored<IssueAssociation> | undefined>;
 export declare const selectIssueAssociationsByIds: (uuids: string[]) => (state: any) => Stored<IssueAssociation>[];
 export declare const selectIssueAssociationsToIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<IssueAssociation>[]>;
+export declare const selectIssueAssociationsToIssues: OvermapSelectorWithArgs<Issue["uuid"][], Stored<IssueAssociation>[]>;
+export declare const selectIssueAssociationsOfIssues: OvermapSelectorWithArgs<Issue["uuid"][], Stored<IssueAssociation>[]>;
 export declare const selectIssueAssociationsOfIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<IssueAssociation>[]>;
 export declare const selectIssueAssociationsOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<IssueAssociation>[]>;
+export declare const selectIssueAssociationsOfAssets: OvermapSelectorWithArgs<Asset["uuid"][], Stored<IssueAssociation>[]>;
 export declare const issueAssociationReducer: import('redux').Reducer<IssueAssociationSliceState>;

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

@@ -1,10 +1,7 @@
-import { MultiPoint } from 'geojson';
 import { ProjectFile, Stored } from '../../typings';
-import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
 import { ModelState } from '../adapters';
 export interface ProjectFileState extends ModelState<ProjectFile["uuid"], Stored<ProjectFile>> {
-    activeProjectFileId: string | null;
-    isImportingProjectFile: boolean;
 }
 export declare const projectFileSlice: import('@reduxjs/toolkit').Slice<ProjectFileState, {
     initializeProjectFiles: import('@reduxjs/toolkit').CaseReducer<ProjectFileState, import('..').InitializePayloadAction<Stored<ProjectFile>>>;
@@ -16,17 +13,8 @@ export declare const projectFileSlice: import('@reduxjs/toolkit').Slice<ProjectF
     updateProjectFiles: import('@reduxjs/toolkit').CaseReducer<ProjectFileState, import('..').UpdateManyPayloadAction<Stored<ProjectFile>>>;
     deleteProjectFile: import('@reduxjs/toolkit').CaseReducer<ProjectFileState, import('..').DeleteOnePayloadAction<string>>;
     deleteProjectFiles: import('@reduxjs/toolkit').CaseReducer<ProjectFileState, import('..').DeleteManyPayloadAction<string>>;
-    setIsImportingProjectFile: (state: import('immer').WritableDraft<ProjectFileState>, action: {
-        payload: boolean;
-    }) => void;
-    saveActiveProjectFileBounds: (state: import('immer').WritableDraft<ProjectFileState>, action: {
-        payload: MultiPoint;
-    }) => void;
-    setActiveProjectFileId: (state: import('immer').WritableDraft<ProjectFileState>, action: {
-        payload: string | null;
-    }) => void;
 }, "projectFiles", "projectFiles", import('@reduxjs/toolkit').SliceSelectors<ProjectFileState>>;
-export declare const initializeProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">, setProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/setProjectFile">, setProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/setProjectFiles">, addProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/addProjectFile">, addProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/addProjectFiles">, updateProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/updateProjectFile">, updateProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/updateProjectFiles">, deleteProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectFiles/deleteProjectFile">, deleteProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectFiles/deleteProjectFiles">, setIsImportingProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "projectFiles/setIsImportingProjectFile">, setActiveProjectFileId: import('@reduxjs/toolkit').ActionCreatorWithPayload<string | null, "projectFiles/setActiveProjectFileId">, saveActiveProjectFileBounds: import('@reduxjs/toolkit').ActionCreatorWithPayload<MultiPoint, "projectFiles/saveActiveProjectFileBounds">;
+export declare const initializeProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">, setProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/setProjectFile">, setProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/setProjectFiles">, addProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/addProjectFile">, addProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/addProjectFiles">, updateProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/updateProjectFile">, updateProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/updateProjectFiles">, deleteProjectFile: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectFiles/deleteProjectFile">, deleteProjectFiles: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectFiles/deleteProjectFiles">;
 export declare const selectProjectFileMapping: (state: OvermapRootState) => Record<string, Stored<ProjectFile>>;
 export declare const selectProjectFiles: ((state: {
     versioning: import('./versioningSlice').VersioningState;
@@ -119,6 +107,4 @@ export declare const selectProjectFiles: ((state: {
 };
 export declare const selectProjectFileById: OvermapSelectorWithArgs<ProjectFile["uuid"], Stored<ProjectFile> | undefined>;
 export declare const selectProjectFilesByIds: (uuids: string[]) => (state: any) => Stored<ProjectFile>[];
-export declare const selectActiveProjectFileId: OvermapSelector<ProjectFile["uuid"] | null>;
-export declare const selectIsImportingProjectFile: OvermapSelector<boolean>;
 export declare const projectFileReducer: import('redux').Reducer<ProjectFileState>;