@overmap-ai/core 1.0.78-view-sets-cleanup.3 → 1.0.79-gcs.0

package/dist/sdk/base.d.ts

@@ -1,8 +1,8 @@
 import { ResultAction } from '@redux-offline/redux-offline/lib/types';
 import { ActionCreatorWithPayload, Store, UnknownAction } from '@reduxjs/toolkit';
+import { SDKRequest } from './typings';
 import { BaseState } from '../store';
 import { FileService } from './services';
-import { SDKRequest } from './typings';
 export declare abstract class BaseSDK<TState extends BaseState> {
     readonly store: Store<TState, UnknownAction | ResultAction | ActionCreatorWithPayload<any, any>>;
     abstract readonly files: FileService<TState, BaseSDK<TState>>;

package/dist/sdk/constants.d.ts

@@ -1,5 +1,4 @@
-/** Default pagination max page size as defined on the BaseOvermapCursorPagination class in /api */
-export declare const PAGINATION_MAX_PAGE_SIZE = 50000;
-/** Default pagination page size as */
-export declare const DEFAULT_PAGINATION_PAGE_SIZE = 1000;
-export declare const PAGINATION_PAGE_SIZE_QUERY_PARAM = "limit";
+/** 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;

package/dist/sdk/index.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
-import { OvermapRootState } from '../../store';
 import { AgentUserConversation, Project } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AgentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     startConversation(prompt: string, projectUuid: Project["uuid"]): Promise<AgentUserConversation>;

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
-import { Asset, AssetAttachment, Project, Stored } from '../../typings';
+import { Asset, AssetAttachment, FilePayload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetAttachment> {
+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> {
     name: string;
     url: string;
     initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">;
@@ -13,24 +13,14 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | 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_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        asset: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        asset: 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: string;
     };
     bulkAdd(payloads: {
         assetUuid: Asset["uuid"];

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

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

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

@@ -1,6 +1,6 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStepFieldValues, AssetProcedureStepFieldValuesAttachment, Created, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {

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

@@ -1,8 +1,8 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
-import { Asset, AssetProcedureInstance, AssetProcedureStep, AssetProcedureStepFields, AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
+import { Asset, AssetProcedure, AssetProcedureStep, AssetProcedureStepFields, AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetProcedureStepFieldValues>): OptimisticModelResult<AssetProcedureStepFieldValues>;
@@ -12,7 +12,7 @@ export declare abstract class AssetProcedureStepFieldValuesService<TState extend
             values: SerializedFieldValues;
             asset: Asset["uuid"];
             fields_revision: AssetProcedureStepFields["uuid"];
-            asset_procedure_instance: AssetProcedureInstance["uuid"];
+            asset_procedure: AssetProcedure["uuid"];
             asset_procedure_step: AssetProcedureStep["uuid"];
             published_at: string;
         }[];

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStepFields, AssetProcedureStepFieldsAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStepFields, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetProcedureStepFields>): OptimisticModelResult<AssetProcedureStepFields>;

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetProcedureStep>): OptimisticModelResult<AssetProcedureStep>;

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

@@ -0,0 +1,31 @@
+import { AssetProcedureType, AssetProcedureTypeAttachment, FilePayload, Organization, 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 AssetProcedureTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetProcedureTypeAttachment["uuid"], AssetProcedureTypeAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/initializeAssetProcedureTypeAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/addAssetProcedureTypeAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/updateAssetProcedureTypeAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeAttachments/deleteAssetProcedureTypeAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeAttachments/deleteAssetProcedureTypeAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/setAssetProcedureTypeAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeAttachment> | undefined>;
+    protected getId(model: Stored<AssetProcedureTypeAttachment>): AssetProcedureTypeAttachment["uuid"];
+    protected buildModel(data: BuildModelData): Submitted<AssetProcedureTypeAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeAttachment>, filePayload: FilePayload): {
+        uuid: string;
+        file_name: string;
+        file_sha1: string;
+        file_extension: string;
+        asset_procedure_type: string;
+    };
+    bulkAdd(payloads: {
+        assetProcedureTypeUuid: AssetProcedureType["uuid"];
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureTypeAttachment>>;
+    delete(uuid: AssetProcedureTypeAttachment["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeAttachment[]>;
+}

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

@@ -0,0 +1,16 @@
+import { AssetProcedureTypeFieldValues, AssetProcedureTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseUploadService } from './BaseUploadService';
+export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldValuesUuid: AssetProcedureTypeFieldValues["uuid"];
+        fieldIdentifier: string;
+        file: File;
+    }[], batchSize?: number): Promise<[
+        Stored<AssetProcedureTypeFieldValuesAttachment>[],
+        Promise<Created<AssetProcedureTypeFieldValuesAttachment>[]>[]
+    ]>;
+    bulkDelete(uuids: AssetProcedureTypeFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldValuesAttachment[]>;
+}

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

@@ -0,0 +1,22 @@
+import { SerializedFieldValues } from '@overmap-ai/forms';
+import { Asset, AssetProcedure, AssetProcedureTypeFields, AssetProcedureTypeFieldValues, 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 AssetProcedureTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureTypeFieldValues>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
+    bulkAdd(payload: {
+        values: SerializedFieldValues;
+        payloads: {
+            values: SerializedFieldValues;
+            asset: Asset["uuid"];
+            fields_revision: AssetProcedureTypeFields["uuid"];
+            asset_procedure: AssetProcedure["uuid"];
+            published_at: string;
+        }[];
+    }, batchSize?: number): [Stored<AssetProcedureTypeFieldValues>[], Promise<Created<AssetProcedureTypeFieldValues>[]>[]];
+    update(payload: UUID<Partial<Payload<AssetProcedureTypeFieldValues>>>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
+    delete(uuid: AssetProcedureTypeFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldValues[]>;
+}

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

@@ -0,0 +1,13 @@
+import { AssetProcedureTypeFields, AssetProcedureTypeFieldsAttachment, Organization } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseUploadService } from './BaseUploadService';
+export declare abstract class AssetProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldsRevisionUuid: AssetProcedureTypeFields["uuid"];
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureTypeFieldsAttachment>>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldsAttachment[]>;
+}

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

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

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

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

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { Asset, AssetType, Created, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Asset>): OptimisticModelResult<Asset>;

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetStageCompletion, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetStageCompletionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetStageCompletion>): OptimisticModelResult<AssetStageCompletion>;

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetStage, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;

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

@@ -1,35 +1,26 @@
-import { OvermapRootState } from '../../store';
-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 { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
+export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment["uuid"], AssetTypeAttachment> {
     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 buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | 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_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,6 +1,6 @@
-import { OvermapRootState } from '../../store';
 import { AssetTypeFieldValues, AssetTypeFieldValuesAttachment, Created, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {

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

@@ -1,8 +1,8 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
 import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetTypeFieldValues>): OptimisticModelResult<AssetTypeFieldValues>;

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetTypeFields, AssetTypeFieldsAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class AssetTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetTypeFields, Organization, Payload } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetTypeFields>): OptimisticModelResult<AssetTypeFields>;

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

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

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

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

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { AssetType, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<AssetType>): OptimisticModelResult<AssetType>;

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

@@ -1,38 +1,32 @@
 import { ActionCreatorWithPayload } from '@reduxjs/toolkit';
 import { OvermapRootState, OvermapSelectorWithArgs } from '../../store';
-import { Attachment, FileModelPayload, Stored, Submitted, User, UUIDModel } from '../../typings';
+import { FileModelPayload, FilePayload, RequiredFileWithNameModel, Stored, Submitted, User, UUIDModel } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseUploadService } from './BaseUploadService';
-export interface AttachmentPayload extends FileModelPayload {
-    uuid: UUIDModel["uuid"];
-    description: Attachment["description"];
-}
-export interface BuildOfflineAttachmentData {
+export interface BuildModelData {
     file: File;
     file_sha1: string;
     submitted_at: string;
-    created_by?: User["id"];
-    description?: string;
-    modelUuid: UUIDModel["uuid"];
-}
-export interface BuildAttachmentPayloadData extends AttachmentPayload {
+    created_by?: User["uuid"];
     modelUuid: UUIDModel["uuid"];
 }
-export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TAttachment extends Attachment> extends BaseUploadService<TState, TSDK> {
+export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string, TModel extends RequiredFileWithNameModel> extends BaseUploadService<TState, TSDK> {
+    protected pageSize: number;
     abstract readonly name: string;
     abstract readonly url: string;
-    abstract readonly addAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
-    abstract readonly updateAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
-    abstract readonly removeAttachments: ActionCreatorWithPayload<string[]>;
-    abstract readonly setAttachment: ActionCreatorWithPayload<Stored<TAttachment>>;
-    abstract readonly removeAttachment: ActionCreatorWithPayload<string>;
-    abstract readonly selectAttachment: OvermapSelectorWithArgs<string, Stored<TAttachment> | undefined>;
-    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData): Submitted<TAttachment>;
-    protected abstract buildAttachmentPayload(data: BuildAttachmentPayloadData): AttachmentPayload;
+    abstract readonly setAttachment: ActionCreatorWithPayload<Stored<TModel>>;
+    abstract readonly addAttachments: ActionCreatorWithPayload<Stored<TModel>[]>;
+    abstract readonly updateAttachments: ActionCreatorWithPayload<Stored<TModel>[]>;
+    abstract readonly removeAttachments: ActionCreatorWithPayload<TModelId[]>;
+    abstract readonly removeAttachment: ActionCreatorWithPayload<TModelId>;
+    abstract readonly selectAttachment: OvermapSelectorWithArgs<TModelId, Stored<TModel> | undefined>;
+    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<TAttachment>>;
-    _delete(uuid: UUIDModel["uuid"]): Promise<void>;
+    }[]): Promise<OptimisticMultipleModelResult<TModel>>;
+    _delete(uuid: TModelId): Promise<void>;
 }

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

@@ -10,6 +10,7 @@ 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[]>;

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { Category, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class CategoryService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Category>): OptimisticModelResult<Category>;