@overmap-ai/core 1.0.74-asset-geojson.0 → 1.0.74-gcs.0

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,29 +12,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>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: number | undefined;
+        created_by: string | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;
         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/AssetProcedureFieldValuesAttachmentService.d.ts

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

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

@@ -1,5 +1,5 @@
 import { FieldValue } from '@overmap-ai/forms';
-import { AssetProcedureFieldValues, Created, Offline, OvermapRootState, Payload, Stored } from '../../typings';
+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';
@@ -9,13 +9,13 @@ export declare abstract class AssetProcedureFieldValuesService<TState extends Ov
         values: Record<string, FieldValue>;
         payloads: {
             values: Record<string, FieldValue>;
-            asset: string;
-            fields_revision: string;
-            asset_procedure_instance: string;
+            asset: Asset["uuid"];
+            fields_revision: AssetProcedureFields["uuid"];
+            asset_procedure_instance: AssetProcedureInstance["uuid"];
             published_at: string;
         }[];
     }, batchSize?: number): [Stored<AssetProcedureFieldValues>[], Promise<Created<AssetProcedureFieldValues>[]>[]];
-    update(payload: Offline<Partial<Payload<AssetProcedureFieldValues>>>): OptimisticModelResult<AssetProcedureFieldValues>;
-    delete(id: string): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    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

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

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

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

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

@@ -1,10 +1,10 @@
-import { AssetProcedureInstance, Offline, OvermapRootState, Payload } from '../../typings';
+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: Offline<Partial<Payload<AssetProcedureInstance>>>): OptimisticModelResult<AssetProcedureInstance>;
-    remove(assetProcedureInstanceId: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    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

@@ -1,10 +1,10 @@
-import { AssetProcedure, Offline, OvermapRootState, Payload } from '../../typings';
+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: Offline<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;
-    remove(id: string): Promise<undefined>;
-    refreshStore(organizationId: number): Promise<void>;
+    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_procedure">[], assetProcedureId: string): OptimisticMultipleModelResult<AssetStage>;
-    bulkUpdate(stagesToUpdate: AssetStage[], assetProcedureId: 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,29 +11,29 @@ 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;
+        created_by: string | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;
         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,5 +1,5 @@
 import { FieldValue } from '@overmap-ai/forms';
-import { AssetTypeFieldValues, Created, Offline, OvermapRootState, Payload, Stored } from '../../typings';
+import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, OvermapRootState, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
@@ -9,12 +9,12 @@ export declare abstract class AssetTypeFieldValuesService<TState extends Overmap
         values: Record<string, FieldValue>;
         payloads: {
             values: Record<string, FieldValue>;
-            asset: string;
-            fields_revision: string;
+            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,24 +1,24 @@
 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["uuid"];
     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<Stored<TAttachment>[]>;
@@ -27,11 +27,11 @@ export declare abstract class BaseAttachmentService<TState extends OvermapRootSt
     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>): Submitted<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,30 +11,30 @@ 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;
+        created_by: string | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;
         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/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,5 +1,5 @@
 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';
 /**
@@ -12,6 +12,6 @@ export declare const separateImageFromFields: (fields: ISerializedField[]) => Pr
 }>;
 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>;
 }

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

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

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

@@ -1,5 +1,5 @@
 import { FieldValue } from '@overmap-ai/forms';
-import { FormSubmission, Offline, OvermapRootState, Payload } from '../../typings';
+import { FormSubmission, OvermapRootState, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseUploadService } from './BaseUploadService';
@@ -9,7 +9,7 @@ export declare const separateFilesFromValues: (values: Record<string, FieldValue
 };
 export declare abstract class FormSubmissionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     add(payload: Payload<FormSubmission>): OptimisticModelResult<FormSubmission>;
-    update(payload: Offline<Partial<Payload<FormSubmission>>>): OptimisticModelResult<FormSubmission>;
-    delete(id: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    update(payload: UUID<Partial<Payload<FormSubmission>>>): OptimisticModelResult<FormSubmission>;
+    delete(uuid: FormSubmission["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }