@overmap-ai/core 1.0.78-view-sets-cleanup.3 → 1.0.78-workflows-2.2

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, 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

@@ -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";
+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,7 +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>;
+    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>;
+    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/AssetProcedureService.d.ts

@@ -1,11 +1,28 @@
-import { OvermapRootState } from '../../store';
-import { AssetProcedure, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedure, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetProcedureService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (uuids: string[]) => (state: any) => Stored<AssetProcedure>[];
+    };
     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[]>;
+    delete(uuid: AssetProcedure["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedure[]>;
 }

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

@@ -1,16 +1,31 @@
-import { OvermapRootState } from '../../store';
-import { AssetProcedureStepFieldValues, AssetProcedureStepFieldValuesAttachment, Created, Project, Stored } from '../../typings';
+import { AssetProcedureStepFieldValuesAttachment, Payload, Project, Stored, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
-    bulkAdd(payloads: {
-        fieldValuesUuid: AssetProcedureStepFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[], batchSize?: number): Promise<[
-        Stored<AssetProcedureStepFieldValuesAttachment>[],
-        Promise<Created<AssetProcedureStepFieldValuesAttachment>[]>[]
-    ]>;
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<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: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureStepFieldValuesAttachment>): string;
+    protected getBlockers(payload: UUID<Omit<Payload<AssetProcedureStepFieldValuesAttachment>, "file_type" | "file_url">>): string[];
+    protected getBlocks(model: Stored<AssetProcedureStepFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureStepFieldValuesAttachment>): Submitted<AssetProcedureStepFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureStepFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureStepFieldValuesAttachment>): object;
     bulkDelete(uuids: AssetProcedureStepFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldValuesAttachment[]>;
 }

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

@@ -1,21 +1,31 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { OvermapRootState } from '../../store';
-import { Asset, AssetProcedureInstance, AssetProcedureStep, AssetProcedureStepFields, AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
+import { AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetProcedureStepFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValues>[];
+    };
     add(payload: Payload<AssetProcedureStepFieldValues>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;
-        payloads: {
-            values: SerializedFieldValues;
-            asset: Asset["uuid"];
-            fields_revision: AssetProcedureStepFields["uuid"];
-            asset_procedure_instance: AssetProcedureInstance["uuid"];
-            asset_procedure_step: AssetProcedureStep["uuid"];
-            published_at: string;
-        }[];
+        payloads: Payload<AssetProcedureStepFieldValues>[];
     }, batchSize?: number): [Stored<AssetProcedureStepFieldValues>[], Promise<Created<AssetProcedureStepFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetProcedureStepFieldValues>>>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     delete(uuid: AssetProcedureStepFieldValues["uuid"]): Promise<void>;

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

@@ -1,13 +1,30 @@
-import { OvermapRootState } from '../../store';
-import { AssetProcedureStepFields, AssetProcedureStepFieldsAttachment, Organization } from '../../typings';
+import { AssetProcedureStepFieldsAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
-    bulkAdd(payloads: {
-        fieldsRevisionUuid: AssetProcedureStepFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureStepFieldsAttachment>>;
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureStepFieldsAttachment["uuid"], AssetProcedureStepFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<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<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/initializeAssetProcedureStepFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldsAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureStepFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureStepFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureStepFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureStepFieldsAttachment>): Submitted<AssetProcedureStepFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureStepFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureStepFieldsAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldsAttachment[]>;
 }

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { AssetProcedureStepFields, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedureStepFields, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (uuids: string[]) => (state: any) => 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 { OvermapRootState } from '../../store';
-import { AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedureStep, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (uuids: string[]) => (state: any) => 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

@@ -0,0 +1,30 @@
+import { AssetProcedureTypeAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeAttachment["uuid"], AssetProcedureTypeAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    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: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureTypeAttachment>): AssetProcedureTypeAttachment["uuid"];
+    protected getBlockers(model: Stored<AssetProcedureTypeAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeAttachment>): Submitted<AssetProcedureTypeAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeAttachment[]>;
+}

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

@@ -0,0 +1,31 @@
+import { AssetProcedureTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<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: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeFieldValuesAttachment>): Submitted<AssetProcedureTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeFieldValuesAttachment>): object;
+    bulkDelete(uuids: AssetProcedureTypeFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldValuesAttachment[]>;
+}

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

@@ -0,0 +1,33 @@
+import { SerializedFieldValues } from '@overmap-ai/forms';
+import { AssetProcedureTypeFieldValues, Created, 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 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: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValues>[];
+    };
+    add(payload: Payload<AssetProcedureTypeFieldValues>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
+    bulkAdd(payload: {
+        values: SerializedFieldValues;
+        payloads: Payload<AssetProcedureTypeFieldValues>[];
+    }, 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,30 @@
+import { AssetProcedureTypeFieldsAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeFieldsAttachment["uuid"], AssetProcedureTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<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<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/initializeAssetProcedureTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldsAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeFieldsAttachment>): Submitted<AssetProcedureTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeFieldsAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldsAttachment[]>;
+}