@overmap-ai/core 1.0.78-improvements.0 → 1.0.78-issue-bulk-delete.0

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

@@ -0,0 +1,27 @@
+import { AddManyPayloadActionCreator, AddOnePayloadActionCreator, BaseState, DeleteManyPayloadActionCreator, DeleteOnePayloadActionCreator, InitializePayloadActionCreator, SelectorWithArgs, SetManyPayloadActionCreator, SetOnePayloadActionCreator, UpdateManyPayloadActionCreator, UpdateOnePayloadActionCreator } from '../../store';
+import { Model, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { ModelSDKRequest, PaginatedModelSDKRequest } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class BaseOfflineModelApiService<TPk extends string | number, TModel extends Model, TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    abstract url: string;
+    abstract name: string;
+    abstract actions: {
+        addOne: AddOnePayloadActionCreator<Stored<TModel>>;
+        addMany: AddManyPayloadActionCreator<Stored<TModel>>;
+        setOne: SetOnePayloadActionCreator<Stored<TModel>>;
+        setMany: SetManyPayloadActionCreator<Stored<TModel>>;
+        updateOne: UpdateOnePayloadActionCreator<Stored<TModel>>;
+        updateMany: UpdateManyPayloadActionCreator<Stored<TModel>>;
+        deleteOne: DeleteOnePayloadActionCreator<TPk>;
+        deleteMany: DeleteManyPayloadActionCreator<TPk>;
+        initialize: InitializePayloadActionCreator<Stored<TModel>>;
+    };
+    abstract selectors: {
+        selectById: SelectorWithArgs<TState, TPk, Stored<TModel> | undefined>;
+        selectByIds: SelectorWithArgs<TState, TPk[], Stored<TModel>[]>;
+    };
+    get(pk: TPk, signal?: AbortSignal): Promise<TModel>;
+    list(requestDetails: Omit<ModelSDKRequest, "method">, signal?: AbortSignal): Promise<TModel[]>;
+    listPaginated(requestDetails: Omit<PaginatedModelSDKRequest, "method">, signal?: AbortSignal): Promise<TModel[][]>;
+}

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

@@ -2,7 +2,7 @@ import { ResultAction } from '@redux-offline/redux-offline/lib/types';
 import { ActionCreatorWithPayload, UnknownAction } from '@reduxjs/toolkit';
 import { BaseState } from '../../store';
 import { BaseSDK } from '../base';
-import { SDKRequest } from '../typings';
+import { OfflineSDKRequest, PaginatedSDKRequest, SDKRequest } from '../typings';
 export declare const CLASS_NAME_TO_SERVICE: Record<string, BaseService<BaseState, BaseSDK<BaseState>>>;
 /**
  * Abstract base class for building a service that can enqueue API requests
@@ -10,7 +10,10 @@ export declare const CLASS_NAME_TO_SERVICE: Record<string, BaseService<BaseState
 export declare abstract class BaseService<TStore extends BaseState, TSDK extends BaseSDK<TStore>> {
     protected readonly client: TSDK;
     abstract readonly host: string;
+    protected readonly pageSize: number;
     protected constructor(sdk: TSDK);
-    protected enqueueRequest<TResult>(requestDetails: SDKRequest): Promise<TResult>;
+    protected performRequest<TResult>(requestDetails: SDKRequest, signal?: AbortSignal): Promise<TResult>;
+    protected enqueueRequest<TResult>(requestDetails: OfflineSDKRequest): Promise<TResult>;
+    protected performPagination<TResult>(requestDetails: PaginatedSDKRequest, signal?: AbortSignal): Promise<TResult[]>;
     protected dispatch(action: UnknownAction | ResultAction | ActionCreatorWithPayload<any, any>): void;
 }

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

@@ -1,35 +1,34 @@
-import { OvermapRootState } from '../../store';
-import { Document, DocumentAttachment, Organization, Project, Stored } from '../../typings';
+import { Document, DocumentAttachment, FilePayload, Organization, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, DocumentAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, DocumentAttachment["uuid"], DocumentAttachment> {
     name: string;
     url: string;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/addDocumentAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/setDocumentAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/updateDocumentAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<DocumentAttachment>[];
+    };
+    protected getId(model: Stored<DocumentAttachment>): DocumentAttachment["uuid"];
+    protected buildModel(data: BuildModelData): Submitted<DocumentAttachment>;
+    protected buildPayload(model: Submitted<DocumentAttachment>, filePayload: FilePayload): {
+        uuid: string;
         file_name: string;
-        file_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        document: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        document: string;
-        modelUuid: import('../..').UUIDModel["uuid"];
-        uuid: import('../..').UUIDModel["uuid"];
-        description: import('../..').Attachment["description"];
-        file_sha1: import('../..').FileWithNameModel["file_sha1"];
-        file_name: import('../..').FileWithNameModel["file_name"];
+        file_sha1: string;
         file_extension: string;
+        document: string;
     };
     bulkAdd(payloads: {
         documentUuid: Document["uuid"];
@@ -37,5 +36,5 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
     }[]): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
     delete(uuid: DocumentAttachment["uuid"]): Promise<void>;
     private makeReadable;
-    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<DocumentAttachment[]>;
 }

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

@@ -1,12 +1,28 @@
-import { OvermapRootState } from '../../store';
-import { Document, MovePosition, Organization, Payload, Project, UUID } from '../../typings';
+import { Document, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class DocumentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class DocumentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Document["uuid"], Document, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>, "documents/addDocument">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/addDocuments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>, "documents/setDocument">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/setDocuments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>, "documents/updateDocument">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/updateDocuments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documents/deleteDocument">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documents/deleteDocuments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Document>[], "documents/initializeDocuments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Document> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Document>[];
+    };
     add(payload: Payload<Document>): OptimisticModelResult<Document>;
     update(payload: UUID<Partial<Payload<Document>>>): OptimisticModelResult<Document>;
-    move(documentUuid: Document["uuid"], targetDocumentUuid: Document["uuid"] | null, position: MovePosition): Promise<Document[]>;
-    delete(uuid: Document["uuid"]): Promise<Document[]>;
-    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+    delete(uuid: Document["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Document[]>;
 }

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { EmailDomain, Organization } from '../../typings';
 import { BaseSDK } from '../base';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class EmailDomainsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseModelApiService } from './BaseModelApiService';
+export declare abstract class EmailDomainsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseModelApiService<EmailDomain["uuid"], EmailDomain, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>, "emailDomains/addEmailDomain">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>[], "emailDomains/addEmailDomains">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>, "emailDomains/setEmailDomain">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>[], "emailDomains/setEmailDomains">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>, "emailDomains/updateEmailDomain">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>[], "emailDomains/updateEmailDomains">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "emailDomains/deleteEmailDomains">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<EmailDomain>[], "emailDomains/initializeEmailDomains">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<EmailDomain> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => EmailDomain[];
+    };
     add(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
-    remove(emailDomain: EmailDomain): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+    delete(emailDomain: EmailDomain): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<EmailDomain[]>;
 }

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

@@ -1,5 +1,7 @@
-import { BaseState } from '../../store';
+import { FilePayload } from '../../typings';
 import { BaseSDK } from '../base';
+import { PresignedUrlsResponse } from '../typings';
+import { BaseState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export interface GetS3UrlSuccessResponse {
     url: string;
@@ -44,5 +46,7 @@ export declare abstract class FileService<TState extends BaseState, TSDK extends
      * example.
      */
     fetchFileFromUrl(url: string, expectedSha1: string, downloadedName?: string): Promise<File>;
+    processPresignedUrls(presignedUrls: PresignedUrlsResponse): Record<string, Promise<undefined>>;
+    getFilePayload(file: File): Promise<FilePayload>;
 }
 export {};

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

@@ -0,0 +1,28 @@
+import { FormIdentifier, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class FormIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormIdentifier["uuid"], FormIdentifier, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>, "formIdentifiers/addFormIdentifier">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>[], "formIdentifiers/addFormIdentifiers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>, "formIdentifiers/setFormIdentifier">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>[], "formIdentifiers/setFormIdentifiers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>, "formIdentifiers/updateFormIdentifier">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>[], "formIdentifiers/updateFormIdentifiers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formIdentifiers/deleteFormIdentifier">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formIdentifiers/deleteFormIdentifiers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifier>[], "formIdentifiers/initializeFormIdentifiers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<FormIdentifier> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormIdentifier>[];
+    };
+    add(payload: Payload<FormIdentifier>): OptimisticModelResult<FormIdentifier>;
+    update(payload: UUID<Partial<Payload<FormIdentifier>>>): OptimisticModelResult<FormIdentifier>;
+    delete(uuid: FormIdentifier["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormIdentifier[]>;
+}

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

@@ -0,0 +1,27 @@
+import { FormIdentifierValue, Organization, Payload, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class FormIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormIdentifierValue["uuid"], FormIdentifierValue, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>, "formIdentifierValues/addFormIdentifierValue">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>[], "formIdentifierValues/addFormIdentifierValues">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>, "formIdentifierValues/setFormIdentifierValue">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>[], "formIdentifierValues/setFormIdentifierValues">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>, "formIdentifierValues/updateFormIdentifierValue">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>[], "formIdentifierValues/updateFormIdentifierValues">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formIdentifierValues/deleteFormIdentifierValue">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formIdentifierValues/deleteFormIdentifierValues">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormIdentifierValue>[], "formIdentifierValues/initializeFormIdentifierValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<FormIdentifierValue> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormIdentifierValue>[];
+    };
+    add(payload: Payload<FormIdentifierValue>): OptimisticModelResult<FormIdentifierValue>;
+    delete(uuid: FormIdentifierValue["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormIdentifierValue[]>;
+}

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

@@ -1,13 +1,30 @@
-import { OvermapRootState } from '../../store';
 import { FormRevision, FormRevisionAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class FormRevisionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class FormRevisionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormRevisionAttachment["uuid"], FormRevisionAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>, "formRevisionAttachments/addFormRevisionAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>[], "formRevisionAttachments/addFormRevisionAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>, "formRevisionAttachments/setFormRevisionAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>[], "formRevisionAttachments/setFormRevisionAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>, "formRevisionAttachments/updateFormRevisionAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>[], "formRevisionAttachments/updateFormRevisionAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formRevisionAttachments/deleteFormRevisionAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formRevisionAttachments/deleteFormRevisionAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>[], "formRevisionAttachments/initializeFormRevisionAttachments">;
+    };
+    selectors: {
+        selectById: (uuid: string) => (state: any) => import('../..').Stored<FormRevisionAttachment> | undefined;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormRevisionAttachment>[];
+    };
     bulkAdd(payloads: {
         revisionUuid: FormRevision["uuid"];
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<FormRevisionAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormRevisionAttachment[]>;
 }

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { FormRevision, FormRevisionPayload, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class FormRevisionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class FormRevisionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormRevision["uuid"], FormRevision, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>, "formRevisions/addFormRevision">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>[], "formRevisions/addFormRevisions">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>, "formRevisions/setFormRevision">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>[], "formRevisions/setFormRevisions">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>, "formRevisions/updateFormRevision">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>[], "formRevisions/updateFormRevisions">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formRevisions/deleteFormRevision">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisions">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevision>[], "formRevisions/initializeFormRevisions">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<FormRevision> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormRevision>[];
+    };
     add(payload: FormRevisionPayload): OptimisticModelResult<FormRevision>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormRevision[]>;
 }

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { Created, Form, FormRevision, Organization, Payload, Stored } from '../../typings';
 import { BaseSDK } from '../base';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class FormService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class FormService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Form["uuid"], Form, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>, "forms/addForm">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>[], "forms/addForms">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>, "forms/setForm">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>[], "forms/setForms">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>, "forms/updateForm">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>[], "forms/updateForms">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "forms/deleteForm">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "forms/deleteForms">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Form>[], "forms/initializeForms">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Form>[];
+    };
     add(payload: Payload<Form>, initialRevision: Pick<FormRevision, "title" | "description" | "fields">): [Stored<Form>, Stored<FormRevision>, Promise<Created<FormRevision>>];
     delete(uuid: Form["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Form[]>;
 }

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

@@ -1,14 +1,31 @@
-import { OvermapRootState } from '../../store';
-import { FormSubmission, FormSubmissionAttachment, Project } from '../../typings';
+import { FormSubmission, FormSubmissionAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class FormSubmissionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+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> {
+    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">;
+        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">;
+    };
+    selectors: {
+        selectById: (uuid: string) => (state: any) => import('../..').Stored<FormSubmissionAttachment> | undefined;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormSubmissionAttachment>[];
+    };
     bulkAdd(payloads: {
         submissionUuid: FormSubmission["uuid"];
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<FormSubmissionAttachment>>;
     bulkDelete(uuids: FormSubmissionAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormSubmissionAttachment[]>;
 }

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

@@ -1,11 +1,28 @@
-import { OvermapRootState } from '../../store';
-import { FormSubmission, Payload, Project, UUID } from '../../typings';
+import { FormSubmission, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class FormSubmissionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class FormSubmissionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormSubmission["uuid"], FormSubmission, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/addFormSubmission">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/addFormSubmissions">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/setFormSubmission">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/setFormSubmissions">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>, "formSubmissions/updateFormSubmission">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/updateFormSubmissions">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "formSubmissions/deleteFormSubmission">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "formSubmissions/deleteFormSubmissions">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormSubmission>[], "formSubmissions/initializeFormSubmissions">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<FormSubmission> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormSubmission>[];
+    };
     add(payload: Payload<FormSubmission>): OptimisticModelResult<FormSubmission>;
     update(payload: UUID<Partial<Payload<FormSubmission>>>): OptimisticModelResult<FormSubmission>;
     delete(uuid: FormSubmission["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormSubmission[]>;
 }

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

@@ -1,12 +1,29 @@
-import { OvermapRootState } from '../../store';
-import { BulkGeoImagePayload, GeoImage, GeoImagePayload, Project, UUID } from '../../typings';
+import { BulkGeoImagePayload, GeoImage, GeoImagePayload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class GeoImageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+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> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/addGeoImage">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/addGeoImages">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/setGeoImage">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/setGeoImages">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/updateGeoImage">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/updateGeoImages">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/initializeGeoImages">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<GeoImage> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<GeoImage>[];
+    };
     add(payload: GeoImagePayload): Promise<OptimisticModelResult<GeoImage>>;
-    bulkAdd(payloads: BulkGeoImagePayload[], projectUuid: string): Promise<OptimisticMultipleModelResult<GeoImage>>;
+    bulkAdd(payloads: BulkGeoImagePayload[], projectUuid: Project["uuid"]): Promise<OptimisticMultipleModelResult<GeoImage>>;
     update(payload: UUID<Partial<Pick<GeoImagePayload, "title" | "description">>>): OptimisticModelResult<GeoImage>;
     delete(uuid: GeoImage["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<GeoImage[]>;
 }

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

@@ -1,10 +1,27 @@
-import { OvermapRootState } from '../../store';
-import { IssueAssociation, Payload, Project } from '../../typings';
+import { IssueAssociation, Payload, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueAssociationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+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> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/addIssueAssociation">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/addIssueAssociations">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/setIssueAssociation">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/setIssueAssociations">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/updateIssueAssociation">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/updateIssueAssociations">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAssociations/deleteIssueAssociation">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAssociations/deleteIssueAssociations">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/initializeIssueAssociations">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAssociation> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueAssociation>[];
+    };
     add(payload: Payload<IssueAssociation>): OptimisticModelResult<IssueAssociation>;
     delete(uuid: IssueAssociation["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAssociation[]>;
 }

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

@@ -1,41 +1,39 @@
-import { OvermapRootState } from '../../store';
-import { Issue, IssueAttachment, Project, Stored } from '../../typings';
+import { FilePayload, Issue, IssueAttachment, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueAttachment> {
+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> {
     name: string;
     url: string;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/addIssueAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/setIssueAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/updateIssueAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
+        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_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        issue: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        issue: string;
-        modelUuid: import('../..').UUIDModel["uuid"];
-        uuid: import('../..').UUIDModel["uuid"];
-        description: import('../..').Attachment["description"];
-        file_sha1: import('../..').FileWithNameModel["file_sha1"];
-        file_name: import('../..').FileWithNameModel["file_name"];
+        file_sha1: string;
         file_extension: string;
+        issue: string;
     };
     bulkAdd(payloads: {
         issueUuid: Issue["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
     delete(uuid: IssueAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAttachment[]>;
 }