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

package/dist/store/adapters/modelAdapter.d.ts

@@ -1,15 +1,14 @@
-import { PayloadAction } from '@reduxjs/toolkit';
-import { ModelState } from './typings';
-export interface OvermapModelAdapter<TId extends string | number | symbol, TModel> {
-    addOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
-    addMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    setOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
-    setMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    updateOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
-    updateMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    deleteOne: (state: ModelState<TId, TModel>, action: PayloadAction<TId>) => void;
-    deleteMany: (state: ModelState<TId, TModel>, action: PayloadAction<TId[]>) => void;
-    initialize: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    getInitialState: <TState extends object>(state: TState) => TState & ModelState<TId, TModel>;
+import { CaseReducer } from '@reduxjs/toolkit';
+import { AddManyPayloadAction, AddOnePayloadAction, DeleteManyPayloadAction, DeleteOnePayloadAction, InitializePayloadAction, ModelState, SetManyPayloadAction, SetOnePayloadAction, UpdateManyPayloadAction, UpdateOnePayloadAction } from './typings';
+export interface OvermapModelAdapter<TId extends PropertyKey, TModel, TState extends ModelState<TId, TModel>> {
+    addOne: CaseReducer<TState, AddOnePayloadAction<TModel>>;
+    addMany: CaseReducer<TState, AddManyPayloadAction<TModel>>;
+    setOne: CaseReducer<TState, SetOnePayloadAction<TModel>>;
+    setMany: CaseReducer<TState, SetManyPayloadAction<TModel>>;
+    updateOne: CaseReducer<TState, UpdateOnePayloadAction<TModel>>;
+    updateMany: CaseReducer<TState, UpdateManyPayloadAction<TModel>>;
+    deleteOne: CaseReducer<TState, DeleteOnePayloadAction<TId>>;
+    deleteMany: CaseReducer<TState, DeleteManyPayloadAction<TId>>;
+    initialize: CaseReducer<TState, InitializePayloadAction<TModel>>;
 }
-export declare function createModelAdapter<TId extends string | number | symbol, TModel>(computeModelId: (model: TModel) => TId): OvermapModelAdapter<TId, TModel>;
+export declare function createModelAdapter<TId extends PropertyKey, TModel, TState extends ModelState<TId, TModel>>(computeModelId: (model: TModel) => TId): OvermapModelAdapter<TId, TModel, TState>;

package/dist/store/adapters/typings.d.ts

@@ -1,6 +1,25 @@
+import { PayloadAction, ActionCreatorWithPayload } from '@reduxjs/toolkit';
 export interface ModelState<TId extends number | string | symbol, TModel> {
     instances: Record<TId, TModel>;
 }
 export interface SelectionState<TSelection> {
     selection: TSelection[];
 }
+export type InitializePayloadAction<TModel> = PayloadAction<TModel[]>;
+export type AddOnePayloadAction<TModel> = PayloadAction<TModel>;
+export type AddManyPayloadAction<TModel> = PayloadAction<TModel[]>;
+export type UpdateOnePayloadAction<TModel> = PayloadAction<TModel>;
+export type UpdateManyPayloadAction<TModel> = PayloadAction<TModel[]>;
+export type DeleteOnePayloadAction<TId> = PayloadAction<TId>;
+export type DeleteManyPayloadAction<TId> = PayloadAction<TId[]>;
+export type SetOnePayloadAction<TModel> = PayloadAction<TModel>;
+export type SetManyPayloadAction<TModel> = PayloadAction<TModel[]>;
+export type InitializePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;
+export type AddOnePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel>;
+export type AddManyPayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;
+export type UpdateOnePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel>;
+export type UpdateManyPayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;
+export type DeleteOnePayloadActionCreator<TId> = ActionCreatorWithPayload<TId>;
+export type DeleteManyPayloadActionCreator<TId> = ActionCreatorWithPayload<TId[]>;
+export type SetOnePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel>;
+export type SetManyPayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;

package/dist/store/reducers.d.ts

@@ -14,7 +14,6 @@ export declare const baseReducer: import('redux').Reducer<{
 }>>;
 export declare const overmapReducers: {
     versioning: import('redux').Reducer<import('./slices').VersioningState>;
-    categoryReducer: import('redux').Reducer<import('./slices').CategoryState>;
     assetReducer: import('redux').Reducer<import('./slices').AssetState>;
     assetAttachmentReducer: import('redux').Reducer<import('./slices').AssetAttachmentState>;
     assetStageCompletionReducer: import('redux').Reducer<import('./slices').AssetStageCompletionState>;
@@ -37,6 +36,8 @@ export declare const overmapReducers: {
     formRevisionAttachmentReducer: import('redux').Reducer<import('./slices').FormRevisionAttachmentState>;
     formSubmissionAttachmentReducer: import('redux').Reducer<import('./slices').FormSubmissionAttachmentState>;
     formSubmissionReducer: import('redux').Reducer<import('./slices').FormSubmissionState>;
+    formIdentifierReducer: import('redux').Reducer<import('./slices').FormIdentifierState>;
+    formIdentifierValueReducer: import('redux').Reducer<import('./slices').FormIdentifierValueState>;
     userReducer: import('redux').Reducer<import('./slices').UserState>;
     emailDomainsReducer: import('redux').Reducer<import('./slices').EmailDomainState>;
     documentsReducer: import('redux').Reducer<import('./slices').DocumentState>;
@@ -52,30 +53,48 @@ export declare const overmapReducers: {
     issueTypeFieldValuesReducer: import('redux').Reducer<import('./slices').IssueTypeFieldValuesState>;
     issueTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').IssueTypeFieldsAttachmentState>;
     issueTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').IssueTypeFieldValuesAttachmentState>;
+    issueTypeIdentifierReducer: import('redux').Reducer<import('./slices').IssueTypeIdentifierState>;
+    issueTypeIdentifierValueReducer: import('redux').Reducer<import('./slices').IssueTypeIdentifierValueState>;
+    issueTypeStatusReducer: import('redux').Reducer<import('./slices').IssueTypeStatusState>;
     assetTypeFieldsReducer: import('redux').Reducer<import('./slices').AssetTypeFieldsState>;
     assetTypeFieldValuesReducer: import('redux').Reducer<import('./slices').AssetTypeFieldValuesState>;
     assetTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeFieldsAttachmentState>;
     assetTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeFieldValuesAttachmentState>;
+    assetTypeIdentifierReducer: import('redux').Reducer<import('./slices').AssetTypeIdentifierState>;
+    assetTypeIdentifierValueReducer: import('redux').Reducer<import('./slices').AssetTypeIdentifierValueState>;
+    assetTypeStatusReducer: import('redux').Reducer<import('./slices').AssetTypeStatusState>;
+    assetProcedureTypeReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeState>;
     assetProcedureReducer: import('redux').Reducer<import('./slices').AssetProcedureState>;
-    assetProcedureInstanceReducer: import('redux').Reducer<import('./slices').AssetProcedureInstanceState>;
-    assetProcedureFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldsState>;
-    assetProcedureFieldValuesReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldValuesState>;
-    assetProcedureFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldsAttachmentState>;
-    assetProcedureFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldValuesAttachmentState>;
-    assetProcedureAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureAttachmentState>;
+    assetProcedureTypeFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldsState>;
+    assetProcedureTypeFieldValuesReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldValuesState>;
+    assetProcedureTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldsAttachmentState>;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldValuesAttachmentState>;
+    assetProcedureTypeAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeAttachmentState>;
     assetProcedureStepFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldsAttachmentState>;
     assetProcedureStepFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldsState>;
     assetProcedureStepFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldValuesAttachmentState>;
     assetProcedureStepFieldValuesReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldValuesState>;
     assetProcedureStepReducer: import('redux').Reducer<import('./slices').AssetProcedureStepState>;
     teamMembershipReducer: import('redux').Reducer<import('./slices').TeamMembershipState>;
+    workflowTypeReducer: import('redux').Reducer<import('./slices').WorkflowTypeState>;
+    workflowStepReducer: import('redux').Reducer<import('./slices').WorkflowStepState>;
+    workflowStepFieldsReducer: import('redux').Reducer<import('./slices').WorkflowStepFieldsState>;
+    workflowStepFieldsAttachmentReducer: import('redux').Reducer<import('./slices').WorkflowStepFieldsAttachmentState>;
+    workflowReducer: import('redux').Reducer<import('./slices').WorkflowState>;
+    workflowStepAssigneeReducer: import('redux').Reducer<import('./slices').WorkflowStepAssigneeState>;
+    workflowStepCommentReducer: import('redux').Reducer<import('./slices').WorkflowStepCommentState>;
+    workflowStepEventReducer: import('redux').Reducer<import('./slices').WorkflowStepEventState>;
+    workflowStepFieldValuesReducer: import('redux').Reducer<import('./slices').WorkflowStepFieldValuesState>;
+    workflowStepFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').WorkflowStepFieldValuesAttachmentState>;
+    workflowStepFieldValuesReviewReducer: import('redux').Reducer<import('./slices').WorkflowStepFieldValuesReviewState>;
+    workflowStepFieldValuesReviewRequestReducer: import('redux').Reducer<import('./slices').WorkflowStepFieldValuesReviewRequestState>;
+    workflowStepReviewerReducer: import('redux').Reducer<import('./slices').WorkflowStepReviewerState>;
     outboxReducer: import('redux').Reducer<import('./slices').OutboxState>;
     fileReducer: import('redux').Reducer<import('./slices').FileState>;
     authReducer: import('redux').Reducer<import('./slices').AuthState>;
 };
 export declare const overmapReducer: import('redux').Reducer<{
     versioning: import('./slices').VersioningState;
-    categoryReducer: import('./slices').CategoryState;
     assetReducer: import('./slices').AssetState;
     assetAttachmentReducer: import('./slices').AssetAttachmentState;
     assetStageCompletionReducer: import('./slices').AssetStageCompletionState;
@@ -98,6 +117,8 @@ export declare const overmapReducer: import('redux').Reducer<{
     formRevisionAttachmentReducer: import('./slices').FormRevisionAttachmentState;
     formSubmissionAttachmentReducer: import('./slices').FormSubmissionAttachmentState;
     formSubmissionReducer: import('./slices').FormSubmissionState;
+    formIdentifierReducer: import('./slices').FormIdentifierState;
+    formIdentifierValueReducer: import('./slices').FormIdentifierValueState;
     userReducer: import('./slices').UserState;
     emailDomainsReducer: import('./slices').EmailDomainState;
     documentsReducer: import('./slices').DocumentState;
@@ -113,29 +134,47 @@ export declare const overmapReducer: import('redux').Reducer<{
     issueTypeFieldValuesReducer: import('./slices').IssueTypeFieldValuesState;
     issueTypeFieldsAttachmentReducer: import('./slices').IssueTypeFieldsAttachmentState;
     issueTypeFieldValuesAttachmentReducer: import('./slices').IssueTypeFieldValuesAttachmentState;
+    issueTypeIdentifierReducer: import('./slices').IssueTypeIdentifierState;
+    issueTypeIdentifierValueReducer: import('./slices').IssueTypeIdentifierValueState;
+    issueTypeStatusReducer: import('./slices').IssueTypeStatusState;
     assetTypeFieldsReducer: import('./slices').AssetTypeFieldsState;
     assetTypeFieldValuesReducer: import('./slices').AssetTypeFieldValuesState;
     assetTypeFieldsAttachmentReducer: import('./slices').AssetTypeFieldsAttachmentState;
     assetTypeFieldValuesAttachmentReducer: import('./slices').AssetTypeFieldValuesAttachmentState;
+    assetTypeIdentifierReducer: import('./slices').AssetTypeIdentifierState;
+    assetTypeIdentifierValueReducer: import('./slices').AssetTypeIdentifierValueState;
+    assetTypeStatusReducer: import('./slices').AssetTypeStatusState;
+    assetProcedureTypeReducer: import('./slices').AssetProcedureTypeState;
     assetProcedureReducer: import('./slices').AssetProcedureState;
-    assetProcedureInstanceReducer: import('./slices').AssetProcedureInstanceState;
-    assetProcedureFieldsReducer: import('./slices').AssetProcedureFieldsState;
-    assetProcedureFieldValuesReducer: import('./slices').AssetProcedureFieldValuesState;
-    assetProcedureFieldsAttachmentReducer: import('./slices').AssetProcedureFieldsAttachmentState;
-    assetProcedureFieldValuesAttachmentReducer: import('./slices').AssetProcedureFieldValuesAttachmentState;
-    assetProcedureAttachmentReducer: import('./slices').AssetProcedureAttachmentState;
+    assetProcedureTypeFieldsReducer: import('./slices').AssetProcedureTypeFieldsState;
+    assetProcedureTypeFieldValuesReducer: import('./slices').AssetProcedureTypeFieldValuesState;
+    assetProcedureTypeFieldsAttachmentReducer: import('./slices').AssetProcedureTypeFieldsAttachmentState;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('./slices').AssetProcedureTypeFieldValuesAttachmentState;
+    assetProcedureTypeAttachmentReducer: import('./slices').AssetProcedureTypeAttachmentState;
     assetProcedureStepFieldsAttachmentReducer: import('./slices').AssetProcedureStepFieldsAttachmentState;
     assetProcedureStepFieldsReducer: import('./slices').AssetProcedureStepFieldsState;
     assetProcedureStepFieldValuesAttachmentReducer: import('./slices').AssetProcedureStepFieldValuesAttachmentState;
     assetProcedureStepFieldValuesReducer: import('./slices').AssetProcedureStepFieldValuesState;
     assetProcedureStepReducer: import('./slices').AssetProcedureStepState;
     teamMembershipReducer: import('./slices').TeamMembershipState;
+    workflowTypeReducer: import('./slices').WorkflowTypeState;
+    workflowStepReducer: import('./slices').WorkflowStepState;
+    workflowStepFieldsReducer: import('./slices').WorkflowStepFieldsState;
+    workflowStepFieldsAttachmentReducer: import('./slices').WorkflowStepFieldsAttachmentState;
+    workflowReducer: import('./slices').WorkflowState;
+    workflowStepAssigneeReducer: import('./slices').WorkflowStepAssigneeState;
+    workflowStepCommentReducer: import('./slices').WorkflowStepCommentState;
+    workflowStepEventReducer: import('./slices').WorkflowStepEventState;
+    workflowStepFieldValuesReducer: import('./slices').WorkflowStepFieldValuesState;
+    workflowStepFieldValuesAttachmentReducer: import('./slices').WorkflowStepFieldValuesAttachmentState;
+    workflowStepFieldValuesReviewReducer: import('./slices').WorkflowStepFieldValuesReviewState;
+    workflowStepFieldValuesReviewRequestReducer: import('./slices').WorkflowStepFieldValuesReviewRequestState;
+    workflowStepReviewerReducer: import('./slices').WorkflowStepReviewerState;
     outboxReducer: import('./slices').OutboxState;
     fileReducer: import('./slices').FileState;
     authReducer: import('./slices').AuthState;
 }, import('redux').UnknownAction, Partial<{
     versioning: import('./slices').VersioningState | undefined;
-    categoryReducer: import('./slices').CategoryState | undefined;
     assetReducer: import('./slices').AssetState | undefined;
     assetAttachmentReducer: import('./slices').AssetAttachmentState | undefined;
     assetStageCompletionReducer: import('./slices').AssetStageCompletionState | undefined;
@@ -158,6 +197,8 @@ export declare const overmapReducer: import('redux').Reducer<{
     formRevisionAttachmentReducer: import('./slices').FormRevisionAttachmentState | undefined;
     formSubmissionAttachmentReducer: import('./slices').FormSubmissionAttachmentState | undefined;
     formSubmissionReducer: import('./slices').FormSubmissionState | undefined;
+    formIdentifierReducer: import('./slices').FormIdentifierState | undefined;
+    formIdentifierValueReducer: import('./slices').FormIdentifierValueState | undefined;
     userReducer: import('./slices').UserState | undefined;
     emailDomainsReducer: import('./slices').EmailDomainState | undefined;
     documentsReducer: import('./slices').DocumentState | undefined;
@@ -173,23 +214,42 @@ export declare const overmapReducer: import('redux').Reducer<{
     issueTypeFieldValuesReducer: import('./slices').IssueTypeFieldValuesState | undefined;
     issueTypeFieldsAttachmentReducer: import('./slices').IssueTypeFieldsAttachmentState | undefined;
     issueTypeFieldValuesAttachmentReducer: import('./slices').IssueTypeFieldValuesAttachmentState | undefined;
+    issueTypeIdentifierReducer: import('./slices').IssueTypeIdentifierState | undefined;
+    issueTypeIdentifierValueReducer: import('./slices').IssueTypeIdentifierValueState | undefined;
+    issueTypeStatusReducer: import('./slices').IssueTypeStatusState | undefined;
     assetTypeFieldsReducer: import('./slices').AssetTypeFieldsState | undefined;
     assetTypeFieldValuesReducer: import('./slices').AssetTypeFieldValuesState | undefined;
     assetTypeFieldsAttachmentReducer: import('./slices').AssetTypeFieldsAttachmentState | undefined;
     assetTypeFieldValuesAttachmentReducer: import('./slices').AssetTypeFieldValuesAttachmentState | undefined;
+    assetTypeIdentifierReducer: import('./slices').AssetTypeIdentifierState | undefined;
+    assetTypeIdentifierValueReducer: import('./slices').AssetTypeIdentifierValueState | undefined;
+    assetTypeStatusReducer: import('./slices').AssetTypeStatusState | undefined;
+    assetProcedureTypeReducer: import('./slices').AssetProcedureTypeState | undefined;
     assetProcedureReducer: import('./slices').AssetProcedureState | undefined;
-    assetProcedureInstanceReducer: import('./slices').AssetProcedureInstanceState | undefined;
-    assetProcedureFieldsReducer: import('./slices').AssetProcedureFieldsState | undefined;
-    assetProcedureFieldValuesReducer: import('./slices').AssetProcedureFieldValuesState | undefined;
-    assetProcedureFieldsAttachmentReducer: import('./slices').AssetProcedureFieldsAttachmentState | undefined;
-    assetProcedureFieldValuesAttachmentReducer: import('./slices').AssetProcedureFieldValuesAttachmentState | undefined;
-    assetProcedureAttachmentReducer: import('./slices').AssetProcedureAttachmentState | undefined;
+    assetProcedureTypeFieldsReducer: import('./slices').AssetProcedureTypeFieldsState | undefined;
+    assetProcedureTypeFieldValuesReducer: import('./slices').AssetProcedureTypeFieldValuesState | undefined;
+    assetProcedureTypeFieldsAttachmentReducer: import('./slices').AssetProcedureTypeFieldsAttachmentState | undefined;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('./slices').AssetProcedureTypeFieldValuesAttachmentState | undefined;
+    assetProcedureTypeAttachmentReducer: import('./slices').AssetProcedureTypeAttachmentState | undefined;
     assetProcedureStepFieldsAttachmentReducer: import('./slices').AssetProcedureStepFieldsAttachmentState | undefined;
     assetProcedureStepFieldsReducer: import('./slices').AssetProcedureStepFieldsState | undefined;
     assetProcedureStepFieldValuesAttachmentReducer: import('./slices').AssetProcedureStepFieldValuesAttachmentState | undefined;
     assetProcedureStepFieldValuesReducer: import('./slices').AssetProcedureStepFieldValuesState | undefined;
     assetProcedureStepReducer: import('./slices').AssetProcedureStepState | undefined;
     teamMembershipReducer: import('./slices').TeamMembershipState | undefined;
+    workflowTypeReducer: import('./slices').WorkflowTypeState | undefined;
+    workflowStepReducer: import('./slices').WorkflowStepState | undefined;
+    workflowStepFieldsReducer: import('./slices').WorkflowStepFieldsState | undefined;
+    workflowStepFieldsAttachmentReducer: import('./slices').WorkflowStepFieldsAttachmentState | undefined;
+    workflowReducer: import('./slices').WorkflowState | undefined;
+    workflowStepAssigneeReducer: import('./slices').WorkflowStepAssigneeState | undefined;
+    workflowStepCommentReducer: import('./slices').WorkflowStepCommentState | undefined;
+    workflowStepEventReducer: import('./slices').WorkflowStepEventState | undefined;
+    workflowStepFieldValuesReducer: import('./slices').WorkflowStepFieldValuesState | undefined;
+    workflowStepFieldValuesAttachmentReducer: import('./slices').WorkflowStepFieldValuesAttachmentState | undefined;
+    workflowStepFieldValuesReviewReducer: import('./slices').WorkflowStepFieldValuesReviewState | undefined;
+    workflowStepFieldValuesReviewRequestReducer: import('./slices').WorkflowStepFieldValuesReviewRequestState | undefined;
+    workflowStepReviewerReducer: import('./slices').WorkflowStepReviewerState | undefined;
     outboxReducer: import('./slices').OutboxState | undefined;
     fileReducer: import('./slices').FileState | undefined;
     authReducer: import('./slices').AuthState | undefined;

package/dist/store/selectors/index.d.ts

@@ -1,2 +1,3 @@
 export * from './hooks';
 export * from './SelectorBuilder';
+export * from './utils';

package/dist/store/selectors/utils.d.ts

@@ -0,0 +1 @@
+export declare const restructureSelectorWithArgs: <TState, TArgs extends any[], TRet>(selector: (state: TState, ...args: TArgs) => TRet) => (...args: TArgs) => (state: TState) => TRet;

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

@@ -1,47 +1,20 @@
 import { AgentUserConversation } from '../../typings';
-import { ModelState } from '../adapters';
 import { OvermapRootState, OvermapSelector } from '../typings';
+import { ModelState } from '../adapters';
 export type AgentsState = ModelState<AgentUserConversation["uuid"], AgentUserConversation>;
 export declare const agentsSlice: import('@reduxjs/toolkit').Slice<AgentsState, {
-    initializeConversations: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation[];
-        type: string;
-    }) => void;
-    addConversation: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation;
-        type: string;
-    }) => void;
-    addConversations: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation[];
-        type: string;
-    }) => void;
-    setConversation: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation;
-        type: string;
-    }) => void;
-    setConversations: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation[];
-        type: string;
-    }) => void;
-    updateConversation: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation;
-        type: string;
-    }) => void;
-    updateConversations: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: AgentUserConversation[];
-        type: string;
-    }) => void;
-    deleteConversation: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteConversations: (state: ModelState<string, AgentUserConversation>, action: {
-        payload: string[];
-        type: string;
-    }) => void;
+    initializeConversations: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').InitializePayloadAction<AgentUserConversation>>;
+    addConversation: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').AddOnePayloadAction<AgentUserConversation>>;
+    addConversations: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').AddManyPayloadAction<AgentUserConversation>>;
+    setConversation: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').SetOnePayloadAction<AgentUserConversation>>;
+    setConversations: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').SetManyPayloadAction<AgentUserConversation>>;
+    updateConversation: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').UpdateOnePayloadAction<AgentUserConversation>>;
+    updateConversations: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').UpdateManyPayloadAction<AgentUserConversation>>;
+    deleteConversation: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').DeleteOnePayloadAction<string>>;
+    deleteConversations: import('@reduxjs/toolkit').CaseReducer<AgentsState, import('..').DeleteManyPayloadAction<string>>;
 }, "agents", "agents", import('@reduxjs/toolkit').SliceSelectors<AgentsState>>;
 export declare const initializeConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/initializeConversations">, addConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, addConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/addConversations">, setConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, setConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/setConversations">, updateConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/updateConversation">, updateConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/updateConversations">, deleteConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "agents/deleteConversation">, deleteConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "agents/deleteConversations">;
 export declare const selectConversationMapping: (state: OvermapRootState) => Record<string, AgentUserConversation>;
 export declare const selectConversations: OvermapSelector<AgentUserConversation[]>;
-export declare const selectConversation: (args: string) => (state: OvermapRootState) => AgentUserConversation | undefined;
+export declare const selectConversation: (conversationId: string) => (state: any) => AgentUserConversation | undefined;
 export declare const agentsReducer: import('redux').Reducer<AgentsState>;

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

@@ -1,48 +1,22 @@
 import { Asset, AssetAttachment, Stored } from '../../typings';
-import { ModelState } from '../adapters';
 import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+import { ModelState } from '../adapters';
 export type AssetAttachmentState = ModelState<AssetAttachment["uuid"], Stored<AssetAttachment>>;
 export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetAttachmentState, {
-    initializeAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>[];
-        type: string;
-    }) => void;
-    addAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>;
-        type: string;
-    }) => void;
-    addAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>[];
-        type: string;
-    }) => void;
-    setAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>;
-        type: string;
-    }) => void;
-    setAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>[];
-        type: string;
-    }) => void;
-    updateAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>;
-        type: string;
-    }) => void;
-    updateAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: Stored<AssetAttachment>[];
-        type: string;
-    }) => void;
-    deleteAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
-        payload: string[];
-        type: string;
-    }) => void;
+    initializeAssetAttachments: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').InitializePayloadAction<Stored<AssetAttachment>>>;
+    addAssetAttachment: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').AddOnePayloadAction<Stored<AssetAttachment>>>;
+    addAssetAttachments: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').AddManyPayloadAction<Stored<AssetAttachment>>>;
+    setAssetAttachment: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').SetOnePayloadAction<Stored<AssetAttachment>>>;
+    setAssetAttachments: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').SetManyPayloadAction<Stored<AssetAttachment>>>;
+    updateAssetAttachment: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').UpdateOnePayloadAction<Stored<AssetAttachment>>>;
+    updateAssetAttachments: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').UpdateManyPayloadAction<Stored<AssetAttachment>>>;
+    deleteAssetAttachment: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').DeleteOnePayloadAction<string>>;
+    deleteAssetAttachments: import('@reduxjs/toolkit').CaseReducer<AssetAttachmentState, import('..').DeleteManyPayloadAction<string>>;
 }, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetAttachmentState>>;
 export declare const initializeAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">, addAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/addAssetAttachment">, addAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">, setAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">, setAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/setAssetAttachments">, updateAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/updateAssetAttachment">, updateAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">, deleteAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">, deleteAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
 export declare const selectAssetAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetAttachment>>;
 export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
 export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<AssetAttachment["uuid"], Stored<AssetAttachment> | undefined>;
+export declare const selectAssetAttachmentsByIds: (uuids: string[]) => (state: any) => Stored<AssetAttachment>[];
 export declare const selectAttachmentsOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<AssetAttachment>[]>;
 export declare const assetAttachmentReducer: import('redux').Reducer<AssetAttachmentState>;

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

@@ -1,49 +1,125 @@
-import { AssetProcedure, Organization, Stored } from '../../typings';
+import { AssetProcedureType, AssetProcedure, AssetType, Stored } from '../../typings';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
 import { ModelState } from '../adapters';
-import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
 export type AssetProcedureState = ModelState<AssetProcedure["uuid"], Stored<AssetProcedure>>;
 export declare const assetProcedureSlice: import('@reduxjs/toolkit').Slice<AssetProcedureState, {
-    initializeAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>[];
-        type: string;
-    }) => void;
-    addAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>;
-        type: string;
-    }) => void;
-    addAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>[];
-        type: string;
-    }) => void;
-    setAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>;
-        type: string;
-    }) => void;
-    setAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>[];
-        type: string;
-    }) => void;
-    updateAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>;
-        type: string;
-    }) => void;
-    updateAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: Stored<AssetProcedure>[];
-        type: string;
-    }) => void;
-    deleteAssetProcedure: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetProcedures: (state: ModelState<string, Stored<AssetProcedure>>, action: {
-        payload: string[];
-        type: string;
-    }) => void;
+    initializeAssetProcedures: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').InitializePayloadAction<Stored<AssetProcedure>>>;
+    addAssetProcedure: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').AddOnePayloadAction<Stored<AssetProcedure>>>;
+    addAssetProcedures: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').AddManyPayloadAction<Stored<AssetProcedure>>>;
+    setAssetProcedure: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').SetOnePayloadAction<Stored<AssetProcedure>>>;
+    setAssetProcedures: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').SetManyPayloadAction<Stored<AssetProcedure>>>;
+    updateAssetProcedure: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').UpdateOnePayloadAction<Stored<AssetProcedure>>>;
+    updateAssetProcedures: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').UpdateManyPayloadAction<Stored<AssetProcedure>>>;
+    deleteAssetProcedure: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').DeleteOnePayloadAction<string>>;
+    deleteAssetProcedures: import('@reduxjs/toolkit').CaseReducer<AssetProcedureState, import('..').DeleteManyPayloadAction<string>>;
 }, "assetProcedures", "assetProcedures", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureState>>;
 export declare const initializeAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/initializeAssetProcedures">, addAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/addAssetProcedure">, addAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/addAssetProcedures">, updateAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/updateAssetProcedure">, updateAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/updateAssetProcedures">, deleteAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedures/deleteAssetProcedure">, deleteAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedures/deleteAssetProcedures">, setAssetProcedure: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/setAssetProcedure">, setAssetProcedures: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/setAssetProcedures">;
 export declare const assetProcedureReducer: import('redux').Reducer<AssetProcedureState>;
 export declare const selectAssetProceduresMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedure>>;
-export declare const selectAssetProcedures: OvermapSelector<Stored<AssetProcedure>[]>;
+export declare const selectAssetProcedures: ((state: {
+    versioning: import('./versioningSlice').VersioningState;
+    assetReducer: import('./assetSlice').AssetState;
+    assetAttachmentReducer: import('./assetAttachmentSlice').AssetAttachmentState;
+    assetStageCompletionReducer: import('./assetStageCompletionSlice').AssetStageCompletionState;
+    assetStageReducer: import('./assetStageSlice').AssetStageState;
+    assetTypeReducer: import('./assetTypeSlice').AssetTypeState;
+    assetTypeAttachmentReducer: import('./assetTypeAttachmentSlice').AssetTypeAttachmentState;
+    issueReducer: import('./issueSlice').IssueState;
+    issueAttachmentReducer: import('./issueAttachmentSlice').IssueAttachmentState;
+    issueTypeReducer: import('./issueTypeSlice').IssueTypeState;
+    issueTypeAttachmentReducer: import('./issueTypeAttachmentSlice').IssueTypeAttachmentState;
+    organizationReducer: import('./organizationSlice').OrganizationState;
+    projectReducer: import('./projectSlice').ProjectState;
+    projectAttachmentReducer: import('./projectAttachmentSlice').ProjectAttachmentState;
+    projectAccessReducer: import('./projectAccessSlice').ProjectAccessState;
+    organizationAccessReducer: import('./organizationAccessSlice').OrganizationAccessState;
+    projectFileReducer: import('./projectFileSlice').ProjectFileState;
+    rehydratedReducer: import('./rehydratedSlice').RehydratedState;
+    formReducer: import('./formSlice').FormState;
+    formRevisionReducer: import('./formRevisionSlice').FormRevisionState;
+    formRevisionAttachmentReducer: import('./formRevisionAttachmentSlice').FormRevisionAttachmentState;
+    formSubmissionAttachmentReducer: import('./formSubmissionAttachmentSlice').FormSubmissionAttachmentState;
+    formSubmissionReducer: import('./formSubmissionSlice').FormSubmissionState;
+    formIdentifierReducer: import('./formIdentifierSlice').FormIdentifierState;
+    formIdentifierValueReducer: import('./formIdentifierValueSlice').FormIdentifierValueState;
+    userReducer: import('./userSlice').UserState;
+    emailDomainsReducer: import('./emailDomainsSlice').EmailDomainState;
+    documentsReducer: import('./documentSlice').DocumentState;
+    documentAttachmentReducer: import('./documentAttachmentSlice').DocumentAttachmentState;
+    teamReducer: import('./teamSlice').TeamState;
+    agentsReducer: import('./agentsSlice').AgentsState;
+    issueCommentReducer: import('./issueCommentSlice').IssueCommentState;
+    issueCommentAttachmentReducer: import('./issueCommentAttachmentSlice').IssueCommentAttachmentState;
+    issueUpdateReducer: import('./issueUpdateSlice').IssueUpdateState;
+    geoImageReducer: import('./geoImageSlice').GeoImageSliceState;
+    issueAssociationReducer: import('./issueAssociationSlice').IssueAssociationSliceState;
+    issueTypeFieldsReducer: import('./issueTypeFieldsSlice').IssueTypeFieldsState;
+    issueTypeFieldValuesReducer: import('./issueTypeFieldValuesSlice').IssueTypeFieldValuesState;
+    issueTypeFieldsAttachmentReducer: import('./issueTypeFieldsAttachmentSlice').IssueTypeFieldsAttachmentState;
+    issueTypeFieldValuesAttachmentReducer: import('./issueTypeFieldValuesAttachmentSlice').IssueTypeFieldValuesAttachmentState;
+    issueTypeIdentifierReducer: import('./issueTypeIdentifierSlice').IssueTypeIdentifierState;
+    issueTypeIdentifierValueReducer: import('./issueTypeIdentifierValueSlice').IssueTypeIdentifierValueState;
+    issueTypeStatusReducer: import('./issueTypeStatusSlice').IssueTypeStatusState;
+    assetTypeFieldsReducer: import('./assetTypeFieldsSlice').AssetTypeFieldsState;
+    assetTypeFieldValuesReducer: import('./assetTypeFieldValuesSlice').AssetTypeFieldValuesState;
+    assetTypeFieldsAttachmentReducer: import('./assetTypeFieldsAttachmentSlice').AssetTypeFieldsAttachmentState;
+    assetTypeFieldValuesAttachmentReducer: import('./assetTypeFieldValuesAttachmentSlice').AssetTypeFieldValuesAttachmentState;
+    assetTypeIdentifierReducer: import('./assetTypeIdentifierSlice').AssetTypeIdentifierState;
+    assetTypeIdentifierValueReducer: import('./assetTypeIdentifierValueSlice').AssetTypeIdentifierValueState;
+    assetTypeStatusReducer: import('./assetTypeStatusSlice').AssetTypeStatusState;
+    assetProcedureTypeReducer: import('./assetProcedureTypeSlice').AssetProcedureTypeState;
+    assetProcedureReducer: AssetProcedureState;
+    assetProcedureTypeFieldsReducer: import('./assetProcedureTypeFieldsSlice').AssetProcedureTypeFieldsState;
+    assetProcedureTypeFieldValuesReducer: import('./assetProcedureTypeFieldValuesSlice').AssetProcedureTypeFieldValuesState;
+    assetProcedureTypeFieldsAttachmentReducer: import('./assetProcedureTypeFieldsAttachmentSlice').AssetProcedureTypeFieldsAttachmentState;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('./assetProcedureTypeFieldValuesAttachmentSlice').AssetProcedureTypeFieldValuesAttachmentState;
+    assetProcedureTypeAttachmentReducer: import('./assetProcedureTypeAttachmentSlice').AssetProcedureTypeAttachmentState;
+    assetProcedureStepFieldsAttachmentReducer: import('./assetProcedureStepFieldsAttachmentSlice').AssetProcedureStepFieldsAttachmentState;
+    assetProcedureStepFieldsReducer: import('./assetProcedureStepFieldsSlice').AssetProcedureStepFieldsState;
+    assetProcedureStepFieldValuesAttachmentReducer: import('./assetProcedureStepFieldValuesAttachmentSlice').AssetProcedureStepFieldValuesAttachmentState;
+    assetProcedureStepFieldValuesReducer: import('./assetProcedureStepFieldValuesSlice').AssetProcedureStepFieldValuesState;
+    assetProcedureStepReducer: import('./assetProcedureStepSlice').AssetProcedureStepState;
+    teamMembershipReducer: import('./teamMembershipSlice').TeamMembershipState;
+    workflowTypeReducer: import('./workflowTypeSlice').WorkflowTypeState;
+    workflowStepReducer: import('./workflowStepSlice').WorkflowStepState;
+    workflowStepFieldsReducer: import('./workflowStepFieldsSlice').WorkflowStepFieldsState;
+    workflowStepFieldsAttachmentReducer: import('./workflowStepFieldsAttachmentSlice').WorkflowStepFieldsAttachmentState;
+    workflowReducer: import('./workflowSlice').WorkflowState;
+    workflowStepAssigneeReducer: import('./workflowStepAssigneeSlice').WorkflowStepAssigneeState;
+    workflowStepCommentReducer: import('./workflowStepCommentSlice').WorkflowStepCommentState;
+    workflowStepEventReducer: import('./workflowStepEventSlice').WorkflowStepEventState;
+    workflowStepFieldValuesReducer: import('./workflowStepFieldValuesSlice').WorkflowStepFieldValuesState;
+    workflowStepFieldValuesAttachmentReducer: import('./workflowStepFieldValuesAttachmentSlice').WorkflowStepFieldValuesAttachmentState;
+    workflowStepFieldValuesReviewReducer: import('./workflowStepFieldValuesReviewSlice').WorkflowStepFieldValuesReviewState;
+    workflowStepFieldValuesReviewRequestReducer: import('./workflowStepFieldValuesReviewRequestSlice').WorkflowStepFieldValuesReviewRequestState;
+    workflowStepReviewerReducer: import('./workflowStepReviewerSlice').WorkflowStepReviewerState;
+    outboxReducer: import('./outboxSlice').OutboxState;
+    fileReducer: import('./fileSlice').FileState;
+    authReducer: import('./authSlice').AuthState;
+} & {
+    offline: import('@redux-offline/redux-offline/lib/types').OfflineState;
+}) => Stored<AssetProcedure>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedure>>) => Stored<AssetProcedure>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedure>>) => Stored<AssetProcedure>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedure>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedure>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProceduresOfAssetProcedureType: OvermapSelectorWithArgs<AssetProcedureType["uuid"], Stored<AssetProcedure>[]>;
+export declare const selectAssetProceduresOfAssetType: OvermapSelectorWithArgs<AssetType["uuid"], Stored<AssetProcedure>[]>;
 export declare const selectAssetProcedureById: OvermapSelectorWithArgs<AssetProcedure["uuid"], Stored<AssetProcedure> | undefined>;
-export declare const selectAssetProceduresByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedure>[];
-export declare const selectAssetProceduresOfOrganization: OvermapSelectorWithArgs<Organization["uuid"], Stored<AssetProcedure>[]>;
+export declare const selectAssetProceduresByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedure>[];