@overmap-ai/core 1.0.71-mapbox.5 → 1.0.71-mapbox.7

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

@@ -1,34 +1,45 @@
-export * from "./JWTAuthService";
-export * from "./BaseApiService";
-export * from "./CategoryService";
-export * from "./AssetService";
-export * from "./AssetStageCompletionService";
-export * from "./AssetStageService";
-export * from "./AssetAttachmentService";
-export * from "./AssetTypeService";
-export * from "./AssetTypeAttachmentService";
-export * from "./IssueCommentService";
-export * from "./IssueUpdateService";
-export * from "./IssueAttachmentService";
-export * from "./IssueService";
-export * from "./IssueTypeService";
-export * from "./ProjectAccessService";
-export * from "./ProjectFileService";
-export * from "./ProjectAttachmentService";
-export * from "./ProjectService";
-export * from "./FormService";
-export * from "./FormSubmissionService";
-export * from "./WorkspaceService";
-export * from "./OrganizationAccessService";
-export * from "./FileService";
-export * from "./EmailVerificationService";
-export * from "./EmailDomainsService";
-export * from "./OrganizationService";
-export * from "./LicenseService";
-export * from "./DocumentService";
-export * from "./DocumentAttachmentService";
-export * from "./AgentService";
-export * from "./TeamService";
-export * from "./UserService";
-export * from "./GeoImageService";
-export * from "./IssueAssociationService";
+export * from './JWTAuthService';
+export * from './BaseApiService';
+export * from './CategoryService';
+export * from './AssetService';
+export * from './AssetStageCompletionService';
+export * from './AssetStageService';
+export * from './AssetAttachmentService';
+export * from './AssetTypeService';
+export * from './AssetTypeAttachmentService';
+export * from './IssueCommentService';
+export * from './IssueUpdateService';
+export * from './IssueAttachmentService';
+export * from './IssueService';
+export * from './IssueTypeService';
+export * from './ProjectAccessService';
+export * from './ProjectFileService';
+export * from './ProjectAttachmentService';
+export * from './ProjectService';
+export * from './FormService';
+export * from './FormSubmissionService';
+export * from './WorkspaceService';
+export * from './OrganizationAccessService';
+export * from './FileService';
+export * from './EmailVerificationService';
+export * from './EmailDomainsService';
+export * from './OrganizationService';
+export * from './LicenseService';
+export * from './DocumentService';
+export * from './DocumentAttachmentService';
+export * from './AgentService';
+export * from './TeamService';
+export * from './UserService';
+export * from './GeoImageService';
+export * from './IssueAssociationService';
+export * from './FormRevisionAttachmentService';
+export * from './FormSubmissionAttachmentService';
+export * from './FormRevisionService';
+export * from './AssetTypeFieldsAttachmentService';
+export * from './AssetTypeFieldsService';
+export * from './AssetTypeFieldValuesService';
+export * from './AssetTypeFieldValuesAttachmentService';
+export * from './IssueTypeFieldsAttachmentService';
+export * from './IssueTypeFieldsService';
+export * from './IssueTypeFieldValuesAttachmentService';
+export * from './IssueTypeFieldValuesService';

package/dist/sdk/typings.d.ts

@@ -1,11 +1,12 @@
-import request from "superagent";
-import { ToolkitStore } from "@reduxjs/toolkit/dist/configureStore";
-import { HttpMethod } from "../enums";
-import { BaseState, Created, Model, Stored, Submitted } from "../typings";
-import { DeferredPromise } from "../utils";
-import { GetS3UrlResponse, GetS3UrlSuccessResponse } from "./services";
-import { BaseSDK } from "./base";
-export type OvermapSDKConstructor<TState extends BaseState, TSDK extends BaseSDK<TState>> = new (store: ToolkitStore<TState>) => TSDK;
+import { default as request } from 'superagent';
+import { HttpMethod } from '../enums';
+import { BaseState, Created, Model, Stored, Submitted } from '../typings';
+import { DeferredPromise } from '../utils';
+import { GetS3UrlResponse, GetS3UrlSuccessResponse } from './services';
+import { BaseSDK } from './base';
+import { Store } from '@reduxjs/toolkit';
+
+export type OvermapSDKConstructor<TState extends BaseState, TSDK extends BaseSDK<TState>> = new (store: Store<TState>) => TSDK;
 export interface TokenPair {
     accessToken: string;
     refreshToken: string;

package/dist/store/adapter.d.ts

@@ -1,15 +1,16 @@
-import { PayloadAction } from "@reduxjs/toolkit";
-import type { ModelState } from "./typings";
+import { PayloadAction } from '@reduxjs/toolkit';
+import { ModelState } from './typings';
+
 export interface OvermapModelAdapter<TModel> {
-    addOne: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel>) => void;
-    addMany: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel[]>) => void;
-    setOne: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel>) => void;
-    setMany: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel[]>) => void;
-    updateOne: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel>) => void;
-    updateMany: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel[]>) => void;
-    deleteOne: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<string>) => void;
-    deleteMany: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<string[]>) => void;
-    initialize: <TState extends ModelState<TModel>>(state: TState, action: PayloadAction<TModel[]>) => void;
+    addOne: (state: ModelState<TModel>, action: PayloadAction<TModel>) => void;
+    addMany: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
+    setOne: (state: ModelState<TModel>, action: PayloadAction<TModel>) => void;
+    setMany: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
+    updateOne: (state: ModelState<TModel>, action: PayloadAction<TModel>) => void;
+    updateMany: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
+    deleteOne: (state: ModelState<TModel>, action: PayloadAction<string>) => void;
+    deleteMany: (state: ModelState<TModel>, action: PayloadAction<string[]>) => void;
+    initialize: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
     getInitialState: <TState extends object>(state: TState) => TState & ModelState<TModel>;
 }
 export declare function createModelAdapter<TModel>(computeModelId: (model: TModel) => string): OvermapModelAdapter<TModel>;

package/dist/store/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./store";
-export * from "./slices";
+export * from './store';
+export * from './slices';

package/dist/store/migrations.d.ts

@@ -1,2 +1,3 @@
-import type { Manifest } from "../typings";
+import { Manifest } from '../typings';
+
 export declare const manifest: Manifest;

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

@@ -1,26 +1,27 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AgentUserConversation, OvermapRootState, OvermapSelector } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AgentUserConversation, OvermapRootState, OvermapSelector } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AgentsState = ModelState<AgentUserConversation>;
-export declare const agentsSlice: import("@reduxjs/toolkit").Slice<ModelState<AgentUserConversation>, {
-    initializeConversations: <TState extends ModelState<AgentUserConversation>>(state: TState, action: {
+export declare const agentsSlice: import('@reduxjs/toolkit').Slice<ModelState<AgentUserConversation>, {
+    initializeConversations: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation[];
         type: string;
     }) => void;
-    addConversation: <TState_1 extends ModelState<AgentUserConversation>>(state: TState_1, action: {
+    addConversation: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-    setConversation: <TState_2 extends ModelState<AgentUserConversation>>(state: TState_2, action: {
+    setConversation: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-    updateConversation: <TState_3 extends ModelState<AgentUserConversation>>(state: TState_3, action: {
+    updateConversation: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-}, "agents">;
-export declare const initializeConversations: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation[], "agents/initializeConversations">, addConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, setConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, updateConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/updateConversation">;
+}, "agents", "agents", import('@reduxjs/toolkit').SliceSelectors<ModelState<AgentUserConversation>>>;
+export declare const initializeConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/initializeConversations">, addConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, setConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, updateConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/updateConversation">;
 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;

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

@@ -1,46 +1,41 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
-import type { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { ModelState } from '../typings';
+import { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+
 export type AssetAttachmentState = ModelState<Stored<AssetAttachment>>;
-export declare const assetAttachmentSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetAttachment>>, {
-    initializeAssetAttachments: <TState extends ModelState<Stored<AssetAttachment>>>(state: TState, action: {
+export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetAttachment>>, {
+    initializeAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    addAssetAttachment: <TState_1 extends ModelState<Stored<AssetAttachment>>>(state: TState_1, action: {
+    addAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    addAssetAttachments: <TState_2 extends ModelState<Stored<AssetAttachment>>>(state: TState_2, action: {
+    addAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    setAssetAttachment: <TState_3 extends ModelState<Stored<AssetAttachment>>>(state: TState_3, action: {
+    setAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    setAssetAttachments: <TState_4 extends ModelState<Stored<AssetAttachment>>>(state: TState_4, action: {
+    setAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    updateAssetAttachment: <TState_5 extends ModelState<Stored<AssetAttachment>>>(state: TState_5, action: {
+    updateAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    updateAssetAttachments: <TState_6 extends ModelState<Stored<AssetAttachment>>>(state: TState_6, action: {
+    updateAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    deleteAssetAttachment: <TState_7 extends ModelState<Stored<AssetAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetAttachments: <TState_8 extends ModelState<Stored<AssetAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetAttachments">;
-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">;
+    deleteAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetAttachment>>>>;
+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<string, Stored<AssetAttachment> | undefined>;

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

@@ -1,51 +1,62 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Asset, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Asset, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetState = ModelState<Stored<Asset>>;
-export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
-    initializeAssets: <TState extends ModelState<Stored<Asset>>>(state: TState, action: {
+export declare const assetSlice: import('@reduxjs/toolkit').Slice<AssetState, {
+    initializeAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    addAsset: <TState_1 extends ModelState<Stored<Asset>>>(state: TState_1, action: {
+    addAsset: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    addAssets: <TState_2 extends ModelState<Stored<Asset>>>(state: TState_2, action: {
+    addAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    setAsset: <TState_3 extends ModelState<Stored<Asset>>>(state: TState_3, action: {
+    setAsset: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    setAssets: <TState_4 extends ModelState<Stored<Asset>>>(state: TState_4, action: {
+    setAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    updateAsset: <TState_5 extends ModelState<Stored<Asset>>>(state: TState_5, action: {
+    updateAsset: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>;
         type: string;
     }) => void;
-    updateAssets: <TState_6 extends ModelState<Stored<Asset>>>(state: TState_6, action: {
+    updateAssets: (state: ModelState<Stored<Asset>>, action: {
         payload: Stored<Asset>[];
         type: string;
     }) => void;
-    deleteAsset: <TState_7 extends ModelState<Stored<Asset>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssets: <TState_8 extends ModelState<Stored<Asset>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assets">;
-export declare const initializeAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">, addAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">, addAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">, updateAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">, updateAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">, deleteAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/deleteAsset">, deleteAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assets/deleteAssets">, setAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">, setAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
+    deleteAsset: (state: ModelState<Stored<Asset>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssets: (state: ModelState<Stored<Asset>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assets", "assets", import('@reduxjs/toolkit').SliceSelectors<AssetState>>;
+export declare const initializeAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/initializeAssets">, addAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/addAsset">, addAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/addAssets">, updateAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/updateAsset">, updateAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/updateAssets">, deleteAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assets/deleteAsset">, deleteAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assets/deleteAssets">, setAsset: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>, "assets/setAsset">, setAssets: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Asset>[], "assets/setAssets">;
 export declare const selectAssetsMapping: (state: OvermapRootState) => Record<string, Stored<Asset>>;
-export declare const selectAssets: ((state: OvermapRootState) => Stored<Asset>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<Asset>>) => Stored<Asset>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectAssets: ((state: OvermapRootState) => Stored<Asset>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<Asset>>) => Stored<Asset>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<Asset>>) => Stored<Asset>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<Asset>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<Asset>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<string, Asset[]>;
 export declare const selectAssetById: OvermapSelectorWithArgs<string, Asset | undefined>;

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

@@ -1,43 +1,54 @@
-import { Reducer } from "@reduxjs/toolkit";
-import { AssetStageCompletion, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetStageCompletion, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetStageCompletionState = ModelState<AssetStageCompletion>;
-export declare const assetStageCompletionSlice: import("@reduxjs/toolkit").Slice<AssetStageCompletionState, {
-    initializeAssetStageCompletions: <TState extends ModelState<AssetStageCompletion>>(state: TState, action: {
+export declare const assetStageCompletionSlice: import('@reduxjs/toolkit').Slice<AssetStageCompletionState, {
+    initializeAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion[];
         type: string;
     }) => void;
-    addAssetStageCompletion: <TState_1 extends ModelState<AssetStageCompletion>>(state: TState_1, action: {
+    addAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion;
         type: string;
     }) => void;
-    addAssetStageCompletions: <TState_2 extends ModelState<AssetStageCompletion>>(state: TState_2, action: {
+    addAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion[];
         type: string;
     }) => void;
-    updateAssetStageCompletion: <TState_3 extends ModelState<AssetStageCompletion>>(state: TState_3, action: {
+    updateAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion;
         type: string;
     }) => void;
-    updateAssetStageCompletions: <TState_4 extends ModelState<AssetStageCompletion>>(state: TState_4, action: {
+    updateAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: {
         payload: AssetStageCompletion[];
         type: string;
     }) => void;
-    deleteAssetStageCompletion: <TState_5 extends ModelState<AssetStageCompletion>>(state: TState_5, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetStageCompletions: <TState_6 extends ModelState<AssetStageCompletion>>(state: TState_6, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetStageCompletions">;
-export declare const initializeAssetStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/initializeAssetStageCompletions">, addAssetStageCompletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/addAssetStageCompletion">, addAssetStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/addAssetStageCompletions">, updateAssetStageCompletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/updateAssetStageCompletion">, updateAssetStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/updateAssetStageCompletions">, deleteAssetStageCompletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetStageCompletions/deleteAssetStageCompletion">, deleteAssetStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetStageCompletions/deleteAssetStageCompletions">;
+    deleteAssetStageCompletion: (state: ModelState<AssetStageCompletion>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetStageCompletions: (state: ModelState<AssetStageCompletion>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetStageCompletions", "assetStageCompletions", import('@reduxjs/toolkit').SliceSelectors<AssetStageCompletionState>>;
+export declare const initializeAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/initializeAssetStageCompletions">, addAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/addAssetStageCompletion">, addAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/addAssetStageCompletions">, updateAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/updateAssetStageCompletion">, updateAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/updateAssetStageCompletions">, deleteAssetStageCompletion: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStageCompletions/deleteAssetStageCompletion">, deleteAssetStageCompletions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStageCompletions/deleteAssetStageCompletions">;
 export declare const selectAssetStageCompletionMapping: (state: OvermapRootState) => Record<string, AssetStageCompletion>;
-export declare const selectCompletedStagesByAsset: ((state: OvermapRootState) => Record<string, Record<string, string>>) & import("reselect").OutputSelectorFields<(args_0: Record<string, AssetStageCompletion>) => Record<string, Record<string, string>>, {
-    clearCache: () => void;
-}> & {
+export declare const selectCompletedStagesByAsset: ((state: OvermapRootState) => Record<string, Record<string, string>>) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, AssetStageCompletion>) => Record<string, Record<string, string>>;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, AssetStageCompletion>) => Record<string, Record<string, string>>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, Record<string, string>>;
+    dependencies: [(state: OvermapRootState) => Record<string, AssetStageCompletion>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectAssetStageCompletionById: OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;
 export declare const selectAssetStageCompletionsByIds: (args: string[]) => (state: OvermapRootState) => AssetStageCompletion[];

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

@@ -1,55 +1,65 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetStage, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetStageState = ModelState<Stored<AssetStage>>;
-export declare const assetStageSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetStage>>, {
-    initializeAssetStages: <TState extends ModelState<Stored<AssetStage>>>(state: TState, action: {
+export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetStage>>, {
+    initializeAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    setAssetStage: <TState_1 extends ModelState<Stored<AssetStage>>>(state: TState_1, action: {
+    setAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    setAssetStages: <TState_2 extends ModelState<Stored<AssetStage>>>(state: TState_2, action: {
+    setAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    addAssetStage: <TState_3 extends ModelState<Stored<AssetStage>>>(state: TState_3, action: {
+    addAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    addAssetStages: <TState_4 extends ModelState<Stored<AssetStage>>>(state: TState_4, action: {
+    addAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    updateAssetStage: <TState_5 extends ModelState<Stored<AssetStage>>>(state: TState_5, action: {
+    updateAssetStage: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>;
         type: string;
     }) => void;
-    updateAssetStages: <TState_6 extends ModelState<Stored<AssetStage>>>(state: TState_6, action: {
+    updateAssetStages: (state: ModelState<Stored<AssetStage>>, action: {
         payload: Stored<AssetStage>[];
         type: string;
     }) => void;
-    deleteAssetStage: <TState_7 extends ModelState<Stored<AssetStage>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetStages: <TState_8 extends ModelState<Stored<AssetStage>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetStages">;
-export declare const initializeAssetStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeAssetStages">, setAssetStage: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setAssetStage">, setAssetStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/setAssetStages">, addAssetStage: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/addAssetStage">, addAssetStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addAssetStages">, updateAssetStage: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateAssetStage">, updateAssetStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateAssetStages">, deleteAssetStage: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetStages/deleteAssetStage">, deleteAssetStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetStages/deleteAssetStages">;
+    deleteAssetStage: (state: ModelState<Stored<AssetStage>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetStages: (state: ModelState<Stored<AssetStage>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetStages", "assetStages", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetStage>>>>;
+export declare const initializeAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeAssetStages">, setAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setAssetStage">, setAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/setAssetStages">, addAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/addAssetStage">, addAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addAssetStages">, updateAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateAssetStage">, updateAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateAssetStages">, deleteAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStages/deleteAssetStage">, deleteAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStages/deleteAssetStages">;
 export declare const assetStageReducer: Reducer<AssetStageState>;
 export declare const selectStageMapping: OvermapSelector<Record<AssetStage["offline_id"], AssetStage>>;
 export declare const selectAssetStageById: OvermapSelectorWithArgs<string, AssetStage | undefined>;
-export declare const selectAssetStages: ((state: import('../../typings/models/store').OvermapRootState) => AssetStage[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, AssetStage>) => AssetStage[], {
-    clearCache: () => void;
-}> & {
+export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => AssetStage[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => AssetStage[];
+    dependencies: [OvermapSelector<Record<string, AssetStage>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectAssetTypeStagesMapping: OvermapSelectorWithArgs<string, Record<string, AssetStage>>;
 export declare const selectStagesOfAssetType: OvermapSelectorWithArgs<string, AssetStage[]>;
-export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../../typings/models/store').OvermapRootState) => Stored<AssetStage>[];
-export declare const selectStageFormIdsFromStageIds: OvermapSelectorWithArgs<string[], Record<string, string>>;
+export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../..').OvermapRootState) => Stored<AssetStage>[];

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

@@ -1,46 +1,41 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { AssetTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
 export type AssetTypeAttachmentState = ModelState<Stored<AssetTypeAttachment>>;
-export declare const assetTypeAttachmentSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetTypeAttachment>>, {
-    initializeAssetTypeAttachments: <TState extends ModelState<Stored<AssetTypeAttachment>>>(state: TState, action: {
+export declare const assetTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetTypeAttachment>>, {
+    initializeAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    addAssetTypeAttachment: <TState_1 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_1, action: {
+    addAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    addAssetTypeAttachments: <TState_2 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_2, action: {
+    addAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    setAssetTypeAttachment: <TState_3 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_3, action: {
+    setAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    setAssetTypeAttachments: <TState_4 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_4, action: {
+    setAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    updateAssetTypeAttachment: <TState_5 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_5, action: {
+    updateAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>;
         type: string;
     }) => void;
-    updateAssetTypeAttachments: <TState_6 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_6, action: {
+    updateAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: {
         payload: Stored<AssetTypeAttachment>[];
         type: string;
     }) => void;
-    deleteAssetTypeAttachment: <TState_7 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteAssetTypeAttachments: <TState_8 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "assetTypeAttachments">;
-export declare const initializeAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">, addAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/addAssetTypeAttachment">, addAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">, setAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">, setAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/setAssetTypeAttachments">, updateAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/updateAssetTypeAttachment">, updateAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">, deleteAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">, deleteAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
+    deleteAssetTypeAttachment: (state: ModelState<Stored<AssetTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeAttachments: (state: ModelState<Stored<AssetTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeAttachments", "assetTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetTypeAttachment>>>>;
+export declare const initializeAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">, addAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/addAssetTypeAttachment">, addAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">, setAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">, setAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/setAssetTypeAttachments">, updateAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/updateAssetTypeAttachment">, updateAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">, deleteAssetTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">, deleteAssetTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
 export declare const selectAssetTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeAttachment>>;
 export declare const selectAssetTypeAttachments: OvermapSelector<Stored<AssetTypeAttachment>[]>;
 export declare const selectAssetTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;