@overmap-ai/core 1.0.78-procedure-steps.6 → 1.0.78-required-model-names.0

package/dist/sdk/base.d.ts

@@ -1,12 +1,12 @@
 import { ResultAction } from '@redux-offline/redux-offline/lib/types';
 import { ActionCreatorWithPayload, Store, UnknownAction } from '@reduxjs/toolkit';
+import { SDKRequest } from './typings';
 import { BaseState } from '../store';
 import { FileService } from './services';
-import { SDKRequest } from './typings';
 export declare abstract class BaseSDK<TState extends BaseState> {
     readonly store: Store<TState, UnknownAction | ResultAction | ActionCreatorWithPayload<any, any>>;
     abstract readonly files: FileService<TState, BaseSDK<TState>>;
     protected constructor(store: Store<TState>);
-    enqueueRequest<TResult>(requestDetails: SDKRequest, host: string, serviceName: string): Promise<TResult>;
+    enqueueRequest<TResult>(requestDetails: SDKRequest, host: string, serviceName: string, signal?: AbortSignal): Promise<TResult>;
     private _enqueueRequest;
 }

package/dist/sdk/constants.d.ts

@@ -0,0 +1,4 @@
+/** Default pagination page size  */
+export declare const DEFAULT_PAGINATION_PAGE_SIZE = 1000;
+/** Attachment model pagination page size */
+export declare const ATTACHMENT_PAGINATION_PAGE_SIZE = 200;

package/dist/sdk/index.d.ts

@@ -1,6 +1,9 @@
 export * from './base';
-export * from './classes';
+export * from './outbox';
+export * from './constants';
 export * from './errors';
 export * from './sdk';
 export * from './services';
 export * from './typings';
+export * from './globals';
+export * from './middleware';

package/dist/sdk/middleware/OfflineAnalyticsMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { default as request } from 'superagent';
+import { FullOfflineAction } from '../../store';
+import { OfflineMiddleware } from './OfflineMiddleware';
+export declare class OfflineAnalyticsMiddleware extends OfflineMiddleware {
+    run(action: FullOfflineAction): Promise<request.Response | null>;
+}

package/dist/sdk/middleware/OfflineMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { default as request } from 'superagent';
+import { FullOfflineAction } from '../../store';
+interface MiddlewareChainer {
+    then: (next: OfflineMiddleware) => MiddlewareChainer;
+    compile: () => OfflineMiddleware[];
+}
+export declare abstract class OfflineMiddleware {
+    next: OfflineMiddleware | null;
+    constructor();
+    then(next: OfflineMiddleware): MiddlewareChainer;
+    run(action: FullOfflineAction): Promise<request.Response | null>;
+}
+export {};

package/dist/sdk/middleware/RateLimitingMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { default as request } from 'superagent';
+import { FullOfflineAction } from '../../store';
+import { OfflineMiddleware } from './OfflineMiddleware';
+export declare class RateLimitingMiddleware extends OfflineMiddleware {
+    run(action: FullOfflineAction): Promise<request.Response | null>;
+}

package/dist/sdk/middleware/constants.d.ts

@@ -0,0 +1 @@
+export declare const ALL_MIDDLEWARE: import('./OfflineMiddleware').OfflineMiddleware[];

package/dist/sdk/middleware/index.d.ts

@@ -0,0 +1,5 @@
+export * from './OfflineMiddleware';
+export * from './OfflineAnalyticsMiddleware';
+export * from './RateLimitingMiddleware';
+export * from './utils';
+export * from './constants';

package/dist/sdk/middleware/utils.d.ts

@@ -0,0 +1,2 @@
+import { FullOfflineAction } from '../../store';
+export declare function runMiddleware(action: FullOfflineAction): Promise<import('superagent').Response | null> | undefined;

package/dist/sdk/outbox/globals.d.ts

@@ -0,0 +1,2 @@
+import { OutboxCoordinator } from './OutboxCoordinator';
+export declare function getOutboxCoordinator(): OutboxCoordinator | null;

package/dist/sdk/{classes → outbox}/index.d.ts

@@ -1 +1,2 @@
 export * from './OutboxCoordinator';
+export * from './globals';

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { AgentUserConversation, Project } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AgentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     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>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AgentUserConversation[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { Asset, AssetAttachment, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetAttachment> {
     name: string;
@@ -37,5 +37,5 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
     delete(uuid: AssetAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetAttachment[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedure, AssetProcedureAttachment, Organization, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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;
@@ -36,5 +36,5 @@ export declare abstract class AssetProcedureAttachmentService<TState extends Ove
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetProcedureAttachment>>;
     delete(uuid: AssetProcedureAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureAttachment[]>;
 }

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

@@ -1,6 +1,6 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureFieldValues, AssetProcedureFieldValuesAttachment, Created, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetProcedureFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -12,5 +12,5 @@ export declare abstract class AssetProcedureFieldValuesAttachmentService<TState
         Promise<Created<AssetProcedureFieldValuesAttachment>[]>[]
     ]>;
     bulkDelete(uuids: AssetProcedureFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureFieldValuesAttachment[]>;
 }

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

@@ -1,8 +1,8 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
 import { Asset, AssetProcedureFields, AssetProcedureFieldValues, AssetProcedureInstance, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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>;
@@ -18,5 +18,5 @@ export declare abstract class AssetProcedureFieldValuesService<TState extends Ov
     }, 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>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureFieldValues[]>;
 }

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

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

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureFields, Organization, Payload } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureFields[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureInstance, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureInstance[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedure, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedure[]>;
 }

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

@@ -1,6 +1,6 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStepFieldValues, AssetProcedureStepFieldValuesAttachment, Created, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -12,5 +12,5 @@ export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TSt
         Promise<Created<AssetProcedureStepFieldValuesAttachment>[]>[]
     ]>;
     bulkDelete(uuids: AssetProcedureStepFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldValuesAttachment[]>;
 }

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

@@ -1,8 +1,8 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
 import { Asset, AssetProcedureInstance, AssetProcedureStep, AssetProcedureStepFields, AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetProcedureStepFieldValues>): OptimisticModelResult<AssetProcedureStepFieldValues>;
@@ -19,5 +19,5 @@ export declare abstract class AssetProcedureStepFieldValuesService<TState extend
     }, batchSize?: number): [Stored<AssetProcedureStepFieldValues>[], Promise<Created<AssetProcedureStepFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetProcedureStepFieldValues>>>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     delete(uuid: AssetProcedureStepFieldValues["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldValues[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStepFields, AssetProcedureStepFieldsAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -9,5 +9,5 @@ export declare abstract class AssetProcedureStepFieldsAttachmentService<TState e
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetProcedureStepFieldsAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldsAttachment[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStepFields, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetProcedureStepFields>): OptimisticModelResult<AssetProcedureStepFields>;
     update(payload: UUID<Partial<Payload<AssetProcedureStepFields>>>): OptimisticModelResult<AssetProcedureStepFields>;
     delete(uuid: AssetProcedureStepFields["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFields[]>;
 }

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

@@ -1,12 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { AssetProcedure, AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    bulkAdd(stepsToSubmit: Omit<Payload<AssetProcedureStep>, "asset_procedure">[], assetProcedureUuid: string): OptimisticMultipleModelResult<AssetProcedureStep>;
-    bulkUpdate(stepsToUpdate: AssetProcedureStep[], assetProcedureUuid: AssetProcedure["uuid"]): Promise<AssetProcedureStep[]>;
-    bulkDelete(uuids: AssetProcedureStep["uuid"][]): Promise<undefined>;
+    add(payload: Payload<AssetProcedureStep>): OptimisticModelResult<AssetProcedureStep>;
     update(payload: UUID<Partial<Payload<AssetProcedureStep>>>): OptimisticModelResult<AssetProcedureStep>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+    delete(uuid: AssetProcedureStep["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStep[]>;
 }

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

@@ -1,12 +1,13 @@
-import { OvermapRootState } from '../../store';
 import { Asset, AssetType, Created, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
-    remove(uuid: Asset["uuid"]): Promise<undefined>;
+    delete(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>;
+    bulkDelete(uuids: Asset["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Asset[]>;
 }

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

@@ -1,12 +1,12 @@
-import { OvermapRootState } from '../../store';
 import { AssetStageCompletion, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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(uuid: AssetStageCompletion["uuid"]): Promise<undefined>;
     bulkAdd(payloads: Payload<AssetStageCompletion>[]): OptimisticMultipleModelResult<AssetStageCompletion>;
     bulkDelete(uuids: AssetStageCompletion["uuid"][]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetStageCompletion[]>;
 }

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

@@ -1,12 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { AssetProcedure, AssetStage, Organization, Payload, UUID } from '../../typings';
+import { AssetStage, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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">[], assetProcedureUuid: string): OptimisticMultipleModelResult<AssetStage>;
-    bulkUpdate(stagesToUpdate: AssetStage[], assetProcedureUuid: AssetProcedure["uuid"]): Promise<AssetStage[]>;
-    bulkDelete(uuids: AssetStage["uuid"][]): Promise<undefined>;
+    add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;
     update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+    delete(uuid: AssetStage["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetStage[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetType, AssetTypeAttachment, Organization, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment> {
     name: string;
@@ -36,5 +36,5 @@ export declare abstract class AssetTypeAttachmentService<TState extends OvermapR
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
     delete(uuid: AssetTypeAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeAttachment[]>;
 }

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

@@ -1,6 +1,6 @@
-import { OvermapRootState } from '../../store';
 import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -9,5 +9,5 @@ export declare abstract class AssetTypeFieldValuesAttachmentService<TState exten
         file: File;
     }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
     bulkDelete(uuids: AssetTypeFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeFieldValuesAttachment[]>;
 }

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

@@ -1,8 +1,8 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
 import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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>;
@@ -17,5 +17,5 @@ export declare abstract class AssetTypeFieldValuesService<TState extends Overmap
     }, batchSize?: number): [Stored<AssetTypeFieldValues>[], Promise<Created<AssetTypeFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetTypeFieldValues>>>): OptimisticModelResult<AssetTypeFieldValues>;
     delete(uuid: AssetTypeFieldValues["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeFieldValues[]>;
 }

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { AssetTypeIdentifier, Organization, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetTypeIdentifier>): OptimisticModelResult<AssetTypeIdentifier>;
+    update(payload: UUID<Partial<Payload<AssetTypeIdentifier>>>): OptimisticModelResult<AssetTypeIdentifier>;
+    delete(uuid: AssetTypeIdentifier["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeIdentifier[]>;
+}

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

@@ -0,0 +1,11 @@
+import { AssetTypeIdentifierValue, Payload, Project, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetTypeIdentifierValue>): OptimisticModelResult<AssetTypeIdentifierValue>;
+    update(payload: UUID<Partial<Payload<AssetTypeIdentifierValue>>>): OptimisticModelResult<AssetTypeIdentifierValue>;
+    delete(uuid: AssetTypeIdentifierValue["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeIdentifierValue[]>;
+}

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { AssetType, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;
     delete(uuid: AssetType["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetType[]>;
 }

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

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

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { Category, Payload, Project, UUID } from '../../typings';
+import { Category, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<Category>>>): OptimisticModelResult<Category>;
     remove(uuid: Category["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Category[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
-import { Document, DocumentAttachment, Organization, Project, Stored } from '../../typings';
+import { Document, DocumentAttachment, Organization, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, DocumentAttachment> {
     name: string;
@@ -37,5 +37,5 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
     }[]): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
     delete(uuid: DocumentAttachment["uuid"]): Promise<void>;
     private makeReadable;
-    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<DocumentAttachment[]>;
 }

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

@@ -1,12 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { Document, MovePosition, Organization, Payload, Project, UUID } from '../../typings';
+import { Document, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: 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>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Document[]>;
 }

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { EmailDomain, Organization } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class EmailDomainsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
     remove(emailDomain: EmailDomain): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<EmailDomain[]>;
 }

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

@@ -1,5 +1,5 @@
-import { BaseState } from '../../store';
 import { BaseSDK } from '../base';
+import { BaseState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export interface GetS3UrlSuccessResponse {
     url: string;

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

@@ -0,0 +1,11 @@
+import { FormIdentifier, Organization, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class FormIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<FormIdentifier>): OptimisticModelResult<FormIdentifier>;
+    update(payload: UUID<Partial<Payload<FormIdentifier>>>): OptimisticModelResult<FormIdentifier>;
+    delete(uuid: FormIdentifier["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormIdentifier[]>;
+}