@overmap-ai/core 1.0.74-guest-access.0 → 1.0.74-master.1

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

@@ -0,0 +1,15 @@
+import { AssetProcedureFieldValuesAttachment, Created, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseUploadService } from './BaseUploadService';
+export declare abstract class AssetProcedureFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldValuesId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[], batchSize?: number): Promise<[
+        Stored<AssetProcedureFieldValuesAttachment>[],
+        Promise<Created<AssetProcedureFieldValuesAttachment>[]>[]
+    ]>;
+    bulkDelete(ids: string[]): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import { FieldValue } from '@overmap-ai/forms';
+import { AssetProcedureFieldValues, Created, Offline, OvermapRootState, Payload, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureFieldValues>): OptimisticModelResult<AssetProcedureFieldValues>;
+    bulkAdd(payload: {
+        values: Record<string, FieldValue>;
+        payloads: {
+            values: Record<string, FieldValue>;
+            asset: string;
+            fields_revision: string;
+            asset_procedure_instance: string;
+            published_at: string;
+        }[];
+    }, batchSize?: number): [Stored<AssetProcedureFieldValues>[], Promise<Created<AssetProcedureFieldValues>[]>[]];
+    update(payload: Offline<Partial<Payload<AssetProcedureFieldValues>>>): OptimisticModelResult<AssetProcedureFieldValues>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import { AssetProcedureFieldsAttachment, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseUploadService } from './BaseUploadService';
+export declare abstract class AssetProcedureFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldsRevisionId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureFieldsAttachment>>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import { AssetProcedureFields, OvermapRootState, Payload } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureFields>): OptimisticModelResult<AssetProcedureFields>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { AssetProcedureInstance, Offline, OvermapRootState, Payload } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class AssetProcedureInstanceService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<AssetProcedureInstance>): OptimisticModelResult<AssetProcedureInstance>;
+    update(payload: Offline<Partial<Payload<AssetProcedureInstance>>>): OptimisticModelResult<AssetProcedureInstance>;
+    remove(assetProcedureInstanceId: string): Promise<undefined>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { AssetProcedure, Offline, OvermapRootState, Payload } 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> {
+    add(payload: Payload<AssetProcedure>): OptimisticModelResult<AssetProcedure>;
+    update(payload: Offline<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;
+    remove(id: string): Promise<undefined>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -3,8 +3,8 @@ import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    bulkAdd(stagesToSubmit: Omit<Payload<AssetStage>, "asset_type">[], assetTypeId: string): OptimisticMultipleModelResult<AssetStage>;
-    bulkUpdate(stagesToUpdate: AssetStage[], assetTypeId: string): Promise<AssetStage[]>;
+    bulkAdd(stagesToSubmit: Omit<Payload<AssetStage>, "asset_procedure">[], assetProcedureId: string): OptimisticMultipleModelResult<AssetStage>;
+    bulkUpdate(stagesToUpdate: AssetStage[], assetProcedureId: string): Promise<AssetStage[]>;
     bulkDelete(idsToDelete: string[]): Promise<undefined>;
     update(payload: Offline<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
     refreshStore(organizationId: number): Promise<undefined>;

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

@@ -21,13 +21,13 @@ export interface BuildAttachmentPayloadData<TModelId> extends AttachmentPayload
 export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string | number, TAttachment extends Attachment> extends BaseUploadService<TState, TSDK> {
     abstract readonly name: string;
     abstract readonly url: string;
-    abstract readonly addAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
-    abstract readonly updateAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly addAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
+    abstract readonly updateAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
     abstract readonly removeAttachments: ActionCreatorWithPayload<string[]>;
     abstract readonly setAttachment: ActionCreatorWithPayload<Stored<TAttachment>>;
     abstract readonly removeAttachment: ActionCreatorWithPayload<string>;
     abstract readonly selectAttachment: OvermapSelectorWithArgs<string, Stored<TAttachment> | undefined>;
-    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData<TModelId>): Stored<TAttachment>;
+    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData<TModelId>): Submitted<TAttachment>;
     protected abstract buildAttachmentPayload(data: BuildAttachmentPayloadData<TModelId>): AttachmentPayload;
     _bulkAdd(payloads: {
         modelId: TModelId;

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

@@ -5,6 +5,7 @@ import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachme
 export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueAttachment> {
     name: string;
     url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
     updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
     removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;

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

@@ -0,0 +1,40 @@
+import { IssueCommentAttachment, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueCommentAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue_comment: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        issue_comment: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        issueCommentId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueCommentAttachment>>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+import { IssueTypeAttachment, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueTypeAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue_type: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        issue_type: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        issueTypeId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueTypeAttachment>>;
+    delete(id: string): Promise<void>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -2,7 +2,7 @@ import { OvermapRootState, ProjectAttachment, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment> {
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, Stored<ProjectAttachment>> {
     name: string;
     url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;

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

@@ -1,5 +1,11 @@
 export * from './AgentService';
 export * from './AssetAttachmentService';
+export * from './AssetProcedureFieldsAttachmentService';
+export * from './AssetProcedureFieldsService';
+export * from './AssetProcedureFieldValuesAttachmentService';
+export * from './AssetProcedureFieldValuesService';
+export * from './AssetProcedureInstanceService';
+export * from './AssetProcedureService';
 export * from './AssetService';
 export * from './AssetStageCompletionService';
 export * from './AssetStageService';
@@ -24,8 +30,10 @@ export * from './FormSubmissionService';
 export * from './GeoImageService';
 export * from './IssueAssociationService';
 export * from './IssueAttachmentService';
+export * from './IssueCommentAttachmentService';
 export * from './IssueCommentService';
 export * from './IssueService';
+export * from './IssueTypeAttachmentService';
 export * from './IssueTypeFieldsAttachmentService';
 export * from './IssueTypeFieldsService';
 export * from './IssueTypeFieldValuesAttachmentService';

package/dist/store/slices/assetAttachmentSlice.d.ts

@@ -39,8 +39,4 @@ export declare const selectAssetAttachmentMapping: (state: OvermapRootState) =>
 export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
 export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
 export declare const selectAttachmentsOfAsset: (args: string) => (state: OvermapRootState) => Stored<AssetAttachment>[];
-export declare const selectAttachmentsOfAssetByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<AssetAttachment>[];
-    imageAttachments: Stored<AssetAttachment>[];
-};
 export declare const assetAttachmentReducer: Reducer<AssetAttachmentState>;

package/dist/store/slices/assetProcedureFieldValuesAttachmentSlice.d.ts

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetProcedureFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldValuesAttachmentState = ModelState<Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const assetProcedureFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesAttachmentState, {
+    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFieldValuesAttachments", "assetProcedureFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesAttachmentState>>;
+export declare const initializeAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/initializeAssetProcedureFieldValuesAttachments">, addAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachment">, addAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachments">, setAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachment">, setAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachments">, updateAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachment">, updateAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachments">, deleteAssetProcedureFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachment">, deleteAssetProcedureFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachments">;
+export declare const selectAssetProcedureFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const selectAssetProcedureFieldValuesAttachments: ((state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValuesAttachment> | undefined>;
+export declare const selectAssetProcedureFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[];
+export declare const selectAttachmentsOfAssetProcedureFieldValues: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValuesAttachment>[]>;
+export declare const assetProcedureFieldValuesAttachmentReducer: Reducer<AssetProcedureFieldValuesAttachmentState>;

package/dist/store/slices/assetProcedureFieldValuesSlice.d.ts

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetProcedureFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldValuesState = ModelState<Stored<AssetProcedureFieldValues>>;
+export declare const assetProcedureFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesState, {
+    initializeAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFieldValues", "assetProcedureFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesState>>;
+export declare const initializeAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/initializeAssetProcedureFieldValues">, addAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/addAssetProcedureFieldValues">, addAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/addAssetProcedureFieldValuesMany">, setAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/setAssetProcedureFieldValues">, setAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/setAssetProcedureFieldValuesMany">, updateAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/updateAssetProcedureFieldValues">, updateAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/updateAssetProcedureFieldValuesMany">, deleteAssetProcedureFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldValues/deleteAssetProcedureFieldValues">, deleteAssetProcedureFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldValues/deleteAssetProcedureFieldValuesMany">;
+export declare const selectAssetProcedureFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValues>>;
+export declare const selectAssetProcedureFieldValues: ((state: OvermapRootState) => Stored<AssetProcedureFieldValues>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValues>>) => Stored<AssetProcedureFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValues>>) => Stored<AssetProcedureFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldValuesOfAsset: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues>[]>;
+export declare const selectFieldValuesOfAssetProcedureInstance: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues>[]>;
+export declare const selectAssetProcedureFieldValuesById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues> | undefined>;
+export declare const assetProcedureFieldValuesReducer: Reducer<AssetProcedureFieldValuesState>;

package/dist/store/slices/assetProcedureFieldsAttachmentSlice.d.ts

@@ -0,0 +1,62 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetProcedureFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldsAttachmentState = ModelState<Stored<AssetProcedureFieldsAttachment>>;
+export declare const assetProcedureFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsAttachmentState, {
+    initializeAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFieldsAttachments", "assetProcedureFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsAttachmentState>>;
+export declare const initializeAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/initializeAssetProcedureFieldsAttachments">, addAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachment">, addAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachments">, setAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachment">, setAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachments">, updateAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachment">, updateAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachments">, deleteAssetProcedureFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachment">, deleteAssetProcedureFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachments">;
+export declare const selectAssetProcedureFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldsAttachment>>;
+export declare const selectAssetProcedureFieldsAttachments: ((state: OvermapRootState) => Stored<AssetProcedureFieldsAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldsAttachment>>) => Stored<AssetProcedureFieldsAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldsAttachment>>) => Stored<AssetProcedureFieldsAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldsAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldsAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAttachmentsOfAssetProcedureFields: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldsAttachment>[]>;
+export declare const selectAssetProcedureFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldsAttachment> | undefined>;
+export declare const assetProcedureFieldsAttachmentReducer: Reducer<AssetProcedureFieldsAttachmentState>;

package/dist/store/slices/assetProcedureFieldsSlice.d.ts

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetProcedureFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureFieldsState = ModelState<Stored<AssetProcedureFields>>;
+export declare const assetProcedureFieldsSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsState, {
+    initializeAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFields: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureFieldsMany: (state: ModelState<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureFields", "assetProcedureFields", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsState>>;
+export declare const initializeAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/initializeAssetProcedureFields">, addAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/addAssetProcedureFields">, addAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/addAssetProcedureFieldsMany">, setAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/setAssetProcedureFields">, setAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/setAssetProcedureFieldsMany">, updateAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>, "assetProcedureFields/updateAssetProcedureFields">, updateAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[], "assetProcedureFields/updateAssetProcedureFieldsMany">, deleteAssetProcedureFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureFields/deleteAssetProcedureFields">, deleteAssetProcedureFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureFields/deleteAssetProcedureFieldsMany">;
+export declare const selectAssetProcedureFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectAssetProcedureFields: ((state: OvermapRootState) => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFields<import('@overmap-ai/forms').ISerializedField>>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureFields>[]>;
+export declare const selectLatestAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureFields> | undefined>;
+export declare const selectAssetProcedureFieldsById: OvermapSelectorWithArgs<string, Stored<AssetProcedureFields> | undefined>;
+export declare const assetProcedureFieldsReducer: Reducer<AssetProcedureFieldsState>;

package/dist/store/slices/assetProcedureInstanceSlice.d.ts

@@ -0,0 +1,64 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetProcedureInstance, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureInstanceState = ModelState<Stored<AssetProcedureInstance>>;
+export declare const assetProcedureInstanceSlice: import('@reduxjs/toolkit').Slice<AssetProcedureInstanceState, {
+    initializeAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    addAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>;
+        type: string;
+    }) => void;
+    addAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    setAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>;
+        type: string;
+    }) => void;
+    setAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>;
+        type: string;
+    }) => void;
+    updateAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: {
+        payload: Stored<AssetProcedureInstance>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureInstance: (state: ModelState<Stored<AssetProcedureInstance>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetProcedureInstances: (state: ModelState<Stored<AssetProcedureInstance>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetProcedureInstances", "assetProcedureInstances", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureInstanceState>>;
+export declare const initializeAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/initializeAssetProcedureInstances">, addAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/addAssetProcedureInstance">, addAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/addAssetProcedureInstances">, updateAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/updateAssetProcedureInstance">, updateAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/updateAssetProcedureInstances">, deleteAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureInstances/deleteAssetProcedureInstance">, deleteAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureInstances/deleteAssetProcedureInstances">, setAssetProcedureInstance: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>, "assetProcedureInstances/setAssetProcedureInstance">, setAssetProcedureInstances: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureInstance>[], "assetProcedureInstances/setAssetProcedureInstances">;
+export declare const selectAssetProcedureInstancesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureInstance>>;
+export declare const selectAssetProcedureInstances: ((state: OvermapRootState) => Stored<AssetProcedureInstance>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureInstance>>) => Stored<AssetProcedureInstance>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureInstance>>) => Stored<AssetProcedureInstance>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureInstance>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureInstance>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureInstancesOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureInstance>[]>;
+export declare const selectAssetProcedureInstancesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetProcedureInstance>[]>;
+export declare const selectAssetProcedureInstanceById: OvermapSelectorWithArgs<string, Stored<AssetProcedureInstance> | undefined>;
+export declare const selectAssetProcedureInstancesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureInstance>[];
+export declare const assetProcedureInstanceReducer: Reducer<AssetProcedureInstanceState>;