@overmap-ai/core 1.0.78-improvements.1 → 1.0.78-issue-update-typing-fix.1

package/dist/sdk/base.d.ts

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

package/dist/sdk/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_PAGE_SIZE = 10000;
+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/errors.d.ts

@@ -13,3 +13,8 @@ export declare class APIError extends Error {
     options: APIErrorOptions;
     constructor(options: APIErrorOptions);
 }
+/**
+ * Makes a best-effort attempt to extract a request.Response from an error object.
+ * @param error The error object
+ */
+export declare function extractResponseFromError(error: unknown): request.Response | undefined;

package/dist/sdk/index.d.ts

@@ -1,6 +1,11 @@
 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';
+export * from './performRequest';
+export * from './utils';

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/performRequest.d.ts

@@ -0,0 +1,6 @@
+import { default as request } from 'superagent';
+import { BaseSDK } from './base';
+import { RequestDetails } from './typings';
+import { BaseState } from '../store';
+import { BaseService } from './services/BaseService';
+export declare function performRequest(baseUrl: string, requestDetails: RequestDetails, client: BaseSDK<BaseState>, service: BaseService<BaseState, BaseSDK<BaseState>>, signal?: AbortSignal): Promise<request.Response>;

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

@@ -1,11 +1,12 @@
-import { OvermapRootState } from '../../store';
 import { AgentUserConversation, Project } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AgentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     startConversation(prompt: string, projectUuid: Project["uuid"]): Promise<AgentUserConversation>;
     continueConversation(prompt: string, conversationUuid: AgentUserConversation["uuid"], projectUuid: Project["uuid"]): Promise<void>;
     fetchDetails(conversationUuid: AgentUserConversation["uuid"]): Promise<void>;
     rate(responseUuid: string, rating: 1 | 5): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    private list;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AgentUserConversation[]>;
 }

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

@@ -1,41 +1,30 @@
-import { OvermapRootState } from '../../store';
-import { Asset, AssetAttachment, Project, Stored } from '../../typings';
+import { AssetAttachment, Payload, 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 { 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 buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
-        file_name: string;
-        file_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        asset: 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_extension: 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>;
-    refreshStore(projectUuid: Project["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 { OvermapRootState } from '../../store';
-import { Asset, AssetType, Created, Payload, Project, UUID } from '../../typings';
+import { Asset, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Asset["uuid"], Asset, TState, TSDK> {
+    url: string;
+    name: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assets/deleteAsset">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assets/deleteAssets">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Asset> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Asset>[];
+    };
     add(payload: Payload<Asset>): OptimisticModelResult<Asset>;
     update(payload: UUID<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
     delete(uuid: Asset["uuid"]): Promise<undefined>;
-    bulkAdd(payloads: Omit<Payload<Asset>, "asset_type" | "project">[], assetTypeUuid: AssetType["uuid"], projectUuid: Project["uuid"], batchSize: number): Promise<Created<Asset>[]>[];
-    bulkDelete(assetUuids: Asset["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    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,40 +1,30 @@
-import { OvermapRootState } from '../../store';
-import { AssetType, AssetTypeAttachment, Organization, Stored } from '../../typings';
+import { AssetTypeAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetTypeAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetTypeAttachment["uuid"], AssetTypeAttachment, TState, TSDK> {
     name: string;
     url: string;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
-        file_name: string;
-        file_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        asset_type: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        asset_type: string;
-        modelUuid: import('../..').UUIDModel["uuid"];
-        uuid: import('../..').UUIDModel["uuid"];
-        description: import('../..').Attachment["description"];
-        file_sha1: import('../..').FileWithNameModel["file_sha1"];
-        file_name: import('../..').FileWithNameModel["file_name"];
-        file_extension: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/addAssetTypeAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/setAssetTypeAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/updateAssetTypeAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeAttachment>[];
     };
-    bulkAdd(payloads: {
-        assetTypeUuid: AssetType["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
-    delete(uuid: AssetTypeAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    protected getId(model: Stored<AssetTypeAttachment>): AssetTypeAttachment["uuid"];
+    protected getBlockers(model: Stored<AssetTypeAttachment>): string[];
+    protected getBlocks(model: Stored<AssetTypeAttachment>): string[];
+    protected buildModel(payload: Payload<AssetTypeAttachment>): Submitted<AssetTypeAttachment>;
+    protected buildPayload(model: Submitted<AssetTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetTypeAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeAttachment[]>;
 }

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+import { AssetTypeIdentifier, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetTypeIdentifier["uuid"], AssetTypeIdentifier, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>, "assetTypeIdentifiers/addAssetTypeIdentifier">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/addAssetTypeIdentifiers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>, "assetTypeIdentifiers/setAssetTypeIdentifier">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/setAssetTypeIdentifiers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>, "assetTypeIdentifiers/updateAssetTypeIdentifier">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/updateAssetTypeIdentifiers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeIdentifiers/deleteAssetTypeIdentifier">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeIdentifiers/deleteAssetTypeIdentifiers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeIdentifier>[], "assetTypeIdentifiers/initializeAssetTypeIdentifiers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeIdentifier> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeIdentifier>[];
+    };
+    add(payload: Payload<AssetTypeIdentifier>): OptimisticModelResult<AssetTypeIdentifier>;
+    update(payload: UUID<Partial<Payload<AssetTypeIdentifier>>>): OptimisticModelResult<AssetTypeIdentifier>;
+    delete(uuid: AssetTypeIdentifier["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeIdentifier[]>;
+}

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

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