@overmap-ai/core 1.0.78-view-sets-cleanup.3 → 1.0.78-workflows-2.1

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

@@ -0,0 +1,26 @@
+import { AssetProcedureTypeFields, Organization, Payload, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFields["uuid"], AssetProcedureTypeFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>, "assetProcedureTypeFields/addAssetProcedureTypeFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/addAssetProcedureTypeFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>, "assetProcedureTypeFields/setAssetProcedureTypeFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/setAssetProcedureTypeFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>, "assetProcedureTypeFields/updateAssetProcedureTypeFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/updateAssetProcedureTypeFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFields/deleteAssetProcedureTypeFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFields/deleteAssetProcedureTypeFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/initializeAssetProcedureTypeFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFields>[];
+    };
+    add(payload: Payload<AssetProcedureTypeFields>): OptimisticModelResult<AssetProcedureTypeFields>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFields[]>;
+}

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

@@ -0,0 +1,28 @@
+import { AssetProcedureType, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureType["uuid"], AssetProcedureType, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>, "assetProcedureTypes/addAssetProcedureType">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/addAssetProcedureTypes">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>, "assetProcedureTypes/setAssetProcedureType">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/setAssetProcedureTypes">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>, "assetProcedureTypes/updateAssetProcedureType">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/updateAssetProcedureTypes">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypes/deleteAssetProcedureType">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypes/deleteAssetProcedureTypes">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/initializeAssetProcedureTypes">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureType> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureType>[];
+    };
+    add(payload: Payload<AssetProcedureType>): OptimisticModelResult<AssetProcedureType>;
+    update(payload: UUID<Partial<Payload<AssetProcedureType>>>): OptimisticModelResult<AssetProcedureType>;
+    delete(uuid: AssetProcedureType["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureType[]>;
+}

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

@@ -1,13 +1,31 @@
-import { OvermapRootState } from '../../store';
-import { Asset, AssetType, Created, Payload, Project, UUID } from '../../typings';
+import { Asset, Created, Payload, Project, Stored, 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> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Asset["uuid"], Asset, TState, TSDK> {
+    url: string;
+    name: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assets/deleteAsset">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assets/deleteAssets">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Asset> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Asset>[];
+    };
     add(payload: Payload<Asset>): OptimisticModelResult<Asset>;
     update(payload: UUID<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
     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>[]>[];
+    bulkAdd(payloads: Payload<Asset>[], batchSize?: number): Promise<Created<Asset>[]>[];
+    bulkUpdate(payloads: UUID<Partial<Payload<Asset>>>[], batchSize?: number): [Stored<Asset>[], Promise<Created<Asset>[]>[]];
     bulkDelete(uuids: Asset["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Asset[]>;
 }

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { AssetStageCompletion, Payload, Project } from '../../typings';
+import { AssetStageCompletion, Payload, Project, Stored } 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> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetStageCompletionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetStageCompletion["uuid"], AssetStageCompletion, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/addAssetStageCompletion">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/addAssetStageCompletions">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/setAssetStageCompletion">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/setAssetStageCompletions">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/updateAssetStageCompletion">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/updateAssetStageCompletions">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStageCompletions/deleteAssetStageCompletion">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStageCompletions/deleteAssetStageCompletions">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/initializeAssetStageCompletions">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetStageCompletion>[];
+    };
     add(payload: Payload<AssetStageCompletion>): OptimisticModelResult<AssetStageCompletion>;
     delete(uuid: AssetStageCompletion["uuid"]): Promise<undefined>;
     bulkAdd(payloads: Payload<AssetStageCompletion>[]): OptimisticMultipleModelResult<AssetStageCompletion>;

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { AssetStage, Organization, Payload, UUID } from '../../typings';
+import { AssetStage, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetStage["uuid"], AssetStage, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/addAssetStage">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addAssetStages">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setAssetStage">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/setAssetStages">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateAssetStage">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateAssetStages">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStages/deleteAssetStage">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStages/deleteAssetStages">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeAssetStages">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetStage> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetStage>[];
+    };
     add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;
     update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
     delete(uuid: AssetStage["uuid"]): Promise<void>;

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

@@ -1,40 +1,30 @@
-import { OvermapRootState } from '../../store';
-import { AssetType, AssetTypeAttachment, Organization, Stored } from '../../typings';
+import { AssetTypeAttachment, Organization, Payload, Stored, Submitted } 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, AssetTypeAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeAttachment["uuid"], AssetTypeAttachment, TState, TSDK> {
     name: string;
     url: string;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
-    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_type: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        asset_type: 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;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/addAssetTypeAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/setAssetTypeAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/updateAssetTypeAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeAttachment>[];
     };
-    bulkAdd(payloads: {
-        assetTypeUuid: AssetType["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
-    delete(uuid: AssetTypeAttachment["uuid"]): Promise<void>;
+    protected getId(model: Stored<AssetTypeAttachment>): AssetTypeAttachment["uuid"];
+    protected getBlockers(model: Stored<AssetTypeAttachment>): string[];
+    protected getBlocks(model: Stored<AssetTypeAttachment>): string[];
+    protected buildModel(payload: Payload<AssetTypeAttachment>): Submitted<AssetTypeAttachment>;
+    protected buildPayload(model: Submitted<AssetTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetTypeAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeAttachment[]>;
 }

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

@@ -1,13 +1,31 @@
-import { OvermapRootState } from '../../store';
-import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { AssetTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } 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: {
-        fieldValuesUuid: AssetTypeFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeFieldValuesAttachment["uuid"], AssetTypeFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/initializeAssetTypeFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<AssetTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<AssetTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<AssetTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetTypeFieldValuesAttachment>): Submitted<AssetTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetTypeFieldValuesAttachment>): object;
     bulkDelete(uuids: AssetTypeFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeFieldValuesAttachment[]>;
 }

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

@@ -1,19 +1,31 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
-import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
+import { AssetTypeFieldValues, Created, 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> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeFieldValues["uuid"], AssetTypeFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/addAssetTypeFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/addAssetTypeFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/setAssetTypeFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/setAssetTypeFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/updateAssetTypeFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/updateAssetTypeFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValues/deleteAssetTypeFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValues/deleteAssetTypeFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/initializeAssetTypeFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldValues>[];
+    };
     add(payload: Payload<AssetTypeFieldValues>): OptimisticModelResult<AssetTypeFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;
-        payloads: {
-            values: SerializedFieldValues;
-            asset: Asset["uuid"];
-            fields_revision: AssetTypeFields["uuid"];
-            published_at: string;
-        }[];
+        payloads: Payload<AssetTypeFieldValues>[];
     }, batchSize?: number): [Stored<AssetTypeFieldValues>[], Promise<Created<AssetTypeFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetTypeFieldValues>>>): OptimisticModelResult<AssetTypeFieldValues>;
     delete(uuid: AssetTypeFieldValues["uuid"]): Promise<void>;

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

@@ -1,13 +1,30 @@
-import { OvermapRootState } from '../../store';
-import { AssetTypeFields, AssetTypeFieldsAttachment, Organization } from '../../typings';
+import { AssetTypeFieldsAttachment, Organization, Payload, Stored, Submitted } 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: {
-        fieldsRevisionUuid: AssetTypeFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetTypeFieldsAttachment>>;
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeFieldsAttachment["uuid"], AssetTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/addAssetTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/addAssetTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/setAssetTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/setAssetTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/initializeAssetTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldsAttachment>[];
+    };
+    protected getId(model: Stored<AssetTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetTypeFieldsAttachment>): Submitted<AssetTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetTypeFieldsAttachment>): object;
     refreshStore(organization: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeFieldsAttachment[]>;
 }

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { AssetTypeFields, Organization, 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> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeFields["uuid"], AssetTypeFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>, "assetTypeFields/addAssetTypeFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>[], "assetTypeFields/addAssetTypeFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>, "assetTypeFields/setAssetTypeFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>[], "assetTypeFields/setAssetTypeFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>, "assetTypeFields/updateAssetTypeFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>[], "assetTypeFields/updateAssetTypeFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFields/deleteAssetTypeFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFields/deleteAssetTypeFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetTypeFields>[], "assetTypeFields/initializeAssetTypeFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetTypeFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<AssetTypeFields>[];
+    };
     add(payload: Payload<AssetTypeFields>): OptimisticModelResult<AssetTypeFields>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeFields[]>;
 }

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

@@ -0,0 +1,28 @@
+import { AssetTypeIdentifier, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeIdentifier["uuid"], AssetTypeIdentifier, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>, "assetTypeIdentifiers/addAssetTypeIdentifier">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/addAssetTypeIdentifiers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>, "assetTypeIdentifiers/setAssetTypeIdentifier">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/setAssetTypeIdentifiers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>, "assetTypeIdentifiers/updateAssetTypeIdentifier">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/updateAssetTypeIdentifiers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeIdentifiers/deleteAssetTypeIdentifier">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeIdentifiers/deleteAssetTypeIdentifiers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/initializeAssetTypeIdentifiers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeIdentifier> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeIdentifier>[];
+    };
+    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,28 @@
+import { AssetTypeIdentifierValue, Payload, Project, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeIdentifierValue["uuid"], AssetTypeIdentifierValue, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>, "assetTypeIdentifierValues/addAssetTypeIdentifierValue">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>[], "assetTypeIdentifierValues/addAssetTypeIdentifierValues">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>, "assetTypeIdentifierValues/setAssetTypeIdentifierValue">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>[], "assetTypeIdentifierValues/setAssetTypeIdentifierValues">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>, "assetTypeIdentifierValues/updateAssetTypeIdentifierValue">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>[], "assetTypeIdentifierValues/updateAssetTypeIdentifierValues">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeIdentifierValues/deleteAssetTypeIdentifierValue">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeIdentifierValues/deleteAssetTypeIdentifierValues">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifierValue>[], "assetTypeIdentifierValues/initializeAssetTypeIdentifierValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeIdentifierValue> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeIdentifierValue>[];
+    };
+    add(payload: Payload<AssetTypeIdentifierValue>): OptimisticModelResult<AssetTypeIdentifierValue>;
+    bulkAdd(payloads: Payload<AssetTypeIdentifierValue>[], batchSize?: number): OptimisticMultipleModelResult<AssetTypeIdentifierValue>;
+    delete(uuid: AssetTypeIdentifierValue["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetTypeIdentifierValue[]>;
+}

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { AssetType, Organization, Payload, UUID } from '../../typings';
+import { AssetType, Organization, Payload, Stored, 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> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetType["uuid"], AssetType, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/addAssetTypes">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/setAssetType">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/setAssetTypes">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/updateAssetType">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/updateAssetTypes">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypes/deleteAssetTypes">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetType> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetType>[];
+    };
     add(payload: Payload<AssetType>): OptimisticModelResult<AssetType>;
     update(payload: UUID<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;
     delete(uuid: AssetType["uuid"]): Promise<undefined>;

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

@@ -0,0 +1,28 @@
+import { AssetTypeStatus, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeStatusService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeStatus["uuid"], AssetTypeStatus, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>, "assetTypeStatuses/addAssetTypeStatus">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>[], "assetTypeStatuses/addAssetTypeStatuses">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>, "assetTypeStatuses/setAssetTypeStatus">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>[], "assetTypeStatuses/setAssetTypeStatuses">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>, "assetTypeStatuses/updateAssetTypeStatus">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>[], "assetTypeStatuses/updateAssetTypeStatuses">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeStatuses/deleteAssetTypeStatus">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeStatuses/deleteAssetTypeStatuses">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeStatus>[], "assetTypeStatuses/initializeAssetTypeStatuses">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeStatus> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeStatus>[];
+    };
+    add(payload: Payload<AssetTypeStatus>): OptimisticModelResult<AssetTypeStatus>;
+    update(payload: UUID<Partial<Payload<AssetTypeStatus>>>): OptimisticModelResult<AssetTypeStatus>;
+    delete(uuid: AssetTypeStatus["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeStatus[]>;
+}

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

@@ -0,0 +1,27 @@
+import { AddManyPayloadActionCreator, AddOnePayloadActionCreator, BaseState, DeleteManyPayloadActionCreator, DeleteOnePayloadActionCreator, InitializePayloadActionCreator, SelectorWithArgs, SetManyPayloadActionCreator, SetOnePayloadActionCreator, UpdateManyPayloadActionCreator, UpdateOnePayloadActionCreator } from '../../store';
+import { Model } from '../../typings';
+import { BaseSDK } from '../base';
+import { ModelSDKRequest, PaginatedModelSDKRequest } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class BaseModelApiService<TPk extends string | number, TModel extends Model, TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    abstract url: string;
+    abstract name: string;
+    abstract actions: {
+        addOne: AddOnePayloadActionCreator<TModel>;
+        addMany: AddManyPayloadActionCreator<TModel>;
+        setOne: SetOnePayloadActionCreator<TModel>;
+        setMany: SetManyPayloadActionCreator<TModel>;
+        updateOne: UpdateOnePayloadActionCreator<TModel>;
+        updateMany: UpdateManyPayloadActionCreator<TModel>;
+        deleteOne: DeleteOnePayloadActionCreator<TPk>;
+        deleteMany: DeleteManyPayloadActionCreator<TPk>;
+        initialize: InitializePayloadActionCreator<TModel>;
+    };
+    abstract selectors: {
+        selectById: SelectorWithArgs<TState, TPk, TModel | undefined>;
+        selectByIds: SelectorWithArgs<TState, TPk[], TModel[]>;
+    };
+    get(pk: TPk, signal?: AbortSignal): Promise<TModel>;
+    list(requestDetails: Omit<ModelSDKRequest, "method">, signal?: AbortSignal): Promise<TModel[]>;
+    listPaginated(requestDetails: Omit<PaginatedModelSDKRequest, "method">, signal?: AbortSignal): Promise<TModel[][]>;
+}

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

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

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

@@ -0,0 +1,27 @@
+import { AddManyPayloadActionCreator, AddOnePayloadActionCreator, BaseState, DeleteManyPayloadActionCreator, DeleteOnePayloadActionCreator, InitializePayloadActionCreator, SelectorWithArgs, SetManyPayloadActionCreator, SetOnePayloadActionCreator, UpdateManyPayloadActionCreator, UpdateOnePayloadActionCreator } from '../../store';
+import { Model, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { ModelSDKRequest, PaginatedModelSDKRequest } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class BaseOfflineModelApiService<TPk extends string | number, TModel extends Model, TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    abstract url: string;
+    abstract name: string;
+    abstract actions: {
+        addOne: AddOnePayloadActionCreator<Stored<TModel>>;
+        addMany: AddManyPayloadActionCreator<Stored<TModel>>;
+        setOne: SetOnePayloadActionCreator<Stored<TModel>>;
+        setMany: SetManyPayloadActionCreator<Stored<TModel>>;
+        updateOne: UpdateOnePayloadActionCreator<Stored<TModel>>;
+        updateMany: UpdateManyPayloadActionCreator<Stored<TModel>>;
+        deleteOne: DeleteOnePayloadActionCreator<TPk>;
+        deleteMany: DeleteManyPayloadActionCreator<TPk>;
+        initialize: InitializePayloadActionCreator<Stored<TModel>>;
+    };
+    abstract selectors: {
+        selectById: SelectorWithArgs<TState, TPk, Stored<TModel> | undefined>;
+        selectByIds: SelectorWithArgs<TState, TPk[], Stored<TModel>[]>;
+    };
+    get(pk: TPk, signal?: AbortSignal): Promise<TModel>;
+    list(requestDetails: Omit<ModelSDKRequest, "method">, signal?: AbortSignal): Promise<TModel[]>;
+    listPaginated(requestDetails: Omit<PaginatedModelSDKRequest, "method">, signal?: AbortSignal): Promise<TModel[][]>;
+}