@overmap-ai/core 1.0.79-gcs.2 → 1.0.79

package/dist/sdk/constants.d.ts

@@ -1,5 +1,4 @@
-/** Default pagination page size  */
 export declare const DEFAULT_PAGE_SIZE = 10000;
-/** Attachment model pagination page size */
-export declare const ATTACHMENT_MODEL_DEFAULT_PAGE_SIZE = 200;
+export declare const FILE_MODEL_DEFAULT_PAGE_SIZE = 200;
 export declare const DISCARD_HTTP_STATUSES: number[];
+export declare const MAX_SERVICE_BATCH_SIZE = 10000;

package/dist/sdk/index.d.ts

@@ -8,3 +8,4 @@ export * from './typings';
 export * from './globals';
 export * from './middleware';
 export * from './performRequest';
+export * from './utils';

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

@@ -7,5 +7,6 @@ export declare abstract class AgentService<TState extends OvermapRootState, TSDK
     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>;
+    private list;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AgentUserConversation[]>;
 }

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

@@ -1,31 +1,30 @@
-import { Asset, AssetAttachment, FilePayload, Project, Stored, Submitted } from '../../typings';
+import { AssetAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
-export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetAttachment["uuid"], AssetAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetAttachment["uuid"], AssetAttachment, TState, TSDK> {
     name: string;
     url: string;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
-    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 getId(model: Stored<AssetAttachment>): AssetAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<AssetAttachment>;
-    protected buildPayload(model: Submitted<AssetAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        asset: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/addAssetAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/setAssetAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/updateAssetAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetAttachment>[];
     };
-    bulkAdd(payloads: {
-        assetUuid: Asset["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
-    delete(uuid: AssetAttachment["uuid"]): Promise<void>;
+    protected getId(model: Stored<AssetAttachment>): AssetAttachment["uuid"];
+    protected getBlockers(model: Stored<AssetAttachment>): string[];
+    protected getBlocks(model: Stored<AssetAttachment>): string[];
+    protected buildModel(data: Payload<AssetAttachment>): Submitted<AssetAttachment>;
+    protected buildPayload(model: Submitted<AssetAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetAttachment>): object;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetAttachment[]>;
 }

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

@@ -0,0 +1,28 @@
+import { AssetComment, Payload, Project, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetComment["uuid"], AssetComment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>, "assetComments/addAssetComment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>[], "assetComments/addAssetComments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>, "assetComments/setAssetComment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>[], "assetComments/setAssetComments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>, "assetComments/updateAssetComment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>[], "assetComments/updateAssetComments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetComments/deleteAssetComment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetComments/deleteAssetComments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetComment>[], "assetComments/initializeAssetComments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetComment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetComment>[];
+    };
+    add(payload: Payload<AssetComment>): OptimisticModelResult<AssetComment>;
+    update(payload: UUID<Partial<Payload<AssetComment>>>): OptimisticModelResult<AssetComment>;
+    delete(uuid: AssetComment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetComment[]>;
+}

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

@@ -1,13 +1,31 @@
-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 { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+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/AssetTypeAttachmentService.d.ts

@@ -1,31 +1,30 @@
-import { AssetType, AssetTypeAttachment, FilePayload, Organization, Stored, Submitted } from '../../typings';
+import { AssetTypeAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
-export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment["uuid"], AssetTypeAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeAttachment["uuid"], AssetTypeAttachment, TState, TSDK> {
     name: string;
     url: string;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">;
-    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 getId(model: Stored<AssetTypeAttachment>): AssetTypeAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<AssetTypeAttachment>;
-    protected buildPayload(model: Submitted<AssetTypeAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        asset_type: string;
+    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 { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { AssetTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } 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: {
-        fieldValuesUuid: AssetTypeFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
+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 { 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 { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+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 { AssetTypeFields, AssetTypeFieldsAttachment, Organization } from '../../typings';
+import { AssetTypeFieldsAttachment, Organization, Payload, Stored, Submitted } 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: {
-        fieldsRevisionUuid: AssetTypeFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetTypeFieldsAttachment>>;
+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

@@ -2,8 +2,25 @@ 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> {
+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

@@ -1,9 +1,26 @@
-import { AssetTypeIdentifier, Organization, Payload, UUID } from '../../typings';
+import { AssetTypeIdentifier, Organization, Payload, Stored, 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> {
+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>;

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

@@ -1,11 +1,28 @@
-import { AssetTypeIdentifierValue, Payload, Project, UUID } from '../../typings';
+import { AssetTypeIdentifierValue, Payload, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult } from '../typings';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+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>;
-    update(payload: UUID<Partial<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 { AssetType, Organization, Payload, UUID } from '../../typings';
+import { AssetType, Organization, Payload, Stored, 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> {
+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[][]>;
+}

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

@@ -1,6 +1,6 @@
 import { ResultAction } from '@redux-offline/redux-offline/lib/types';
 import { ActionCreatorWithPayload, UnknownAction } from '@reduxjs/toolkit';
-import { BaseState } from '../../store';
+import { BaseState, Selector } from '../../store';
 import { BaseSDK } from '../base';
 import { OfflineSDKRequest, PaginatedSDKRequest, SDKRequest } from '../typings';
 export declare const CLASS_NAME_TO_SERVICE: Record<string, BaseService<BaseState, BaseSDK<BaseState>>>;
@@ -16,4 +16,5 @@ export declare abstract class BaseService<TStore extends BaseState, TSDK extends
     protected enqueueRequest<TResult>(requestDetails: OfflineSDKRequest): Promise<TResult>;
     protected performPagination<TResult>(requestDetails: PaginatedSDKRequest, signal?: AbortSignal): Promise<TResult[]>;
     protected dispatch(action: UnknownAction | ResultAction | ActionCreatorWithPayload<any, any>): void;
+    protected select<TRet>(selector: Selector<TStore, TRet>): TRet;
 }