@overmap-ai/core 1.0.71-mapbox.6 → 1.0.71-mapbox.8

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

@@ -1,11 +1,11 @@
-import { BaseAttachmentService } from './BaseAttachmentService';
-import { AssetAttachment, Stored, OvermapRootState } from '../../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+import { AssetAttachment, OvermapRootState, Stored } from '../../typings';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseSDK } from '../base';
-import { AttachmentModel } from '../../enums';
 
 export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, AssetAttachment> {
-    attachmentModel: AttachmentModel;
+    name: string;
+    url: string;
     initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">;
     updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">;
@@ -13,7 +13,29 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
-    private buildOfflineAttachment;
-    attachFilesToAsset(files: File[], assetId: string): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
-    deleteAssetAttachment(attachmentId: string): Promise<void>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        asset: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        asset: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        assetId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
 }

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

@@ -7,6 +7,6 @@ export declare abstract class AssetService<TState extends OvermapRootState, TSDK
     add(payload: Payload<Asset>): OptimisticModelResult<Asset>;
     update(payload: Offline<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
     remove(id: string): Promise<undefined>;
-    bulkAdd(payloads: Omit<Payload<Asset>, "asset_type">[], assetTypeId: string, batchSize: number): Promise<Created<Asset>[]>[];
+    bulkAdd(payloads: Omit<Payload<Asset>, "asset_type" | "project">[], assetTypeId: string, projectId: number, batchSize: number): Promise<Created<Asset>[]>[];
     refreshStore(projectId: number): Promise<void>;
 }

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

@@ -8,7 +8,5 @@ export declare abstract class AssetStageService<TState extends OvermapRootState,
     bulkUpdate(stagesToUpdate: AssetStage[], assetTypeId: string): Promise<AssetStage[]>;
     bulkDelete(idsToDelete: string[]): Promise<undefined>;
     update(payload: Offline<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
-    linkForm(stageId: string, formId: string): Promise<undefined>;
-    unlinkForm(stageId: string, formId: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<undefined>;
+    refreshStore(organizationId: number): Promise<undefined>;
 }

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

@@ -1,19 +1,40 @@
-import { BaseAttachmentService } from './BaseAttachmentService';
-import { AssetTypeAttachment, Stored, OvermapRootState } from '../../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+import { AssetTypeAttachment, OvermapRootState, Stored } from '../../typings';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseSDK } from '../base';
-import { AttachmentModel } from '../../enums';
 
 export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, AssetTypeAttachment> {
-    attachmentModel: AttachmentModel;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">;
+    name: string;
+    url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
     updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">;
     removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
-    private buildOfflineAttachment;
-    attachFilesToAssetType(files: File[], assetTypeId: string): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
-    deleteAssetTypeAttachment(attachmentId: string): Promise<void>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        asset_type: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        asset_type: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        assetTypeId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
+    delete(attachmentId: string): Promise<void>;
+    refreshStore(organizationId: number): Promise<void>;
 }

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

@@ -0,0 +1,13 @@
+import { AssetTypeFieldValuesAttachment, Created, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+
+export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldValuesId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
+    bulkDelete(ids: string[]): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import { AssetTypeFieldValues, Created, Offline, OvermapRootState, Payload, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseApiService } from './BaseApiService';
+import { OptimisticModelResult } from '../typings';
+import { FieldValue } from '@overmap-ai/forms';
+
+export declare abstract class AssetTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetTypeFieldValues>): OptimisticModelResult<AssetTypeFieldValues>;
+    bulkAdd(payload: {
+        values: Record<string, FieldValue>;
+        payloads: {
+            values: Record<string, FieldValue>;
+            asset: string;
+            fields_revision: string;
+            published_at: string;
+        }[];
+    }, batchSize?: number): [Stored<AssetTypeFieldValues>[], Promise<Created<AssetTypeFieldValues>[]>[]];
+    update(payload: Offline<Partial<Payload<AssetTypeFieldValues>>>): OptimisticModelResult<AssetTypeFieldValues>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { AssetTypeFieldsAttachment, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+import { OptimisticMultipleModelResult } from '../typings';
+
+export declare abstract class AssetTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldsRevisionId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetTypeFieldsAttachment>>;
+    refreshStore(organization: number): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { AssetTypeFields, OvermapRootState, Payload } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseApiService } from './BaseApiService';
+import { OptimisticModelResult } from '../typings';
+
+export declare abstract class AssetTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetTypeFields>): OptimisticModelResult<AssetTypeFields>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -7,5 +7,5 @@ export declare abstract class AssetTypeService<TState extends OvermapRootState,
     add(payload: Payload<AssetType>): OptimisticModelResult<AssetType>;
     update(payload: Offline<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;
     delete(assetTypeId: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    refreshStore(organizationId: number): Promise<void>;
 }

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

@@ -1,40 +1,38 @@
 import { ActionCreatorWithPayload } from '@reduxjs/toolkit';
 import { OptimisticMultipleModelResult } from '../typings';
-import { AttachmentModel } from '../../enums';
-import { Attachment, OfflineModel, OvermapRootState, OvermapSelectorWithArgs, Stored, Submitted } from '../../typings';
+import { Attachment, FileModelPayload, OfflineModel, OvermapRootState, OvermapSelectorWithArgs, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseUploadService } from './BaseUploadService';
 
-export interface AttachmentPayload {
+export interface AttachmentPayload extends FileModelPayload {
     offline_id: OfflineModel["offline_id"];
-    name: Attachment["file_name"];
-    sha1: Attachment["file_sha1"];
     description: Attachment["description"];
 }
-export interface FilePayload {
-    sha1: Attachment["file_sha1"];
-    file_type: string;
-    extension: string;
-    size: number;
-}
 export interface BuildOfflineAttachmentData<TModelId> {
     file: File;
-    sha1: string;
-    submittedAt: string;
-    createdBy?: number;
+    file_sha1: string;
+    submitted_at: string;
+    created_by?: number;
     description?: string;
     modelId: TModelId;
 }
+export interface BuildAttachmentPayloadData<TModelId> extends AttachmentPayload {
+    modelId: TModelId;
+}
 export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string | number, TAttachment extends Attachment> extends BaseUploadService<TState, TSDK> {
-    abstract readonly attachmentModel: AttachmentModel;
-    abstract readonly initializeAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly name: string;
+    abstract readonly url: string;
     abstract readonly addAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
     abstract readonly updateAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
     abstract readonly removeAttachments: ActionCreatorWithPayload<string[]>;
     abstract readonly setAttachment: ActionCreatorWithPayload<Stored<TAttachment>>;
     abstract readonly removeAttachment: ActionCreatorWithPayload<string>;
     abstract readonly selectAttachment: OvermapSelectorWithArgs<string, Stored<TAttachment> | undefined>;
-    protected attachFiles(files: File[], modelId: TModelId, buildOfflineAttachment: (data: BuildOfflineAttachmentData<TModelId>) => Stored<TAttachment>): Promise<OptimisticMultipleModelResult<TAttachment>>;
-    protected deleteAttachment(attachmendId: string): Promise<void>;
-    refreshStore(projectId: number, _organizationId?: number): Promise<void>;
+    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData<TModelId>): Stored<TAttachment>;
+    protected abstract buildAttachmentPayload(data: BuildAttachmentPayloadData<TModelId>): AttachmentPayload;
+    _bulkAdd(payloads: {
+        modelId: TModelId;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<TAttachment>>;
+    _delete(attachmendId: string): Promise<void>;
 }

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

@@ -1,9 +1,10 @@
 import { BaseApiService } from './BaseApiService';
 import { PresignedUrlsResponse } from '../typings';
-import { OvermapRootState } from '../../typings';
+import { FilePayload, OvermapRootState } from '../../typings';
 import { BaseSDK } from '../base';
 
 export declare abstract class BaseUploadService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     protected getNumberOfAttachmentsWithSha1(sha1: string): number;
     protected processPresignedUrls(presignedUrls: PresignedUrlsResponse): Record<string, Promise<undefined>>;
+    protected getFilePayload(file: File): Promise<FilePayload>;
 }

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

@@ -1,21 +1,41 @@
-import { BaseAttachmentService } from './BaseAttachmentService';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 import { DocumentAttachment, OvermapRootState, Stored } from '../../typings';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseSDK } from '../base';
-import { AttachmentModel } from '../../enums';
 
 export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, DocumentAttachment> {
-    attachmentModel: AttachmentModel;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">;
+    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>;
-    private buildOfflineAttachment;
-    attachFilesToDocument(files: File[], documentId: string): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
-    deleteDocumentAttachment(attachmentId: string): Promise<void>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        document: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        document: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        documentId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
+    delete(id: string): Promise<void>;
     private makeReadable;
     refreshStore(projectId: number, organizationId: number): Promise<void>;
 }

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

@@ -0,0 +1,13 @@
+import { FormRevisionAttachment, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+import { OptimisticMultipleModelResult } from '../typings';
+
+export declare abstract class FormRevisionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        revisionId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<FormRevisionAttachment>>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { FormRevision, FormRevisionPayload, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+import { OptimisticModelResult } from '../typings';
+
+export declare abstract class FormRevisionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    add(payload: FormRevisionPayload): OptimisticModelResult<FormRevision>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -1,21 +1,18 @@
-import { Form, FormRevision, FormRevisionAttachment, FormRevisionPayload, OvermapRootState, Stored, Created } from '../../typings';
+import { Created, Form, FormRevision, OvermapRootState, Payload, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseUploadService } from './BaseUploadService';
 import { ISerializedField } from '@overmap-ai/forms';
 
+/**
+ * Finds and separates image files from form revision fields. The image attribute is deleted from the field objects and
+ * is returned separately from the image files as they are stored in a different table.
+ */
+export declare const separateImageFromFields: (fields: ISerializedField[]) => Promise<{
+    fields: ISerializedField[];
+    images: Record<string, File>;
+}>;
 export declare abstract class FormService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
-    private bulkAddRevisionAttachments;
-    private add;
-    addForOrganization(organizationId: number, initialRevision: FormRevisionPayload): Promise<[Stored<Form>, Stored<FormRevision<ISerializedField>>, Stored<FormRevisionAttachment>[], Promise<Created<FormRevision<ISerializedField>>>, Promise<Created<FormRevisionAttachment>[]>]>;
-    addForProject(projectId: number, initialRevision: FormRevisionPayload): Promise<[Stored<Form>, Stored<FormRevision<ISerializedField>>, Stored<FormRevisionAttachment>[], Promise<Created<FormRevision<ISerializedField>>>, Promise<Created<FormRevisionAttachment>[]>]>;
-    addForIssueType(issueTypeId: string, initialRevision: FormRevisionPayload): Promise<[Stored<Form>, Stored<FormRevision<ISerializedField>>, Stored<FormRevisionAttachment>[], Promise<Created<FormRevision<ISerializedField>>>, Promise<Created<FormRevisionAttachment>[]>]>;
-    addForAssetType(assetTypeId: string, initialRevision: FormRevisionPayload): Promise<[Stored<Form>, Stored<FormRevision<ISerializedField>>, Stored<FormRevisionAttachment>[], Promise<Created<FormRevision<ISerializedField>>>, Promise<Created<FormRevisionAttachment>[]>]>;
-    createRevision(formId: string, revision: FormRevisionPayload): Promise<[
-        Stored<FormRevision>,
-        Stored<FormRevisionAttachment>[],
-        Promise<Created<FormRevision>>,
-        Promise<Created<FormRevisionAttachment>[]>
-    ]>;
+    add(payload: Payload<Form>, initialRevision: Pick<FormRevision, "title" | "description" | "fields">): [Stored<Form>, Stored<FormRevision>, Promise<Created<FormRevision>>];
     delete(id: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    refreshStore(organizationId: number): Promise<void>;
 }

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

@@ -0,0 +1,14 @@
+import { FormSubmissionAttachment, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+import { OptimisticMultipleModelResult } from '../typings';
+
+export declare abstract class FormSubmissionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        submissionId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<FormSubmissionAttachment>>;
+    bulkDelete(attachmentsIds: string[]): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -1,36 +1,16 @@
-import { Created, FormSubmission, FormSubmissionAttachment, Offline, OvermapRootState, Payload, Stored } from '../../typings';
-import { PresignedUrlsResponse } from '../typings';
+import { FormSubmission, Offline, OvermapRootState, Payload } from '../../typings';
+import { OptimisticModelResult } from '../typings';
 import { BaseSDK } from '../base';
 import { BaseUploadService } from './BaseUploadService';
 import { FieldValue } from '@overmap-ai/forms';
 
-interface BulkAddRequestReturnValue {
-    submissions: Created<FormSubmission>[];
-    attachments: Created<FormSubmissionAttachment>[];
-    presigned_urls: PresignedUrlsResponse;
-}
+export declare const separateFilesFromValues: (values: Record<string, FieldValue>) => {
+    values: Record<string, FieldValue>;
+    files: Record<string, File[]>;
+};
 export declare abstract class FormSubmissionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
-    private bulkAddSubmissionAttachments;
-    private bulkDeleteSubmissionAttachments;
-    add(payload: Payload<FormSubmission>): Promise<[
-        Stored<FormSubmission>,
-        Stored<FormSubmissionAttachment>[],
-        Promise<Created<FormSubmission>>,
-        Promise<Created<FormSubmissionAttachment>[]>
-    ]>;
-    bulkAdd(args: {
-        formRevision: string;
-        commonFieldValues: Record<string, FieldValue>;
-        fieldValuesByAsset: Record<string, Record<string, FieldValue>>;
-    }, batchSize: number): Promise<Promise<BulkAddRequestReturnValue>[]>;
-    update(payload: Offline<Partial<Payload<FormSubmission>>>): Promise<[
-        Stored<FormSubmission>,
-        Stored<FormSubmissionAttachment>[],
-        Promise<Created<FormSubmission>>,
-        Promise<Created<FormSubmissionAttachment>[]>,
-        Promise<void>
-    ]>;
+    add(payload: Payload<FormSubmission>): OptimisticModelResult<FormSubmission>;
+    update(payload: Offline<Partial<Payload<FormSubmission>>>): OptimisticModelResult<FormSubmission>;
     delete(id: string): Promise<undefined>;
     refreshStore(projectId: number): Promise<void>;
 }
-export {};

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

@@ -1,9 +1,9 @@
 import { IssueAssociation, OvermapRootState, Payload } from '../../typings';
 import { OptimisticModelResult } from '../typings';
 import { BaseSDK } from '../base';
-import { BaseUploadService } from './BaseUploadService';
+import { BaseApiService } from './BaseApiService';
 
-export declare abstract class IssueAssociationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+export declare abstract class IssueAssociationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<IssueAssociation>): OptimisticModelResult<IssueAssociation>;
     delete(id: string): Promise<void>;
     refreshStore(projectId: number): Promise<void>;

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

@@ -1,19 +1,40 @@
-import { BaseAttachmentService } from './BaseAttachmentService';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 import { OptimisticMultipleModelResult } from '../typings';
 import { IssueAttachment, OvermapRootState, Stored } from '../../typings';
 import { BaseSDK } from '../base';
-import { AttachmentModel } from '../../enums';
 
 export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueAttachment> {
-    attachmentModel: AttachmentModel;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
+    name: string;
+    url: string;
     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>;
-    private buildOfflineAttachment;
-    attachFilesToIssue(files: File[], issueId: string): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
-    deleteIssueAttachment(attachmentId: string): Promise<void>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        issue: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        issueId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
 }

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

@@ -3,9 +3,6 @@ import { Issue, Offline, OvermapRootState, Payload } from '../../typings';
 import { BaseApiService } from './BaseApiService';
 import { BaseSDK } from '../base';
 
-/**
- * Handles CRUD operations on issues
- */
 export declare abstract class IssueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Issue>): OptimisticModelResult<Issue>;
     update(payload: Offline<Partial<Payload<Issue>>>): OptimisticModelResult<Issue>;

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

@@ -0,0 +1,14 @@
+import { IssueTypeFieldValuesAttachment, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+import { OptimisticMultipleModelResult } from '../typings';
+
+export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldValuesId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldValuesAttachment>>;
+    bulkDelete(attachmentsIds: string[]): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import { IssueTypeFieldValues, Offline, OvermapRootState, Payload } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseApiService } from './BaseApiService';
+import { OptimisticModelResult } from '../typings';
+
+export declare abstract class IssueTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<IssueTypeFieldValues>): OptimisticModelResult<IssueTypeFieldValues>;
+    update(payload: Offline<Partial<Payload<IssueTypeFieldValues>>>): OptimisticModelResult<IssueTypeFieldValues>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { IssueTypeFieldsAttachment, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+import { OptimisticMultipleModelResult } from '../typings';
+
+export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldsRevisionId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldsAttachment>>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { IssueTypeFields, OvermapRootState, Payload } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseApiService } from './BaseApiService';
+import { OptimisticModelResult } from '../typings';
+
+export declare abstract class IssueTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<IssueTypeFields>): OptimisticModelResult<IssueTypeFields>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -1,19 +1,40 @@
-import { BaseAttachmentService } from './BaseAttachmentService';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 import { OvermapRootState, ProjectAttachment, Stored } from '../../typings';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseSDK } from '../base';
-import { AttachmentModel } from '../../enums';
 
 export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment> {
-    attachmentModel: AttachmentModel;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
+    name: string;
+    url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
     updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
     removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, ProjectAttachment | undefined>;
-    private buildOfflineAttachment;
-    attachFilesToProject(files: File[], projectId: number): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    deleteProjectAttachment(attachmentId: string): Promise<void>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<number>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        project: number;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<number>): {
+        project: number;
+        modelId: number;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        projectId: number;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
+    delete(attachmentId: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
 }