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

package/dist/sdk/constants.d.ts

@@ -1,4 +1,4 @@
 export declare const DEFAULT_PAGE_SIZE = 10000;
-export declare const ATTACHMENT_MODEL_DEFAULT_PAGE_SIZE = 200;
+export declare const FILE_MODEL_DEFAULT_PAGE_SIZE = 200;
 export declare const DISCARD_HTTP_STATUSES: number[];
 export declare const MAX_SERVICE_BATCH_SIZE = 10000;

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

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

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

@@ -1,8 +1,8 @@
-import { AssetProcedureStepFieldValues, AssetProcedureStepFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { AssetProcedureStepFieldValuesAttachment, Payload, Project, Stored, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFieldValuesAttachment["uuid"], AssetProcedureStepFieldValuesAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureStepFieldValuesAttachment["uuid"], AssetProcedureStepFieldValuesAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -20,14 +20,12 @@ export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TSt
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValuesAttachment> | undefined>;
         selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValuesAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldValuesUuid: AssetProcedureStepFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[], batchSize?: number): Promise<[
-        Stored<AssetProcedureStepFieldValuesAttachment>[],
-        Promise<Created<AssetProcedureStepFieldValuesAttachment>[]>[]
-    ]>;
+    protected getId(model: Stored<AssetProcedureStepFieldValuesAttachment>): string;
+    protected getBlockers(payload: UUID<Omit<Payload<AssetProcedureStepFieldValuesAttachment>, "file_type" | "file_url">>): string[];
+    protected getBlocks(model: Stored<AssetProcedureStepFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureStepFieldValuesAttachment>): Submitted<AssetProcedureStepFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureStepFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureStepFieldValuesAttachment>): object;
     bulkDelete(uuids: AssetProcedureStepFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldValuesAttachment[]>;
 }

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

@@ -1,30 +1,30 @@
-import { AssetProcedureStepFields, AssetProcedureStepFieldsAttachment, Organization } from '../../typings';
+import { AssetProcedureStepFieldsAttachment, 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 AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFieldsAttachment["uuid"], AssetProcedureStepFieldsAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureStepFieldsAttachment["uuid"], AssetProcedureStepFieldsAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
-        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachment">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachments">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachment">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachments">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachment">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachments">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachments">;
         deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldsAttachments/deleteAssetProcedureStepFieldsAttachment">;
         deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldsAttachments/deleteAssetProcedureStepFieldsAttachments">;
-        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/initializeAssetProcedureStepFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/initializeAssetProcedureStepFieldsAttachments">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetProcedureStepFieldsAttachment> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<AssetProcedureStepFieldsAttachment>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldsAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldsRevisionUuid: AssetProcedureStepFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureStepFieldsAttachment>>;
+    protected getId(model: Stored<AssetProcedureStepFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureStepFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureStepFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureStepFieldsAttachment>): Submitted<AssetProcedureStepFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureStepFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureStepFieldsAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldsAttachment[]>;
 }

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

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

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

@@ -1,8 +1,8 @@
-import { AssetProcedureTypeFieldValues, AssetProcedureTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { AssetProcedureTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFieldValuesAttachment["uuid"], AssetProcedureTypeFieldValuesAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeFieldValuesAttachment["uuid"], AssetProcedureTypeFieldValuesAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -20,14 +20,12 @@ export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TSt
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValuesAttachment> | undefined>;
         selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValuesAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldValuesUuid: AssetProcedureTypeFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[], batchSize?: number): Promise<[
-        Stored<AssetProcedureTypeFieldValuesAttachment>[],
-        Promise<Created<AssetProcedureTypeFieldValuesAttachment>[]>[]
-    ]>;
+    protected getId(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeFieldValuesAttachment>): Submitted<AssetProcedureTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeFieldValuesAttachment>): object;
     bulkDelete(uuids: AssetProcedureTypeFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldValuesAttachment[]>;
 }

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

@@ -1,30 +1,30 @@
-import { AssetProcedureTypeFields, AssetProcedureTypeFieldsAttachment, Organization } from '../../typings';
+import { AssetProcedureTypeFieldsAttachment, 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 AssetProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFieldsAttachment["uuid"], AssetProcedureTypeFieldsAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeFieldsAttachment["uuid"], AssetProcedureTypeFieldsAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
-        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachment">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachments">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachment">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachments">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachment">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachments">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachments">;
         deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldsAttachments/deleteAssetProcedureTypeFieldsAttachment">;
         deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldsAttachments/deleteAssetProcedureTypeFieldsAttachments">;
-        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/initializeAssetProcedureTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/initializeAssetProcedureTypeFieldsAttachments">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetProcedureTypeFieldsAttachment> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<AssetProcedureTypeFieldsAttachment>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldsAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldsRevisionUuid: AssetProcedureTypeFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureTypeFieldsAttachment>>;
+    protected getId(model: Stored<AssetProcedureTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeFieldsAttachment>): Submitted<AssetProcedureTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeFieldsAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldsAttachment[]>;
 }

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

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

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

@@ -1,8 +1,8 @@
-import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { AssetTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeFieldValuesAttachment["uuid"], AssetTypeFieldValuesAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeFieldValuesAttachment["uuid"], AssetTypeFieldValuesAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -20,11 +20,12 @@ export declare abstract class AssetTypeFieldValuesAttachmentService<TState exten
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment> | undefined>;
         selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldValuesAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldValuesUuid: AssetTypeFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
+    protected getId(model: Stored<AssetTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<AssetTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<AssetTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetTypeFieldValuesAttachment>): Submitted<AssetTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetTypeFieldValuesAttachment>): object;
     bulkDelete(uuids: AssetTypeFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeFieldValuesAttachment[]>;
 }

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

@@ -1,9 +1,8 @@
-import { AssetTypeFields, AssetTypeFieldsAttachment, Organization, Stored } from '../../typings';
+import { AssetTypeFieldsAttachment, 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 AssetTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeFieldsAttachment["uuid"], AssetTypeFieldsAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeFieldsAttachment["uuid"], AssetTypeFieldsAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -21,10 +20,11 @@ export declare abstract class AssetTypeFieldsAttachmentService<TState extends Ov
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment> | undefined>;
         selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldsAttachment>[];
     };
-    bulkAdd(payloads: {
-        fieldsRevisionUuid: AssetTypeFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetTypeFieldsAttachment>>;
+    protected getId(model: Stored<AssetTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetTypeFieldsAttachment>): Submitted<AssetTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetTypeFieldsAttachment>): object;
     refreshStore(organization: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeFieldsAttachment[]>;
 }

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

@@ -1,6 +1,6 @@
 import { AssetTypeIdentifierValue, 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 AssetTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeIdentifierValue["uuid"], AssetTypeIdentifierValue, TState, TSDK> {
@@ -22,6 +22,7 @@ export declare abstract class AssetTypeIdentifierValueService<TState extends Ove
         selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeIdentifierValue>[];
     };
     add(payload: Payload<AssetTypeIdentifierValue>): OptimisticModelResult<AssetTypeIdentifierValue>;
+    bulkAdd(payloads: Payload<AssetTypeIdentifierValue>[], batchSize?: number): OptimisticMultipleModelResult<AssetTypeIdentifierValue>;
     delete(uuid: AssetTypeIdentifierValue["uuid"]): Promise<undefined>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeIdentifierValue[]>;
 }

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

@@ -0,0 +1,17 @@
+import { OvermapRootState } from '../../store';
+import { FileAnnotated, Payload, RequiredFileModel, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticFileModelResult, OptimisticMultipleFileModelResult } from '../typings';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class BaseOfflineFileModelApiService<TModelId extends string, TModel extends RequiredFileModel, TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<TModelId, TModel, TState, TSDK> {
+    protected pageSize: number;
+    protected abstract getId(model: Stored<TModel>): TModelId;
+    protected abstract getBlockers(model: Stored<TModel>): string[];
+    protected abstract getBlocks(model: Stored<TModel>): string[];
+    protected abstract buildModel(data: Payload<TModel>): Submitted<TModel>;
+    protected abstract buildPayload(model: Submitted<TModel>): object;
+    protected abstract buildBulkPayload(model: Submitted<TModel>): object;
+    add(payload: Payload<TModel> | FileAnnotated<Omit<Payload<TModel>, keyof RequiredFileModel>>): Promise<OptimisticFileModelResult<TModel>>;
+    bulkAdd(payloads: (Payload<TModel> | FileAnnotated<Omit<Payload<TModel>, keyof RequiredFileModel>>)[], batchSize?: number): Promise<OptimisticMultipleFileModelResult<TModel>>;
+    delete(uuid: TModelId): Promise<void>;
+}

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

@@ -1,6 +1,6 @@
 import { ResultAction } from '@redux-offline/redux-offline/lib/types';
 import { ActionCreatorWithPayload, UnknownAction } from '@reduxjs/toolkit';
-import { BaseState } from '../../store';
+import { BaseState, Selector } from '../../store';
 import { BaseSDK } from '../base';
 import { OfflineSDKRequest, PaginatedSDKRequest, SDKRequest } from '../typings';
 export declare const CLASS_NAME_TO_SERVICE: Record<string, BaseService<BaseState, BaseSDK<BaseState>>>;
@@ -16,4 +16,5 @@ export declare abstract class BaseService<TStore extends BaseState, TSDK extends
     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;
+    protected select<TRet>(selector: Selector<TStore, TRet>): TRet;
 }

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

@@ -1,9 +1,9 @@
-import { Document, DocumentAttachment, FilePayload, Organization, Stored, Submitted } from '../../typings';
+import { DocumentAttachment, FileAnnotated, Organization, Payload, RequiredFileModel, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
+import { OptimisticMultipleFileModelResult } from '../typings';
 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> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<DocumentAttachment["uuid"], DocumentAttachment, TState, TSDK> {
     name: string;
     url: string;
     actions: {
@@ -22,19 +22,12 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
         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_sha1: string;
-        file_extension: string;
-        document: string;
-    };
-    bulkAdd(payloads: {
-        documentUuid: Document["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
-    delete(uuid: DocumentAttachment["uuid"]): Promise<void>;
+    protected getBlockers(model: Stored<DocumentAttachment>): string[];
+    protected getBlocks(model: Stored<DocumentAttachment>): string[];
+    protected buildModel(data: Payload<DocumentAttachment>): Submitted<DocumentAttachment>;
+    protected buildPayload(model: Submitted<DocumentAttachment>): object;
+    protected buildBulkPayload(model: Submitted<DocumentAttachment>): object;
+    bulkAdd(payloads: (Payload<DocumentAttachment> | FileAnnotated<Omit<Payload<DocumentAttachment>, keyof RequiredFileModel>>)[], batchSize?: number): Promise<OptimisticMultipleFileModelResult<DocumentAttachment>>;
     private makeReadable;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<DocumentAttachment[]>;
 }

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

@@ -1,40 +1,18 @@
-import { FilePayload } from '../../typings';
+import { FilePayload, GetS3UrlResponse, PresignedUrlsResponse } from '../../typings';
 import { BaseSDK } from '../base';
-import { PresignedUrlsResponse } from '../typings';
 import { BaseState } from '../../store';
 import { BaseApiService } from './BaseApiService';
-export interface GetS3UrlSuccessResponse {
-    url: string;
-    fields: Record<string, string>;
-}
-interface GetS3UrlWarningResponse {
-    warning: string;
-}
-export type GetS3UrlResponse = GetS3UrlSuccessResponse | GetS3UrlWarningResponse;
-interface DatabaseFileProperties {
-    file_name: string;
-    file_sha1: string;
-    /** When uploading, this is the s3 key of the file.
-     * When downloading, this is the s3 public url.
-     */
-    file: string;
-}
 export declare abstract class FileService<TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     host: string;
-    private _dbPromise;
-    private renewUploadUrl;
+    private dbPromise;
+    private getDB;
     /**
      * Adds a file to the cache using the sha1 hash as the key and returns the sha1 hash.
      * @param file The file to add to the cache
-     * TODO: This should be removed once the bug described in [1] is fixed.
-     * @param sha1 The sha1 hash of the file to cache.
      */
-    addCache(file: File, sha1: string): Promise<void>;
+    addCache(file: File): Promise<void>;
     removeCache(sha1: string): Promise<void>;
     fetchCache(sha1: string): Promise<File | undefined>;
-    getOrRenewUploadUrl(sha1: string): Promise<GetS3UrlResponse>;
-    /** Ensure the file has been added to the file cache before calling `uploadFileToS3()` */
-    uploadFileToS3(sha1: string): Promise<[DatabaseFileProperties, Promise<undefined>]>;
     /**
      * Fetches a file based on its URL and SHA1. SHA1 values should be known ahead of time because the SHA1 and URL of
      * any file is stored in a FileModelMixin (see backend). If the expected SHA1 doesn't match the actual SHA1 of the
@@ -46,7 +24,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>>;
+    processPresignedUrl(sha1: string, presignedUrl: GetS3UrlResponse): Promise<void>;
+    processPresignedUrls(presignedUrls: PresignedUrlsResponse): Record<string, Promise<void>>;
     getFilePayload(file: File): Promise<FilePayload>;
 }
-export {};

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

@@ -1,30 +1,30 @@
-import { FormRevision, FormRevisionAttachment, Organization } from '../../typings';
+import { FormRevisionAttachment, 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 FormRevisionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<FormRevisionAttachment["uuid"], FormRevisionAttachment, TState, TSDK> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class FormRevisionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<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">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/addFormRevisionAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/addFormRevisionAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/setFormRevisionAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/setFormRevisionAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>, "formRevisionAttachments/updateFormRevisionAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<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">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<FormRevisionAttachment>[], "formRevisionAttachments/initializeFormRevisionAttachments">;
     };
     selectors: {
-        selectById: (uuid: string) => (state: any) => import('../..').Stored<FormRevisionAttachment> | undefined;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormRevisionAttachment>[];
+        selectById: (uuid: string) => (state: any) => Stored<FormRevisionAttachment> | undefined;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormRevisionAttachment>[];
     };
-    bulkAdd(payloads: {
-        revisionUuid: FormRevision["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<FormRevisionAttachment>>;
+    protected getId(model: Stored<FormRevisionAttachment>): string;
+    protected getBlockers(model: Stored<FormRevisionAttachment>): string[];
+    protected getBlocks(model: Stored<FormRevisionAttachment>): string[];
+    protected buildModel(data: Payload<FormRevisionAttachment>): Submitted<FormRevisionAttachment>;
+    protected buildPayload(model: Submitted<FormRevisionAttachment>): object;
+    protected buildBulkPayload(model: Submitted<FormRevisionAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormRevisionAttachment[]>;
 }

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

@@ -1,5 +1,6 @@
-import { Created, Form, FormRevision, Organization, Payload, Stored } from '../../typings';
+import { Form, 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 FormService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Form["uuid"], Form, TState, TSDK> {
@@ -20,7 +21,8 @@ export declare abstract class FormService<TState extends OvermapRootState, TSDK
         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>>];
+    add(payload: Payload<Form>): OptimisticModelResult<Form>;
+    update(payload: UUID<Partial<Payload<Form>>>): OptimisticModelResult<Form>;
     delete(uuid: Form["uuid"]): Promise<undefined>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Form[]>;
 }