@overmap-ai/core 1.0.60-model-adapter.1 → 1.0.60-move-active-states.0

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

@@ -1,11 +1,12 @@
+import { OvermapRootState, ProjectAccess } from "../../typings";
 import { BaseApiService } from "./BaseApiService";
-import { ProjectAccess } from "../../typings";
+import type { BaseSDK } from "../base";
 /**
  * Handles the creation of ProjectAccess Service
  */
-export declare class ProjectAccessService extends BaseApiService {
+export declare abstract class ProjectAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     fetchAll(projectId: number): Promise<ProjectAccess[]>;
     update(projectAccess: ProjectAccess): Promise<ProjectAccess>;
     remove(projectAccess: ProjectAccess): Promise<undefined>;
-    refreshStore(): Promise<undefined>;
+    refreshStore(projectId: number): Promise<undefined>;
 }

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

@@ -1,7 +1,8 @@
 import { BaseAttachmentService } from "./BaseAttachmentService";
-import { AttachmentModel, ProjectAttachment, Stored } from "../../typings";
+import { AttachmentModel, OvermapRootState, ProjectAttachment, Stored } from "../../typings";
 import { OptimisticMultipleModelResult } from "../typings";
-export declare class ProjectAttachmentService extends BaseAttachmentService<number, ProjectAttachment> {
+import type { BaseSDK } from "../base";
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment> {
     attachmentModel: AttachmentModel;
     initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
     addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
@@ -9,7 +10,7 @@ export declare class ProjectAttachmentService extends BaseAttachmentService<numb
     removeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
     removeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
     setAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
-    selectAttachment: import('../../typings/store').SelectorWithArgs<string, ProjectAttachment>;
+    selectAttachment: import('../../typings/store').OvermapSelectorWithArgs<string, ProjectAttachment>;
     private buildOfflineAttachment;
     attachFilesToProject(files: File[], projectId: number): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
     deleteProjectAttachment(attachmentId: string): Promise<void>;

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

@@ -1,11 +1,13 @@
 import { ProjectFile } from '../../typings/models/projects';
 import { OptimisticGenericResult } from "../typings";
+import { OvermapRootState } from "../../typings";
 import { BaseApiService } from "./BaseApiService";
+import type { BaseSDK } from "../base";
 /**
  * Handles creation and caching of ProjectFiles
  */
-export declare class ProjectFileService extends BaseApiService {
-    refreshStore(): Promise<void>;
+export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    refreshStore(projectId: number): Promise<void>;
     saveExisting(file: ProjectFile): Promise<ProjectFile>;
     saveActive(): OptimisticGenericResult<ProjectFile>;
     delete(projectFileId: string): Promise<undefined>;

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

@@ -1,10 +1,11 @@
 import { Project } from '../../typings/models/projects';
+import { OvermapRootState, Payload } from "../../typings";
 import { BaseApiService } from "./BaseApiService";
-import { Payload } from "../../typings";
+import type { BaseSDK } from "../base";
 interface JoinProjectResponse {
     username: string;
 }
-export declare class ProjectService extends BaseApiService {
+export declare abstract class ProjectService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     /**
      * Creates a new project. Due to the nature of project creation,
      * @param project A Payload<Project> object containing project attributes.

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

@@ -1,12 +1,13 @@
-import { BaseApiService } from "./BaseApiService";
-import { Stored, Team, TeamPayload, User } from "../../typings";
+import { OvermapRootState, Stored, Team, TeamPayload, User } from "../../typings";
 import { OptimisticModelResult } from "../typings";
-export declare class TeamService extends BaseApiService {
-    add(teamPayload: TeamPayload): OptimisticModelResult<Team>;
+import { BaseApiService } from "./BaseApiService";
+import type { BaseSDK } from "../base";
+export declare abstract class TeamService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(teamPayload: TeamPayload, organizationId: number): OptimisticModelResult<Team>;
     update(team: Stored<Team>): OptimisticModelResult<Team>;
     delete(teamId: string): Promise<undefined>;
     setMembers(teamId: string, members: User["id"][]): Promise<undefined>;
     addMembers(teamId: string, members: User["id"][]): Promise<undefined>;
     removeMembers(teamId: string, members: User["id"][]): Promise<undefined>;
-    refreshStore(): Promise<void>;
+    refreshStore(organizationId: number): Promise<void>;
 }

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

@@ -1,9 +1,9 @@
-import { UserForm, UserFormRevision, UserFormRevisionPayload } from '../../typings/models/forms';
+import { ISerializedField, UserForm, UserFormRevision, UserFormRevisionPayload } from '../../typings/models/forms';
 import { OptimisticModelResult } from "../typings";
+import { Created, Submitted, OvermapRootState } from "../../typings";
 import { BaseApiService } from "./BaseApiService";
-import { Created, Submitted } from "../../typings";
-import { ISerializedField } from "../../forms";
-export declare class UserFormService extends BaseApiService {
+import type { BaseSDK } from "../base";
+export declare abstract class UserFormService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     private getAttachImagePromises;
     private add;
     addForOrganization(organizationId: number, initialRevision: UserFormRevisionPayload): Promise<[Submitted<UserForm>, Submitted<UserFormRevision<ISerializedField>>, Promise<Created<UserFormRevision<ISerializedField>>>, Promise<Created<UserFormRevision<ISerializedField>>>]>;
@@ -14,5 +14,5 @@ export declare class UserFormService extends BaseApiService {
     favorite(formId: string): Promise<undefined>;
     unfavorite(formId: string): Promise<undefined>;
     delete(formId: string): Promise<undefined>;
-    refreshStore(): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
 }

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

@@ -1,16 +1,15 @@
 import { Offline } from '../../typings/models/base';
-import { BaseApiService } from "./BaseApiService";
-import { UserFormSubmission, UserFormSubmissionAttachment, UserFormSubmissionPayload } from '../../typings/models/forms';
-import { OptimisticModelResult } from "../typings";
-import { FieldValue } from '../../forms';
-import { Created, Stored } from "../../typings";
-import { GetS3UrlSuccessResponse } from "./FileService";
+import { FieldValue, UserFormSubmission, UserFormSubmissionAttachment, UserFormSubmissionPayload } from '../../typings/models/forms';
+import { OptimisticModelResult, PresignedUrlsResponse } from "../typings";
+import { Created, OvermapRootState, Stored } from "../../typings";
+import type { BaseSDK } from "../base";
+import { BaseUploadService } from "./BaseUploadService";
 interface BulkAddRequestReturnValue {
     submissions: Created<UserFormSubmission>[];
     attachments: Created<UserFormSubmissionAttachment>[];
-    presigned_urls: Record<string, GetS3UrlSuccessResponse>;
+    presigned_urls: PresignedUrlsResponse;
 }
-export declare class UserFormSubmissionService extends BaseApiService {
+export declare abstract class UserFormSubmissionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     private getAttachFilesPromises;
     add(payload: Offline<UserFormSubmissionPayload>): OptimisticModelResult<UserFormSubmission>;
     bulkAdd(args: {
@@ -20,6 +19,6 @@ export declare class UserFormSubmissionService extends BaseApiService {
     }, batchSize: number): Promise<Promise<BulkAddRequestReturnValue>[]>;
     update(submission: Stored<UserFormSubmission>): OptimisticModelResult<UserFormSubmission>;
     delete(submissionId: string): Promise<undefined>;
-    refreshStore(): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
 }
 export {};

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

@@ -0,0 +1,6 @@
+import { BaseApiService } from "./BaseApiService";
+import { OvermapRootState } from "../../typings";
+import { BaseSDK } from "../base";
+export declare abstract class UserService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    refreshStore(projectId: number, organizationId: number): Promise<void>;
+}

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

@@ -1,9 +1,12 @@
 import { Payload } from '../../typings/models/base';
 import { Workspace } from '../../typings/models/workspace';
 import { OptimisticModelResult } from "../typings";
+import { OvermapRootState } from "../../typings";
 import { BaseApiService } from "./BaseApiService";
-export declare class WorkspaceService extends BaseApiService {
+import type { BaseSDK } from "../base";
+export declare abstract class WorkspaceService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(workspace: Payload<Workspace>): OptimisticModelResult<Workspace>;
     update(workspace: Workspace): OptimisticModelResult<Workspace>;
     delete(workspaceId: string): Promise<undefined>;
+    refreshStore(projectId: number): Promise<undefined>;
 }

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

@@ -1,4 +1,4 @@
-export * from "./AuthService";
+export * from "./JWTAuthService";
 export * from "./BaseApiService";
 export * from "./CategoryService";
 export * from "./AssetService";
@@ -12,7 +12,6 @@ export * from "./IssueUpdateService";
 export * from "./IssueAttachmentService";
 export * from "./IssueService";
 export * from "./IssueTypeService";
-export * from "./MainService";
 export * from "./ProjectAccessService";
 export * from "./ProjectFileService";
 export * from "./ProjectAttachmentService";
@@ -30,3 +29,5 @@ export * from "./DocumentService";
 export * from "./DocumentAttachmentService";
 export * from "./AgentService";
 export * from "./TeamService";
+export * from "./UserService";
+export * from "./GeoImageService";

package/dist/sdk/typings.d.ts

@@ -1,8 +1,11 @@
 import request from "superagent";
+import { ToolkitStore } from "@reduxjs/toolkit/dist/configureStore";
 import { HttpMethod } from "../enums";
-import { Created, Model, Stored, Submitted } from "../typings";
-import { DeferredPromise } from "../utils/async/DeferredPromise";
-import { GetS3UrlResponse } from "./services";
+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;
 export interface TokenPair {
     accessToken: string;
     refreshToken: string;
@@ -108,4 +111,6 @@ export interface OfflineMetaEffect {
     /** An ISO timestamp of when the request was created. */
     timestamp: string;
     BASE_URL: string;
+    serviceName: string;
 }
+export type PresignedUrlsResponse = Record<string, GetS3UrlSuccessResponse>;

package/dist/store/index.d.ts

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

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

@@ -1,5 +1,5 @@
 import { Reducer } from "@reduxjs/toolkit";
-import { AgentUserConversation, RootState, Selector } from "../../typings";
+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>, {
@@ -21,7 +21,7 @@ export declare const agentsSlice: import("@reduxjs/toolkit").Slice<ModelState<Ag
     }) => 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">;
-export declare const selectConversationMapping: (state: RootState) => Record<string, AgentUserConversation>;
-export declare const selectConversations: Selector<AgentUserConversation[]>;
-export declare const selectConversation: (args: string) => (state: RootState) => AgentUserConversation | undefined;
+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 agentsReducer: Reducer<AgentsState>;

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

@@ -1,6 +1,6 @@
 import { Reducer } from "@reduxjs/toolkit";
 import { ModelState } from "../typings";
-import { AssetAttachment, RootState, Selector, SelectorWithArgs, Stored } 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: {
@@ -41,11 +41,11 @@ export declare const assetAttachmentSlice: import("@reduxjs/toolkit").Slice<Mode
     }) => 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">;
-export declare const selectAssetAttachmentMapping: (state: RootState) => Record<string, Stored<AssetAttachment>>;
-export declare const selectAssetAttachments: Selector<Stored<AssetAttachment>[]>;
-export declare const selectAssetAttachment: SelectorWithArgs<string, Stored<AssetAttachment>>;
-export declare const selectAttachmentsOfAsset: (args: string) => (state: RootState) => Stored<AssetAttachment>[];
-export declare const selectAttachmentsOfAssetByType: (args: string) => (state: RootState) => {
+export declare const selectAssetAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetAttachment>>;
+export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
+export declare const selectAssetAttachment: OvermapSelectorWithArgs<string, Stored<AssetAttachment>>;
+export declare const selectAttachmentsOfAsset: (args: string) => (state: OvermapRootState) => Stored<AssetAttachment>[];
+export declare const selectAttachmentsOfAssetByType: (args: string) => (state: OvermapRootState) => {
     fileAttachments: Stored<AssetAttachment>[];
     imageAttachments: Stored<AssetAttachment>[];
 };

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

@@ -1,5 +1,5 @@
 import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { Asset, AssetType, RootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
+import { Asset, AssetType, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored, Submitted } from "../../typings";
 import { ModelState } from "../typings";
 export type AssetState = ModelState<Stored<Asset>>;
 export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
@@ -14,11 +14,11 @@ export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
     deleteAssets: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string[]>) => void;
 }, "assets">;
 export declare const initializeAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset[], "assets/initializeAssets">, addAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/addAsset">, addAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<(Asset | Submitted<Asset>)[], "assets/addAssets">, updateAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/updateAsset">, updateAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset[], "assets/updateAssets">, deleteAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/deleteAsset">, deleteAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assets/deleteAssets">, setAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/setAsset">, setAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset[], "assets/setAssets">;
-export declare const selectAssets: (state: RootState) => Asset[];
-export declare const selectAssetsMapping: (state: RootState) => Record<string, Stored<Asset>>;
-export declare const selectAssetsOfAssetType: SelectorWithArgs<string, Asset[]>;
-export declare const selectAsset: SelectorWithArgs<string, Asset>;
-export declare const selectAssetToAssetTypeMapping: Selector<Record<string, AssetType>>;
-export declare const selectNumberOfAssetsOfAssetType: SelectorWithArgs<string | undefined, number>;
-export declare const selectAssetTypesFromIds: SelectorWithArgs<string[], AssetType[]>;
+export declare const selectAssets: (state: OvermapRootState) => Asset[];
+export declare const selectAssetsMapping: (state: OvermapRootState) => Record<string, Stored<Asset>>;
+export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<string, Asset[]>;
+export declare const selectAsset: OvermapSelectorWithArgs<string, Asset>;
+export declare const selectAssetToAssetTypeMapping: OvermapSelector<Record<string, AssetType>>;
+export declare const selectNumberOfAssetsOfAssetType: OvermapSelectorWithArgs<string | undefined, number>;
+export declare const selectAssetTypesFromIds: OvermapSelectorWithArgs<string[], AssetType[]>;
 export declare const assetReducer: Reducer<AssetState>;

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

@@ -1,5 +1,5 @@
 import { Reducer, PayloadAction } from "@reduxjs/toolkit";
-import { CompletedStagesMapping, Asset, RootState, SelectorWithArgs, AssetStageCompletion } from "../../typings";
+import { CompletedStagesMapping, Asset, OvermapRootState, OvermapSelectorWithArgs, AssetStageCompletion } from "../../typings";
 export interface AssetStageCompletionState {
     completionsByAssetId: CompletedStagesMapping;
 }
@@ -10,6 +10,6 @@ export declare const assetStageCompletionSlice: import("@reduxjs/toolkit").Slice
     setStageCompletions: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<CompletedStagesMapping>) => void;
 }, "assetStageCompletions">;
 export declare const addStageCompletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/addStageCompletion">, addStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<CompletedStagesMapping, "assetStageCompletions/addStageCompletions">, removeStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/removeStageCompletions">, setStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<CompletedStagesMapping, "assetStageCompletions/setStageCompletions">;
-export declare const selectCompletedStages: (state: RootState) => CompletedStagesMapping;
-export declare const selectCompletedStageIdsForAsset: SelectorWithArgs<Asset, string[]>;
+export declare const selectCompletedStages: (state: OvermapRootState) => CompletedStagesMapping;
+export declare const selectCompletedStageIdsForAsset: OvermapSelectorWithArgs<Asset, string[]>;
 export declare const assetStageCompletionReducer: Reducer<AssetStageCompletionState>;

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

@@ -1,5 +1,5 @@
 import { Reducer } from "@reduxjs/toolkit";
-import { AssetStage, RootState, SelectorWithArgs, Stored } from "../../typings";
+import { AssetStage, OvermapRootState, 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>>, {
@@ -28,13 +28,13 @@ export declare const assetStageSlice: import("@reduxjs/toolkit").Slice<ModelStat
         type: string;
     }) => void;
 }, "assetStages">;
-export declare const selectStageMapping: (state: RootState) => Record<string, AssetStage>;
-export declare const selectStage: SelectorWithArgs<string, AssetStage | undefined>;
-export declare const selectStages: (state: RootState) => AssetStage[];
-export declare const selectStagesFromAssetTypeIds: SelectorWithArgs<string[], Record<string, AssetStage[]>>;
-export declare const selectAssetTypeStagesMapping: SelectorWithArgs<string, Record<string, AssetStage>>;
-export declare const selectStagesOfAssetType: SelectorWithArgs<string, AssetStage[]>;
-export declare const selectStagesFromStageIds: SelectorWithArgs<string[], AssetStage[]>;
-export declare const selectStageFormIdsFromStageIds: SelectorWithArgs<string[], Record<string, string>>;
+export declare const selectStageMapping: (state: OvermapRootState) => Record<string, AssetStage>;
+export declare const selectStage: OvermapSelectorWithArgs<string, AssetStage | undefined>;
+export declare const selectStages: (state: OvermapRootState) => AssetStage[];
+export declare const selectStagesFromAssetTypeIds: OvermapSelectorWithArgs<string[], Record<string, AssetStage[]>>;
+export declare const selectAssetTypeStagesMapping: OvermapSelectorWithArgs<string, Record<string, AssetStage>>;
+export declare const selectStagesOfAssetType: OvermapSelectorWithArgs<string, AssetStage[]>;
+export declare const selectStagesFromStageIds: OvermapSelectorWithArgs<string[], AssetStage[]>;
+export declare const selectStageFormIdsFromStageIds: OvermapSelectorWithArgs<string[], Record<string, string>>;
 export declare const initializeStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeStages">, setStage: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setStage">, addStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addStages">, updateStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateStages">, removeStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetStages/removeStages">, updateStage: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateStage">;
 export declare const assetStageReducer: Reducer<AssetStageState>;

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

@@ -1,5 +1,5 @@
 import { Reducer } from "@reduxjs/toolkit";
-import { AssetTypeAttachment, type RootState, type Selector, type SelectorWithArgs, Stored } from "../../typings";
+import { AssetTypeAttachment, type OvermapRootState, type OvermapSelector, type 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>>, {
@@ -41,11 +41,11 @@ export declare const assetTypeAttachmentSlice: import("@reduxjs/toolkit").Slice<
     }) => 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">;
-export declare const selectAssetTypeAttachmentMapping: (state: RootState) => Record<string, Stored<AssetTypeAttachment>>;
-export declare const selectAssetTypeAttachments: Selector<Stored<AssetTypeAttachment>[]>;
-export declare const selectAssetTypeAttachment: SelectorWithArgs<string, Stored<AssetTypeAttachment>>;
-export declare const selectAttachmentsOfAssetType: (args: string) => (state: RootState) => Stored<AssetTypeAttachment>[];
-export declare const selectAttachmentsOfAssetTypeByType: (args: string) => (state: RootState) => {
+export declare const selectAssetTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeAttachment>>;
+export declare const selectAssetTypeAttachments: OvermapSelector<Stored<AssetTypeAttachment>[]>;
+export declare const selectAssetTypeAttachment: OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment>>;
+export declare const selectAttachmentsOfAssetType: (args: string) => (state: OvermapRootState) => Stored<AssetTypeAttachment>[];
+export declare const selectAttachmentsOfAssetTypeByType: (args: string) => (state: OvermapRootState) => {
     fileAttachments: Stored<AssetTypeAttachment>[];
     imageAttachments: Stored<AssetTypeAttachment>[];
 };

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

@@ -1,9 +1,7 @@
 import type { Reducer } from "@reduxjs/toolkit";
-import type { AssetType, Selector, SelectorWithArgs, Stored } from "../../typings";
+import type { AssetType, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
 import { ModelState } from "../typings";
-export interface AssetTypeState extends ModelState<Stored<AssetType>> {
-    hiddenAssetTypeIds: Record<string, boolean>;
-}
+export type AssetTypeState = ModelState<Stored<AssetType>>;
 export declare const assetTypeSlice: import("@reduxjs/toolkit").Slice<AssetTypeState, {
     initializeAssetTypes: <TState extends ModelState<Stored<AssetType>>>(state: TState, action: {
         payload: Stored<AssetType>[];
@@ -17,20 +15,16 @@ export declare const assetTypeSlice: import("@reduxjs/toolkit").Slice<AssetTypeS
         payload: string;
         type: string;
     }) => void;
-    toggleAssetTypeVisibility: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
-        payload: string;
-    }) => void;
 }, "assetTypes">;
-export declare const addAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, initializeAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, deleteAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, toggleAssetTypeVisibility: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/toggleAssetTypeVisibility">;
-export declare const selectAssetTypesMapping: Selector<Record<string, AssetType>>;
-export declare const selectAssetTypes: Selector<AssetType[]>;
-export declare const selectAssetType: SelectorWithArgs<string, AssetType>;
+export declare const addAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, initializeAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, deleteAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">;
+export declare const selectAssetTypesMapping: OvermapSelector<Record<string, AssetType>>;
+export declare const selectAssetTypes: OvermapSelector<AssetType[]>;
+export declare const selectAssetType: OvermapSelectorWithArgs<string, AssetType>;
 interface selectNumberOfAssetTypesMatchingCaseInsensitiveNameProps {
     name: string | null | undefined;
     assetTypeId: string | undefined;
 }
-export declare const selectNumberOfAssetTypesMatchingCaseInsensitiveName: SelectorWithArgs<selectNumberOfAssetTypesMatchingCaseInsensitiveNameProps, number>;
-export declare const selectAssetTypesByName: SelectorWithArgs<string, AssetType[]>;
-export declare const selectHiddenAssetTypeIds: Selector<Record<string, boolean | undefined>>;
+export declare const selectNumberOfAssetTypesMatchingCaseInsensitiveName: OvermapSelectorWithArgs<selectNumberOfAssetTypesMatchingCaseInsensitiveNameProps, number>;
+export declare const selectAssetTypesByName: OvermapSelectorWithArgs<string, AssetType[]>;
 export declare const assetTypeReducer: Reducer<AssetTypeState>;
 export {};

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

@@ -1,6 +1,6 @@
 import { PayloadAction, Reducer } from "@reduxjs/toolkit";
 import { TokenPair } from '../../sdk/typings';
-import { RootState } from "../../typings";
+import { BaseState } from "../../typings";
 export interface AuthState {
     accessToken: string;
     refreshToken: string;
@@ -15,6 +15,6 @@ export declare const authSlice: import("@reduxjs/toolkit").Slice<AuthState, {
     setLoggedIn: (state: import("immer/dist/internal.js").WritableDraft<AuthState>, action: PayloadAction<boolean>) => void;
 }, "auth">;
 export declare const setTokens: import("@reduxjs/toolkit").ActionCreatorWithPayload<TokenPair, "auth/setTokens">, clearTokens: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"auth/clearTokens">, setLoggedIn: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "auth/setLoggedIn">;
-export declare const selectAccessToken: (state: RootState) => string;
-export declare const selectIsLoggedIn: (state: RootState) => boolean;
+export declare const selectAccessToken: (state: BaseState) => string;
+export declare const selectIsLoggedIn: (state: BaseState) => boolean;
 export declare const authReducer: Reducer<AuthState>;

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

@@ -1,89 +1,33 @@
-/// <reference types="@redux-offline/redux-offline" />
-import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { Category, RootState, SelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from "@reduxjs/toolkit";
+import { Category, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
 import { ModelState } from "../typings";
-interface CategoryVisibility {
-    hiddenCategoryIds: string[];
-    isNullCategoryHidden: boolean;
-}
-export interface CategoryState extends ModelState<Stored<Category>> {
-    categoryVisibility: CategoryVisibility;
-}
+export type CategoryState = ModelState<Stored<Category>>;
 export declare const categorySlice: import("@reduxjs/toolkit").Slice<CategoryState, {
-    initializeCategories: (state: import("immer/dist/internal.js").WritableDraft<CategoryState>, action: PayloadAction<Stored<Category>[]>) => void;
-    addCategory: <TState extends ModelState<Stored<Category>>>(state: TState, action: {
+    initializeCategories: <TState extends ModelState<Stored<Category>>>(state: TState, action: {
+        payload: Stored<Category>[];
+        type: string;
+    }) => void;
+    addCategory: <TState_1 extends ModelState<Stored<Category>>>(state: TState_1, action: {
         payload: Stored<Category>;
         type: string;
     }) => void;
-    updateCategory: <TState_1 extends ModelState<Stored<Category>>>(state: TState_1, action: {
+    updateCategory: <TState_2 extends ModelState<Stored<Category>>>(state: TState_2, action: {
         payload: Stored<Category>;
         type: string;
     }) => void;
-    deleteCategory: <TState_2 extends ModelState<Stored<Category>>>(state: TState_2, action: {
+    deleteCategory: <TState_3 extends ModelState<Stored<Category>>>(state: TState_3, action: {
         payload: string;
         type: string;
     }) => void;
-    hideCategory: (state: import("immer/dist/internal.js").WritableDraft<CategoryState>, action: {
-        payload: string | null;
-    }) => void;
-    hideAllCategories: (state: import("immer/dist/internal.js").WritableDraft<CategoryState>) => void;
-    unhideCategory: (state: import("immer/dist/internal.js").WritableDraft<CategoryState>, action: {
-        payload: string | null;
-    }) => void;
-    unhideAllCategories: (state: import("immer/dist/internal.js").WritableDraft<CategoryState>) => void;
 }, "categories">;
-export declare const initializeCategories: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>[], "categories/initializeCategories">, addCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>, "categories/addCategory">, updateCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>, "categories/updateCategory">, deleteCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "categories/deleteCategory">, hideCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<string | null, "categories/hideCategory">, hideAllCategories: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"categories/hideAllCategories">, unhideCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<string | null, "categories/unhideCategory">, unhideAllCategories: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"categories/unhideAllCategories">;
-export declare const selectCategoryMapping: (state: RootState) => Record<string, Stored<Category>>;
-export declare const selectCategories: ((state: import("redux").EmptyObject & {
-    versioning: import('../slices/versioningSlice').VersioningState;
-    fileReducer: import('..').FileState;
-    authReducer: import('..').AuthState;
-    categoryReducer: CategoryState;
-    assetReducer: import('..').AssetState;
-    assetAttachmentReducer: import('..').AssetAttachmentState;
-    assetStageCompletionReducer: import('..').AssetStageCompletionState;
-    assetStageReducer: import('..').AssetStageState;
-    assetTypeReducer: import('..').AssetTypeState;
-    assetTypeAttachmentReducer: import('..').AssetTypeAttachmentState;
-    issueReducer: import('..').IssueState;
-    issueTypeReducer: import('..').IssueTypeState;
-    mapReducer: import('..').MapState;
-    organizationReducer: import('..').OrganizationState;
-    outboxReducer: import('..').OutboxState;
-    projectReducer: import('..').ProjectState;
-    projectAttachmentReducer: import('..').ProjectAttachmentState;
-    projectAccessReducer: import('..').ProjectAccessState;
-    organizationAccessReducer: import('..').OrganizationAccessState;
-    projectFileReducer: import('..').ProjectFileState;
-    rehydratedReducer: import('..').RehydratedState;
-    settingReducer: import('..').SettingState;
-    formReducer: import('..').FormState;
-    userReducer: import('..').UserState;
-    formRevisionReducer: import('..').FormRevisionState;
-    formRevisionAttachmentReducer: import('..').FormRevisionAttachmentState;
-    formSubmissionAttachmentReducer: import('..').FormSubmissionAttachmentState;
-    formSubmissionReducer: import('..').FormSubmissionState;
-    workspaceReducer: import('..').WorkspaceState;
-    emailDomainsReducer: import('..').EmailDomainState;
-    licenseReducer: import('..').LicenseState;
-    documentsReducer: import('..').DocumentState;
-    documentAttachmentReducer: import('..').DocumentAttachmentState;
-    teamReducer: import('..').TeamState;
-    agentsReducer: import('..').AgentsState;
-    issueCommentReducer: import('..').IssueCommentState;
-    issueUpdateReducer: import('..').IssueUpdateState;
-    issueAttachmentReducer: import('..').IssueAttachmentState;
-} & {
-    offline: import("@redux-offline/redux-offline/lib/types").OfflineState;
-}) => Stored<Category>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<Category>>, args_1: string | null) => Stored<Category>[], {
+export declare const initializeCategories: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>[], "categories/initializeCategories">, addCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>, "categories/addCategory">, updateCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<Category>, "categories/updateCategory">, deleteCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "categories/deleteCategory">;
+export declare const selectCategoryMapping: (state: OvermapRootState) => Record<string, Stored<Category>>;
+export declare const selectCategories: ((state: OvermapRootState) => Stored<Category>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<Category>>) => Stored<Category>[], {
     clearCache: () => void;
 }> & {
     clearCache: () => void;
 };
-export declare const selectCategoriesOfWorkspace: SelectorWithArgs<string, Category[]>;
-export declare const selectCategoryById: SelectorWithArgs<string, Category | undefined>;
-export declare const selectCategoryVisibility: (state: RootState) => CategoryVisibility;
-export declare const selectHiddenCategoryCount: (state: RootState) => number;
-export declare const selectIssueCountOfCategory: SelectorWithArgs<string | null, number>;
+export declare const selectCategoriesOfWorkspace: OvermapSelectorWithArgs<string, Category[]>;
+export declare const selectCategoryById: OvermapSelectorWithArgs<string, Category | undefined>;
+export declare const selectIssueCountOfCategory: OvermapSelectorWithArgs<string | null, number>;
 export declare const categoryReducer: Reducer<CategoryState>;
-export {};

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

@@ -1,6 +1,6 @@
 import { Reducer } from "@reduxjs/toolkit";
 import { ModelState } from "../typings";
-import { DocumentAttachment, RootState, Selector, SelectorWithArgs, Stored } from "../../typings";
+import { DocumentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
 export type DocumentAttachmentState = ModelState<Stored<DocumentAttachment>>;
 export declare const documentAttachmentSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<DocumentAttachment>>, {
     initializeDocumentAttachments: <TState extends ModelState<Stored<DocumentAttachment>>>(state: TState, action: {
@@ -41,11 +41,11 @@ export declare const documentAttachmentSlice: import("@reduxjs/toolkit").Slice<M
     }) => void;
 }, "documentAttachments">;
 export declare const initializeDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">, addDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/addDocumentAttachment">, addDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">, setDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">, setDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/setDocumentAttachments">, updateDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/updateDocumentAttachment">, updateDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">, deleteDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">, deleteDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
-export declare const selectDocumentAttachmentMapping: (state: RootState) => Record<string, Stored<DocumentAttachment>>;
-export declare const selectAllDocumentAttachments: Selector<Stored<DocumentAttachment>[]>;
-export declare const selectDocumentAttachment: SelectorWithArgs<string, Stored<DocumentAttachment>>;
-export declare const selectAttachmentsOfDocument: (args: string) => (state: RootState) => Stored<DocumentAttachment>[];
-export declare const selectAttachmentsOfDocumentByType: (args: string) => (state: RootState) => {
+export declare const selectDocumentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<DocumentAttachment>>;
+export declare const selectAllDocumentAttachments: OvermapSelector<Stored<DocumentAttachment>[]>;
+export declare const selectDocumentAttachment: OvermapSelectorWithArgs<string, Stored<DocumentAttachment>>;
+export declare const selectAttachmentsOfDocument: (args: string) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
+export declare const selectAttachmentsOfDocumentByType: (args: string) => (state: OvermapRootState) => {
     fileAttachments: Stored<DocumentAttachment>[];
     imageAttachments: Stored<DocumentAttachment>[];
 };