@overmap-ai/core 1.0.75-more-clean-ups.0 → 1.0.76

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

@@ -1,10 +1,10 @@
-import { AgentUserConversation, OvermapRootState } from '../../typings';
+import { AgentUserConversation, OvermapRootState, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AgentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    startConversation(prompt: string, projectId: number): Promise<AgentUserConversation>;
-    continueConversation(prompt: string, conversationId: AgentUserConversation["offline_id"], projectId: number): Promise<void>;
-    fetchDetails(conversationId: AgentUserConversation["offline_id"]): Promise<void>;
-    rate(responseId: string, rating: 1 | 5): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    startConversation(prompt: string, projectUuid: Project["uuid"]): Promise<AgentUserConversation>;
+    continueConversation(prompt: string, conversationUuid: AgentUserConversation["uuid"], projectUuid: Project["uuid"]): Promise<void>;
+    fetchDetails(conversationUuid: AgentUserConversation["uuid"]): Promise<void>;
+    rate(responseUuid: string, rating: 1 | 5): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,8 +1,8 @@
-import { AssetAttachment, OvermapRootState, Stored } from '../../typings';
+import { Asset, AssetAttachment, OvermapRootState, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, AssetAttachment> {
+export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetAttachment> {
     name: string;
     url: string;
     initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">;
@@ -12,7 +12,7 @@ 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>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
         created_by: number | undefined;
@@ -22,19 +22,19 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
         description: string | undefined;
         asset: string;
     }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
         asset: string;
-        modelId: string;
-        offline_id: import('../..').OfflineModel["offline_id"];
+        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_extension: string;
     };
     bulkAdd(payloads: {
-        assetId: string;
+        assetUuid: Asset["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
-    delete(id: string): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    delete(uuid: AssetAttachment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -0,0 +1,39 @@
+import { AssetProcedure, AssetProcedureAttachment, Organization, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class AssetProcedureAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetProcedureAttachment> {
+    name: string;
+    url: string;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/addAssetProcedureAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/updateAssetProcedureAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureAttachments/deleteAssetProcedureAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureAttachments/deleteAssetProcedureAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>, "assetProcedureAttachments/setAssetProcedureAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        asset_procedure: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
+        asset_procedure: 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_extension: string;
+    };
+    bulkAdd(payloads: {
+        assetProcedureUuid: AssetProcedure["uuid"];
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureAttachment>>;
+    delete(uuid: AssetProcedureAttachment["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+import { AssetProcedureFieldValues, AssetProcedureFieldValuesAttachment, Created, OvermapRootState, Project, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+export declare abstract class AssetProcedureFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldValuesUuid: AssetProcedureFieldValues["uuid"];
+        fieldIdentifier: string;
+        file: File;
+    }[], batchSize?: number): Promise<[
+        Stored<AssetProcedureFieldValuesAttachment>[],
+        Promise<Created<AssetProcedureFieldValuesAttachment>[]>[]
+    ]>;
+    bulkDelete(uuids: AssetProcedureFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import { SerializedFieldValues } from '@overmap-ai/forms';
+import { Asset, AssetProcedureFields, AssetProcedureFieldValues, AssetProcedureInstance, Created, OvermapRootState, Payload, Project, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureFieldValues>): OptimisticModelResult<AssetProcedureFieldValues>;
+    bulkAdd(payload: {
+        values: SerializedFieldValues;
+        payloads: {
+            values: SerializedFieldValues;
+            asset: Asset["uuid"];
+            fields_revision: AssetProcedureFields["uuid"];
+            asset_procedure_instance: AssetProcedureInstance["uuid"];
+            published_at: string;
+        }[];
+    }, batchSize?: number): [Stored<AssetProcedureFieldValues>[], Promise<Created<AssetProcedureFieldValues>[]>[]];
+    update(payload: UUID<Partial<Payload<AssetProcedureFieldValues>>>): OptimisticModelResult<AssetProcedureFieldValues>;
+    delete(uuid: AssetProcedureFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import { AssetProcedureFields, AssetProcedureFieldsAttachment, Organization, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseUploadService } from './BaseUploadService';
+export declare abstract class AssetProcedureFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldsRevisionUuid: AssetProcedureFields["uuid"];
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureFieldsAttachment>>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import { AssetProcedureFields, Organization, OvermapRootState, Payload } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureFields>): OptimisticModelResult<AssetProcedureFields>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { AssetProcedureInstance, OvermapRootState, Payload, Project, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureInstanceService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureInstance>): OptimisticModelResult<AssetProcedureInstance>;
+    update(payload: UUID<Partial<Payload<AssetProcedureInstance>>>): OptimisticModelResult<AssetProcedureInstance>;
+    remove(uuid: AssetProcedureInstance["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { AssetProcedure, Organization, OvermapRootState, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedure>): OptimisticModelResult<AssetProcedure>;
+    update(payload: UUID<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;
+    remove(uuid: AssetProcedure["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -1,11 +1,11 @@
-import { Asset, Created, Offline, OvermapRootState, Payload } from '../../typings';
+import { Asset, AssetType, Created, OvermapRootState, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, 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" | "project">[], assetTypeId: string, projectId: number, batchSize: number): Promise<Created<Asset>[]>[];
-    refreshStore(projectId: number): Promise<void>;
+    update(payload: UUID<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
+    remove(uuid: Asset["uuid"]): Promise<undefined>;
+    bulkAdd(payloads: Omit<Payload<Asset>, "asset_type" | "project">[], assetTypeUuid: AssetType["uuid"], projectUuid: Project["uuid"], batchSize: number): Promise<Created<Asset>[]>[];
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,11 +1,11 @@
-import { AssetStageCompletion, OvermapRootState, Payload } from '../../typings';
+import { AssetStageCompletion, OvermapRootState, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetStageCompletionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetStageCompletion>): OptimisticModelResult<AssetStageCompletion>;
-    delete(id: string): Promise<undefined>;
+    delete(uuid: AssetStageCompletion["uuid"]): Promise<undefined>;
     bulkAdd(payloads: Payload<AssetStageCompletion>[]): OptimisticMultipleModelResult<AssetStageCompletion>;
-    bulkDelete(ids: string[]): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    bulkDelete(uuids: AssetStageCompletion["uuid"][]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,11 +1,11 @@
-import { AssetStage, Offline, OvermapRootState, Payload } from '../../typings';
+import { AssetProcedure, AssetStage, Organization, OvermapRootState, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    bulkAdd(stagesToSubmit: Omit<Payload<AssetStage>, "asset_type">[], assetTypeId: string): OptimisticMultipleModelResult<AssetStage>;
-    bulkUpdate(stagesToUpdate: AssetStage[], assetTypeId: string): Promise<AssetStage[]>;
-    bulkDelete(idsToDelete: string[]): Promise<undefined>;
-    update(payload: Offline<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
-    refreshStore(organizationId: number): Promise<undefined>;
+    bulkAdd(stagesToSubmit: Omit<Payload<AssetStage>, "asset_procedure">[], assetProcedureUuid: string): OptimisticMultipleModelResult<AssetStage>;
+    bulkUpdate(stagesToUpdate: AssetStage[], assetProcedureUuid: AssetProcedure["uuid"]): Promise<AssetStage[]>;
+    bulkDelete(uuids: AssetStage["uuid"][]): Promise<undefined>;
+    update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
 }

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

@@ -1,8 +1,8 @@
-import { AssetTypeAttachment, OvermapRootState, Stored } from '../../typings';
+import { AssetType, AssetTypeAttachment, Organization, OvermapRootState, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, AssetTypeAttachment> {
+export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment> {
     name: string;
     url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
@@ -11,7 +11,7 @@ export declare abstract class AssetTypeAttachmentService<TState extends OvermapR
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
         created_by: number | undefined;
@@ -21,19 +21,19 @@ export declare abstract class AssetTypeAttachmentService<TState extends OvermapR
         description: string | undefined;
         asset_type: string;
     }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
         asset_type: string;
-        modelId: string;
-        offline_id: import('../..').OfflineModel["offline_id"];
+        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_extension: string;
     };
     bulkAdd(payloads: {
-        assetTypeId: string;
+        assetTypeUuid: AssetType["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
-    delete(attachmentId: string): Promise<void>;
-    refreshStore(organizationId: number): Promise<void>;
+    delete(uuid: AssetTypeAttachment["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,12 +1,12 @@
-import { AssetTypeFieldValuesAttachment, Created, OvermapRootState, Stored } from '../../typings';
+import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, OvermapRootState, Project, 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;
+        fieldValuesUuid: AssetTypeFieldValues["uuid"];
         fieldIdentifier: string;
         file: File;
     }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
-    bulkDelete(ids: string[]): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    bulkDelete(uuids: AssetTypeFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,20 +1,20 @@
-import { FieldValue } from '@overmap-ai/forms';
-import { AssetTypeFieldValues, Created, Offline, OvermapRootState, Payload, Stored } from '../../typings';
+import { SerializedFieldValues } from '@overmap-ai/forms';
+import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, OvermapRootState, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 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>;
+        values: SerializedFieldValues;
         payloads: {
-            values: Record<string, FieldValue>;
-            asset: string;
-            fields_revision: string;
+            values: SerializedFieldValues;
+            asset: Asset["uuid"];
+            fields_revision: AssetTypeFields["uuid"];
             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>;
+    update(payload: UUID<Partial<Payload<AssetTypeFieldValues>>>): OptimisticModelResult<AssetTypeFieldValues>;
+    delete(uuid: AssetTypeFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

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

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

@@ -1,8 +1,8 @@
-import { AssetTypeFields, OvermapRootState, Payload } from '../../typings';
+import { AssetTypeFields, Organization, OvermapRootState, Payload } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 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>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,10 +1,10 @@
-import { AssetType, Offline, OvermapRootState, Payload } from '../../typings';
+import { AssetType, Organization, OvermapRootState, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetType>): OptimisticModelResult<AssetType>;
-    update(payload: Offline<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;
-    delete(assetTypeId: string): Promise<undefined>;
-    refreshStore(organizationId: number): Promise<void>;
+    update(payload: UUID<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;
+    delete(uuid: AssetType["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,37 +1,37 @@
 import { ActionCreatorWithPayload } from '@reduxjs/toolkit';
-import { Attachment, FileModelPayload, OfflineModel, OvermapRootState, OvermapSelectorWithArgs, Stored, Submitted } from '../../typings';
+import { Attachment, FileModelPayload, OvermapRootState, OvermapSelectorWithArgs, Stored, Submitted, User, UUIDModel } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseUploadService } from './BaseUploadService';
 export interface AttachmentPayload extends FileModelPayload {
-    offline_id: OfflineModel["offline_id"];
+    uuid: UUIDModel["uuid"];
     description: Attachment["description"];
 }
-export interface BuildOfflineAttachmentData<TModelId> {
+export interface BuildOfflineAttachmentData {
     file: File;
     file_sha1: string;
     submitted_at: string;
-    created_by?: number;
+    created_by?: User["id"];
     description?: string;
-    modelId: TModelId;
+    modelUuid: UUIDModel["uuid"];
 }
-export interface BuildAttachmentPayloadData<TModelId> extends AttachmentPayload {
-    modelId: TModelId;
+export interface BuildAttachmentPayloadData extends AttachmentPayload {
+    modelUuid: UUIDModel["uuid"];
 }
-export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string | number, TAttachment extends Attachment> extends BaseUploadService<TState, TSDK> {
+export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TAttachment extends Attachment> extends BaseUploadService<TState, TSDK> {
     abstract readonly name: string;
     abstract readonly url: string;
-    abstract readonly addAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
-    abstract readonly updateAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly addAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
+    abstract readonly updateAttachments: ActionCreatorWithPayload<Stored<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 abstract buildOfflineAttachment(data: BuildOfflineAttachmentData<TModelId>): Stored<TAttachment>;
-    protected abstract buildAttachmentPayload(data: BuildAttachmentPayloadData<TModelId>): AttachmentPayload;
+    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData): Submitted<TAttachment>;
+    protected abstract buildAttachmentPayload(data: BuildAttachmentPayloadData): AttachmentPayload;
     _bulkAdd(payloads: {
-        modelId: TModelId;
+        modelUuid: UUIDModel["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<TAttachment>>;
-    _delete(attachmendId: string): Promise<void>;
+    _delete(uuid: UUIDModel["uuid"]): Promise<void>;
 }

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

@@ -1,10 +1,10 @@
-import { Category, Offline, OvermapRootState, Payload } from '../../typings';
+import { Category, OvermapRootState, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class CategoryService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Category>): OptimisticModelResult<Category>;
-    update(payload: Offline<Partial<Payload<Category>>>): OptimisticModelResult<Category>;
-    remove(id: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<undefined>;
+    update(payload: UUID<Partial<Payload<Category>>>): OptimisticModelResult<Category>;
+    remove(uuid: Category["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<undefined>;
 }

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

@@ -1,8 +1,8 @@
-import { DocumentAttachment, OvermapRootState, Stored } from '../../typings';
+import { Document, DocumentAttachment, Organization, OvermapRootState, Project, Stored } 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, string, DocumentAttachment> {
+export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, DocumentAttachment> {
     name: string;
     url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">;
@@ -11,7 +11,7 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
     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<string>): import('../..').Offline<{
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
         created_by: number | undefined;
@@ -21,20 +21,20 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
         description: string | undefined;
         document: string;
     }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
         document: string;
-        modelId: string;
-        offline_id: import('../..').OfflineModel["offline_id"];
+        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_extension: string;
     };
     bulkAdd(payloads: {
-        documentId: string;
+        documentUuid: Document["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
-    delete(id: string): Promise<void>;
+    delete(uuid: DocumentAttachment["uuid"]): Promise<void>;
     private makeReadable;
-    refreshStore(projectId: number, organizationId: number): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,11 +1,11 @@
-import { Document, MovePosition, Offline, OvermapRootState, Payload } from '../../typings';
+import { Document, MovePosition, Organization, OvermapRootState, Payload, Project, 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> {
     add(payload: Payload<Document>): OptimisticModelResult<Document>;
-    update(payload: Offline<Partial<Payload<Document>>>): OptimisticModelResult<Document>;
-    move(documentId: string, targetDocumentId: string | null, position: MovePosition): Promise<Document[]>;
-    delete(id: string): Promise<Document[]>;
-    refreshStore(projectId: number, organizationId: number): Promise<void>;
+    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>;
 }

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

@@ -1,8 +1,8 @@
-import { EmailDomain, OvermapRootState } from '../../typings';
+import { EmailDomain, Organization, OvermapRootState } 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> {
-    add(orgId: number, email: string): Promise<undefined>;
+    add(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
     remove(emailDomain: EmailDomain): Promise<undefined>;
-    refreshStore(organizationId: number): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
 }

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

@@ -1,12 +1,12 @@
-import { FormRevisionAttachment, OvermapRootState } from '../../typings';
+import { FormRevision, FormRevisionAttachment, Organization, OvermapRootState } 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> {
     bulkAdd(payloads: {
-        revisionId: string;
+        revisionUuid: FormRevision["uuid"];
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<FormRevisionAttachment>>;
-    refreshStore(organizationId: number): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,8 +1,8 @@
-import { FormRevision, FormRevisionPayload, OvermapRootState } from '../../typings';
+import { FormRevision, FormRevisionPayload, Organization, OvermapRootState } 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> {
     add(payload: FormRevisionPayload): OptimisticModelResult<FormRevision>;
-    refreshStore(organizationId: number): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,17 +1,8 @@
-import { ISerializedField } from '@overmap-ai/forms';
-import { Created, Form, FormRevision, OvermapRootState, Payload, Stored } from '../../typings';
+import { Created, Form, FormRevision, Organization, OvermapRootState, Payload, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseUploadService } from './BaseUploadService';
-/**
- * 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> {
     add(payload: Payload<Form>, initialRevision: Pick<FormRevision, "title" | "description" | "fields">): [Stored<Form>, Stored<FormRevision>, Promise<Created<FormRevision>>];
-    delete(id: string): Promise<undefined>;
-    refreshStore(organizationId: number): Promise<void>;
+    delete(uuid: Form["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }