@overmap-ai/core 1.0.78-bump-page-sizes.1 → 1.0.78-debug.0

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

@@ -1,9 +1,26 @@
-import { AssetStageCompletion, Payload, Project } from '../../typings';
+import { AssetStageCompletion, Payload, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetStageCompletionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+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: (args: string[]) => (state: OvermapRootState) => 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 { AssetStage, Organization, Payload, UUID } from '../../typings';
+import { AssetStage, 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 AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+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: (args: string[]) => (state: OvermapRootState) => 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,35 +1,34 @@
-import { AssetType, AssetTypeAttachment, Organization, Stored } from '../../typings';
+import { AssetType, AssetTypeAttachment, FilePayload, Organization, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment> {
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, AssetTypeAttachment["uuid"], AssetTypeAttachment> {
     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;
+    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: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeAttachment>[];
+    };
+    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_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_sha1: string;
         file_extension: string;
+        asset_type: string;
     };
     bulkAdd(payloads: {
         assetTypeUuid: AssetType["uuid"];

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

@@ -1,8 +1,25 @@
 import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OvermapRootState } from '../../store';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<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: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldValuesUuid: AssetTypeFieldValues["uuid"];
         fieldIdentifier: string;

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

@@ -3,8 +3,25 @@ import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, Payload, Project
 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: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValues>[];
+    };
     add(payload: Payload<AssetTypeFieldValues>): OptimisticModelResult<AssetTypeFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;

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

@@ -1,9 +1,26 @@
-import { AssetTypeFields, AssetTypeFieldsAttachment, Organization } from '../../typings';
+import { AssetTypeFields, AssetTypeFieldsAttachment, Organization, Stored } 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<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: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldsAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldsRevisionUuid: AssetTypeFields["uuid"];
         fieldIdentifier: string;

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: (args: string[]) => (state: OvermapRootState) => 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: (args: string[]) => (state: OvermapRootState) => 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,9 +1,26 @@
-import { AssetTypeIdentifierValue, Payload, Project, UUID } from '../../typings';
+import { AssetTypeIdentifierValue, 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 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: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeIdentifierValue>[];
+    };
     add(payload: Payload<AssetTypeIdentifierValue>): OptimisticModelResult<AssetTypeIdentifierValue>;
     update(payload: UUID<Partial<Payload<AssetTypeIdentifierValue>>>): OptimisticModelResult<AssetTypeIdentifierValue>;
     delete(uuid: AssetTypeIdentifierValue["uuid"]): Promise<undefined>;

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: (args: string[]) => (state: OvermapRootState) => 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: (args: string[]) => (state: OvermapRootState) => 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/BaseOfflineAttachmentModelService.d.ts

@@ -0,0 +1,23 @@
+import { OvermapRootState } from '../../store';
+import { FileModelPayload, FilePayload, RequiredFileWithNameModel, Stored, Submitted, User, UUIDModel } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export interface BuildModelData {
+    file: File;
+    file_sha1: string;
+    submitted_at: string;
+    created_by: User["id"] | null;
+    modelUuid: UUIDModel["uuid"];
+}
+export declare abstract class BaseOfflineAttachmentModelService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string, TModel extends RequiredFileWithNameModel> extends BaseOfflineModelApiService<TModelId, TModel, TState, TSDK> {
+    protected pageSize: number;
+    protected abstract getId(model: Stored<TModel>): TModelId;
+    protected abstract buildModel(data: BuildModelData): Submitted<TModel>;
+    protected abstract buildPayload(model: Submitted<TModel>, filePayload: FilePayload): FileModelPayload;
+    _bulkAdd(payloads: {
+        modelUuid: UUIDModel["uuid"];
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<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

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

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

@@ -1,11 +1,28 @@
-import { Category, Organization, Payload, UUID } from '../../typings';
+import { Category, 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 CategoryService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class CategoryService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Category["uuid"], Category, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/addCategory">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>[], "categories/addCategories">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/setCategory">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>[], "categories/setCategories">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>, "categories/updateCategory">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>[], "categories/updateCategories">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "categories/deleteCategory">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "categories/deleteCategories">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Category>[], "categories/initializeCategories">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Category> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<Category>[];
+    };
     add(payload: Payload<Category>): OptimisticModelResult<Category>;
     update(payload: UUID<Partial<Payload<Category>>>): OptimisticModelResult<Category>;
-    remove(uuid: Category["uuid"]): Promise<undefined>;
+    delete(uuid: Category["uuid"]): Promise<undefined>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Category[]>;
 }

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

@@ -1,35 +1,34 @@
-import { Document, DocumentAttachment, Organization, Stored } from '../../typings';
+import { Document, DocumentAttachment, FilePayload, Organization, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, DocumentAttachment> {
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, DocumentAttachment["uuid"], DocumentAttachment> {
     name: string;
     url: string;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/addDocumentAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/setDocumentAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/updateDocumentAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
+    };
+    protected getId(model: Stored<DocumentAttachment>): DocumentAttachment["uuid"];
+    protected buildModel(data: BuildModelData): Submitted<DocumentAttachment>;
+    protected buildPayload(model: Submitted<DocumentAttachment>, filePayload: FilePayload): {
+        uuid: string;
         file_name: string;
-        file_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        document: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        document: 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_sha1: string;
         file_extension: string;
+        document: string;
     };
     bulkAdd(payloads: {
         documentUuid: Document["uuid"];