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

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 { SDKRequest } from './typings';
+import { BaseService } from './services/BaseService';
+import { OfflineSDKRequest, PaginatedSDKRequest, SDKRequest } from './typings';
 import { BaseState } from '../store';
 import { FileService } from './services';
 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, signal?: AbortSignal): 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

@@ -2,3 +2,4 @@
 export declare const DEFAULT_PAGE_SIZE = 10000;
 /** Attachment model pagination page size */
 export declare const ATTACHMENT_MODEL_DEFAULT_PAGE_SIZE = 200;
+export declare const DISCARD_HTTP_STATUSES: number[];

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

@@ -7,3 +7,5 @@ export * from './services';
 export * from './typings';
 export * from './globals';
 export * from './middleware';
+export * from './performRequest';
+export * from './utils';

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

@@ -7,5 +7,6 @@ export declare abstract class AgentService<TState extends OvermapRootState, TSDK
     continueConversation(prompt: string, conversationUuid: AgentUserConversation["uuid"], projectUuid: Project["uuid"]): Promise<void>;
     fetchDetails(conversationUuid: AgentUserConversation["uuid"]): Promise<void>;
     rate(responseUuid: string, rating: 1 | 5): Promise<undefined>;
+    private list;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AgentUserConversation[]>;
 }

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

@@ -1,36 +1,34 @@
-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 { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetAttachment> {
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class AssetAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, AssetAttachment["uuid"], AssetAttachment> {
     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;
+    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: (args: string[]) => (state: OvermapRootState) => Stored<AssetAttachment>[];
+    };
+    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,28 @@
-import { AssetProcedure, Payload, Project, UUID } from '../../typings';
+import { AssetProcedure, 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 AssetProcedureService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedure["uuid"], AssetProcedure, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/addAssetProcedure">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/addAssetProcedures">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/setAssetProcedure">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/setAssetProcedures">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/updateAssetProcedure">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/updateAssetProcedures">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedures/deleteAssetProcedure">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedures/deleteAssetProcedures">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/initializeAssetProcedures">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedure> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedure>[];
+    };
     add(payload: Payload<AssetProcedure>): OptimisticModelResult<AssetProcedure>;
     update(payload: UUID<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;
-    remove(uuid: AssetProcedure["uuid"]): Promise<undefined>;
+    delete(uuid: AssetProcedure["uuid"]): Promise<undefined>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedure[]>;
 }

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

@@ -1,8 +1,25 @@
 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFieldValuesAttachment["uuid"], AssetProcedureStepFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>, "assetProcedureStepFieldValuesAttachments/addAssetProcedureStepFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/addAssetProcedureStepFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>, "assetProcedureStepFieldValuesAttachments/setAssetProcedureStepFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/setAssetProcedureStepFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>, "assetProcedureStepFieldValuesAttachments/updateAssetProcedureStepFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/updateAssetProcedureStepFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldValuesAttachments/deleteAssetProcedureStepFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldValuesAttachments/deleteAssetProcedureStepFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/initializeAssetProcedureStepFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValuesAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStepFieldValuesAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldValuesUuid: AssetProcedureStepFieldValues["uuid"];
         fieldIdentifier: string;

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

@@ -3,8 +3,25 @@ import { Asset, AssetProcedure, AssetProcedureStep, AssetProcedureStepFields, As
 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFieldValues["uuid"], AssetProcedureStepFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>, "assetProcedureStepFieldValues/addAssetProcedureStepFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/addAssetProcedureStepFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>, "assetProcedureStepFieldValues/setAssetProcedureStepFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/setAssetProcedureStepFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>, "assetProcedureStepFieldValues/updateAssetProcedureStepFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/updateAssetProcedureStepFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldValues/deleteAssetProcedureStepFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldValues/deleteAssetProcedureStepFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/initializeAssetProcedureStepFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValues> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStepFieldValues>[];
+    };
     add(payload: Payload<AssetProcedureStepFieldValues>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;

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

@@ -2,8 +2,25 @@ import { AssetProcedureStepFields, AssetProcedureStepFieldsAttachment, Organizat
 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFieldsAttachment["uuid"], AssetProcedureStepFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldsAttachments/deleteAssetProcedureStepFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldsAttachments/deleteAssetProcedureStepFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/initializeAssetProcedureStepFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetProcedureStepFieldsAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<AssetProcedureStepFieldsAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldsRevisionUuid: AssetProcedureStepFields["uuid"];
         fieldIdentifier: string;

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

@@ -1,9 +1,26 @@
-import { AssetProcedureStepFields, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedureStepFields, 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 AssetProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFields["uuid"], AssetProcedureStepFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>, "assetProcedureStepFields/addAssetProcedureStepFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/addAssetProcedureStepFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>, "assetProcedureStepFields/setAssetProcedureStepFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/setAssetProcedureStepFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>, "assetProcedureStepFields/updateAssetProcedureStepFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/updateAssetProcedureStepFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFields/deleteAssetProcedureStepFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFields/deleteAssetProcedureStepFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/initializeAssetProcedureStepFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFields> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStepFields>[];
+    };
     add(payload: Payload<AssetProcedureStepFields>): OptimisticModelResult<AssetProcedureStepFields>;
     update(payload: UUID<Partial<Payload<AssetProcedureStepFields>>>): OptimisticModelResult<AssetProcedureStepFields>;
     delete(uuid: AssetProcedureStepFields["uuid"]): Promise<void>;

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

@@ -1,9 +1,26 @@
-import { AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedureStep, 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 AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStep["uuid"], AssetProcedureStep, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>, "assetProcedureSteps/addAssetProcedureStep">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/addAssetProcedureSteps">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>, "assetProcedureSteps/setAssetProcedureStep">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/setAssetProcedureSteps">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>, "assetProcedureSteps/updateAssetProcedureStep">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/updateAssetProcedureSteps">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureSteps/deleteAssetProcedureStep">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureSteps/deleteAssetProcedureSteps">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/initializeAssetProcedureSteps">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStep> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStep>[];
+    };
     add(payload: Payload<AssetProcedureStep>): OptimisticModelResult<AssetProcedureStep>;
     update(payload: UUID<Partial<Payload<AssetProcedureStep>>>): OptimisticModelResult<AssetProcedureStep>;
     delete(uuid: AssetProcedureStep["uuid"]): Promise<void>;

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

@@ -1,35 +1,34 @@
-import { AssetProcedureType, AssetProcedureTypeAttachment, Organization, Stored } from '../../typings';
+import { AssetProcedureType, AssetProcedureTypeAttachment, 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 AssetProcedureTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetProcedureTypeAttachment> {
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class AssetProcedureTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, AssetProcedureTypeAttachment["uuid"], AssetProcedureTypeAttachment> {
     name: string;
     url: string;
-    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 buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/addAssetProcedureTypeAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/addAssetProcedureTypeAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/setAssetProcedureTypeAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/setAssetProcedureTypeAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/updateAssetProcedureTypeAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/updateAssetProcedureTypeAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeAttachments/deleteAssetProcedureTypeAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeAttachments/deleteAssetProcedureTypeAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/initializeAssetProcedureTypeAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeAttachment>[];
+    };
+    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_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        asset_procedure_type: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        asset_procedure_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_procedure_type: string;
     };
     bulkAdd(payloads: {
         assetProcedureTypeUuid: AssetProcedureType["uuid"];

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

@@ -1,8 +1,25 @@
 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFieldValuesAttachment["uuid"], AssetProcedureTypeFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>, "assetProcedureTypeFieldValuesAttachments/addAssetProcedureTypeFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/addAssetProcedureTypeFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>, "assetProcedureTypeFieldValuesAttachments/setAssetProcedureTypeFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/setAssetProcedureTypeFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>, "assetProcedureTypeFieldValuesAttachments/updateAssetProcedureTypeFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/updateAssetProcedureTypeFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldValuesAttachments/deleteAssetProcedureTypeFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldValuesAttachments/deleteAssetProcedureTypeFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/initializeAssetProcedureTypeFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValuesAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeFieldValuesAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldValuesUuid: AssetProcedureTypeFieldValues["uuid"];
         fieldIdentifier: string;

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

@@ -3,8 +3,25 @@ import { Asset, AssetProcedure, AssetProcedureTypeFields, AssetProcedureTypeFiel
 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFieldValues["uuid"], AssetProcedureTypeFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>, "assetProcedureTypeFieldValues/addAssetProcedureTypeFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/addAssetProcedureTypeFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>, "assetProcedureTypeFieldValues/setAssetProcedureTypeFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/setAssetProcedureTypeFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>, "assetProcedureTypeFieldValues/updateAssetProcedureTypeFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/updateAssetProcedureTypeFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldValues/deleteAssetProcedureTypeFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldValues/deleteAssetProcedureTypeFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/initializeAssetProcedureTypeFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValues> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeFieldValues>[];
+    };
     add(payload: Payload<AssetProcedureTypeFieldValues>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;

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

@@ -2,8 +2,25 @@ import { AssetProcedureTypeFields, AssetProcedureTypeFieldsAttachment, Organizat
 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> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFieldsAttachment["uuid"], AssetProcedureTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldsAttachments/deleteAssetProcedureTypeFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldsAttachments/deleteAssetProcedureTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/initializeAssetProcedureTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetProcedureTypeFieldsAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<AssetProcedureTypeFieldsAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldsRevisionUuid: AssetProcedureTypeFields["uuid"];
         fieldIdentifier: string;

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

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

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

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

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

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