@overmap-ai/core 1.0.56 → 1.0.57-export-overmap-reducer.0

package/dist/sdk/sdk.d.ts

@@ -1,11 +1,11 @@
-import { AgentService, AuthService, CategoryService, ComponentAttachmentService, ComponentService, ComponentStageCompletionService, ComponentStageService, ComponentTypeAttachmentService, ComponentTypeService, DocumentAttachmentService, DocumentService, EmailDomainsService, EmailVerificationService, FileService, IssueAttachmentService, IssueCommentService, IssueService, IssueTypeService, IssueUpdateService, LicenseService, MainService, OrganizationAccessService, OrganizationService, ProjectAccessService, ProjectAttachmentService, ProjectFileService, ProjectService, TeamService, UserFormService, UserFormSubmissionService, WorkspaceService } from "./services";
+import { AgentService, AuthService, CategoryService, AssetService, AssetStageCompletionService, AssetStageService, AssetAttachmentService, AssetTypeService, AssetTypeAttachmentService, DocumentAttachmentService, DocumentService, EmailDomainsService, EmailVerificationService, FileService, IssueAttachmentService, IssueCommentService, IssueService, IssueTypeService, IssueUpdateService, LicenseService, MainService, OrganizationAccessService, OrganizationService, ProjectAccessService, ProjectAttachmentService, ProjectFileService, ProjectService, TeamService, UserFormService, UserFormSubmissionService, WorkspaceService } from "./services";
 import { ToolkitStore } from "@reduxjs/toolkit/dist/configureStore";
-import { RootState } from "../typings";
+import { OvermapRootState } from "../typings";
 import { SDKRequest } from "./typings";
 export declare class OvermapSDK {
     readonly API_URL: string;
-    readonly store: ToolkitStore<RootState>;
-    constructor(apiUrl: string, store: ToolkitStore<RootState>);
+    readonly store: ToolkitStore<OvermapRootState>;
+    constructor(apiUrl: string, store: ToolkitStore<OvermapRootState>);
     /**
      * Enqueues an API request to the offline outbox.
      * @param requestDetails An SDKRequest object containing the details of the request.
@@ -31,12 +31,12 @@ export declare class OvermapSDK {
     issueAttachments: IssueAttachmentService;
     workspaces: WorkspaceService;
     main: MainService;
-    components: ComponentService;
-    componentAttachments: ComponentAttachmentService;
-    componentTypes: ComponentTypeService;
-    componentTypeAttachments: ComponentTypeAttachmentService;
-    componentStages: ComponentStageService;
-    componentStageCompletions: ComponentStageCompletionService;
+    assets: AssetService;
+    assetAttachments: AssetAttachmentService;
+    assetTypes: AssetTypeService;
+    assetTypeAttachments: AssetTypeAttachmentService;
+    assetStages: AssetStageService;
+    assetStageCompletions: AssetStageCompletionService;
     userForms: UserFormService;
     userFormSubmissions: UserFormSubmissionService;
     projects: ProjectService;
@@ -49,4 +49,4 @@ export declare class OvermapSDK {
     teams: TeamService;
     documentAttachments: DocumentAttachmentService;
 }
-export declare const makeClient: (apiUrl: string, store: ToolkitStore<RootState>) => OvermapSDK;
+export declare const makeClient: (apiUrl: string, store: ToolkitStore<OvermapRootState>) => OvermapSDK;

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

@@ -1,24 +1,5 @@
 import { BaseApiService } from "./BaseApiService";
-import { AgentProfile, AgentUserConversation, Payload } from "../../typings";
-import { JSONContent } from "@tiptap/core";
-export interface PromptAgentResponse {
-    /**
-     * The response from the agent.
-     */
-    response: JSONContent[];
-    /**
-     * The UUID of the conversation.
-     */
-    conversation_id: string;
-    /**
-     * The UUID of the response (used when submitting ratings)
-     */
-    response_id: string;
-    /**
-     * The profile of the agent. Only included in the first response in a conversation.
-     */
-    profile?: AgentProfile;
-}
+import { AgentUserConversation } from "../../typings";
 export declare class AgentService extends BaseApiService {
     startConversation(prompt: string): Promise<AgentUserConversation>;
     /**
@@ -26,7 +7,7 @@ export declare class AgentService extends BaseApiService {
      * @param prompt The message to prompt the agent with.
      * @param conversationId If continuing an existing message, the UUID of that conversation.
      */
-    continueConversation(prompt: Payload<string>, conversationId: AgentUserConversation["offline_id"]): Promise<void>;
+    continueConversation(prompt: string, conversationId: AgentUserConversation["offline_id"]): Promise<void>;
     fetchDetails(conversationId: AgentUserConversation["offline_id"]): Promise<void>;
     rate(responseId: string, rating: 1 | 5): Promise<undefined>;
     refreshStore(): Promise<void>;

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

@@ -0,0 +1,10 @@
+import { BaseAttachmentService } from "./BaseAttachmentService";
+import { AttachmentModel, AssetAttachment } from "../../typings";
+import { OptimisticMultipleModelResult } from "../typings";
+export declare class AssetAttachmentService extends BaseAttachmentService {
+    attachmentModel: AttachmentModel;
+    private buildOfflineAttachment;
+    attachFilesToAsset(files: File[], assetId: string): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
+    deleteAssetAttachment(attachmentId: string): Promise<void>;
+    refreshStore(): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import { BaseApiService } from "./BaseApiService";
+import { Asset, Payload } from "../../typings";
+import { OptimisticModelResult } from "../typings";
+export declare class AssetService extends BaseApiService {
+    add(asset: Payload<Asset>, workspaceId: string): OptimisticModelResult<Asset>;
+    update(asset: Asset, workspaceId: string): OptimisticModelResult<Asset>;
+    remove(assetId: string): Promise<undefined>;
+    deleteAllAssetsOfAssetType(assetTypeId: string): Promise<undefined>;
+    addBatch(assetsToCreate: Payload<Asset>[], workspaceId: string, assetTypeId: string): Promise<Record<string, Asset>>;
+    refreshStore(): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import { BaseApiService } from "./BaseApiService";
+import { OptimisticModelResult } from "../typings";
+import { AssetStageCompletion, Payload } from "../../typings";
+export declare class AssetStageCompletionService extends BaseApiService {
+    add(assetId: string, stageId: string): OptimisticModelResult<AssetStageCompletion>;
+    refreshStore(): Promise<void>;
+    /**
+     * Creates a collection of AssetStageCompletions, marking the referenced stages as completed for the referenced
+     * assets. It's REQUIRED that all assets referenced all have the SAME asset type.
+     * @param assetTypeId The ID of the asset type for which we are completing stages (we can only complete
+     * stages for one asset type at a time)
+     * @param stageCompletions
+     */
+    bulkAdd(assetTypeId: string, stageCompletions: Payload<AssetStageCompletion>[]): Promise<void>;
+    bulkDelete(stageId: string, assetIds: string[]): Promise<undefined>;
+}

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

@@ -0,0 +1,11 @@
+import { BaseApiService } from "./BaseApiService";
+import { AssetStage, AssetStagePayload, Payload } from "../../typings";
+export declare class AssetStageService extends BaseApiService {
+    bulkCreateStages(stagesToSubmit: Payload<AssetStagePayload>[], assetTypeId: string, workspaceId: string): Promise<AssetStage[]>;
+    bulkUpdateStages(stagesToUpdate: AssetStage[], assetTypeId: string): Promise<AssetStage[]>;
+    bulkDelete(idsToDelete: string[]): Promise<undefined>;
+    update(assetStage: AssetStage): Promise<undefined>;
+    linkForm(stageId: string, formId: string): Promise<undefined>;
+    unlinkForm(stageId: string, formId: string): Promise<undefined>;
+    refreshStore(): Promise<undefined>;
+}

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

@@ -0,0 +1,10 @@
+import { BaseAttachmentService } from "./BaseAttachmentService";
+import { AttachmentModel, AssetTypeAttachment } from "../../typings";
+import { OptimisticMultipleModelResult } from "../typings";
+export declare class AssetTypeAttachmentService extends BaseAttachmentService {
+    attachmentModel: AttachmentModel;
+    private buildOfflineAttachment;
+    attachFilesToAssetType(files: File[], assetTypeId: string): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
+    deleteAssetTypeAttachment(attachmentId: string): Promise<void>;
+    refreshStore(): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { BaseApiService } from "./BaseApiService";
+import { AssetType, Payload } from "../../typings";
+import { OptimisticModelResult } from "../typings";
+export declare class AssetTypeService extends BaseApiService {
+    add(assetType: Payload<AssetType>): OptimisticModelResult<AssetType>;
+    update(assetType: AssetType): Promise<undefined>;
+    delete(assetTypeId: string): Promise<undefined>;
+    refreshStore(): Promise<void>;
+}

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

@@ -5,12 +5,12 @@ export declare class UserFormService extends BaseApiService {
     private getAttachImagePromises;
     private add;
     addForOrganization(initialRevision: UserFormRevisionPayload, attachedTo?: {
-        componentTypeId: string;
+        assetTypeId: string;
     } | {
         issueTypeId: string;
     }): Promise<[SubmittedUserForm, UserFormRevision, Promise<UserFormRevision>, Promise<UserFormRevision>]>;
     addForCurrentUser(initialRevision: UserFormRevision, attachedTo?: {
-        componentTypeId: string;
+        assetTypeId: string;
     } | {
         issueTypeId: string;
     }): Promise<[SubmittedUserForm, UserFormRevision, Promise<UserFormRevision>, Promise<UserFormRevision>]>;

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

@@ -10,7 +10,7 @@ export declare class UserFormSubmissionService extends BaseApiService {
     bulkAdd(args: {
         formRevision: string;
         values: Record<string, FieldValue>;
-        componentOfflineIds: string[];
+        assetOfflineIds: string[];
     }): Promise<OptimisticMultipleModelResult<UserFormSubmission>>;
     update(submission: Stored<UserFormSubmission>): OptimisticModelResult<UserFormSubmission>;
     delete(submissionId: string): Promise<undefined>;

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

@@ -1,12 +1,12 @@
 export * from "./AuthService";
 export * from "./BaseApiService";
 export * from "./CategoryService";
-export * from "./ComponentService";
-export * from "./ComponentStageCompletionService";
-export * from "./ComponentStageService";
-export * from "./ComponentAttachmentService";
-export * from "./ComponentTypeService";
-export * from "./ComponentTypeAttachmentService";
+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";

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 { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { AgentUserConversation, Offline, OfflineIdMapping, RootState, Selector } from "../../typings";
+import { AgentUserConversation, Offline, OfflineIdMapping, OvermapRootState, Selector } from "../../typings";
 export interface AgentsState {
     conversations: OfflineIdMapping<AgentUserConversation>;
 }
@@ -10,7 +10,7 @@ export declare const agentsSlice: import("@reduxjs/toolkit").Slice<AgentsState,
     updateConversation: (state: import("immer/dist/internal.js").WritableDraft<AgentsState>, action: PayloadAction<Offline<Partial<AgentUserConversation>>>) => void;
 }, "agents">;
 export declare const setConversations: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation[], "agents/setConversations">, addConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, setConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, updateConversation: import("@reduxjs/toolkit").ActionCreatorWithPayload<Offline<Partial<AgentUserConversation>>, "agents/updateConversation">;
-export declare const selectConversationMapping: (state: RootState) => OfflineIdMapping<AgentUserConversation>;
+export declare const selectConversationMapping: (state: OvermapRootState) => OfflineIdMapping<AgentUserConversation>;
 export declare const selectConversations: Selector<AgentUserConversation[]>;
-export declare const selectConversation: (args: string) => (state: RootState) => AgentUserConversation | undefined;
+export declare const selectConversation: (args: string) => (state: OvermapRootState) => AgentUserConversation | undefined;
 export declare const agentsReducer: Reducer<AgentsState>;

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

@@ -0,0 +1,63 @@
+import { PayloadAction, Reducer } from "@reduxjs/toolkit";
+import { Asset, AssetAttachment, AssetType, OvermapRootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
+export interface AssetState {
+    assets: Record<string, Asset | Submitted<Asset>>;
+    attachments: Record<string, Stored<AssetAttachment>>;
+}
+export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
+    addAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset>) => void;
+    addAssetsInBatches: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<(Asset | Submitted<Asset>)[]>) => void;
+    setAssets: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset[]>) => void;
+    updateAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset>) => void;
+    removeAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string>) => void;
+    removeAllAssetsOfType: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string>) => void;
+    setAssetAttachment: (state: AssetState, action: {
+        payload: Stored<AssetAttachment>;
+        type: string;
+    }) => void;
+    setAssetAttachments: (state: AssetState, action: {
+        payload: Stored<AssetAttachment>[];
+        type: string;
+    }) => void;
+    addAssetAttachment: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>;
+        type: string;
+    }) => void;
+    addAssetAttachments: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetAttachment: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>;
+        type: string;
+    }) => void;
+    updateAssetAttachments: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>[];
+        type: string;
+    }) => void;
+    removeAssetAttachment: (state: AssetState, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    removeAssetAttachments: (state: AssetState, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assets">;
+export declare const addAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/addAsset">, updateAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/updateAsset">, removeAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAsset">, addAssetsInBatches: import("@reduxjs/toolkit").ActionCreatorWithPayload<(Asset | Submitted<Asset>)[], "assets/addAssetsInBatches">, setAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset[], "assets/setAssets">, removeAllAssetsOfType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAllAssetsOfType">, setAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>, "assets/setAssetAttachment">, setAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assets/setAssetAttachments">, addAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>, "assets/addAssetAttachment">, addAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>[], "assets/addAssetAttachments">, updateAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>, "assets/updateAssetAttachment">, updateAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>[], "assets/updateAssetAttachments">, removeAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAssetAttachment">, removeAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assets/removeAssetAttachments">;
+export declare const selectAssets: (state: OvermapRootState) => Asset[];
+export declare const selectAssetsMapping: (state: OvermapRootState) => Record<string, Asset | Submitted<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 selectAssetAttachmentMapping: (state: OvermapRootState) => 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: OvermapRootState) => Stored<AssetAttachment>[];
+export declare const selectAttachmentsOfAssetByType: (args: string) => (state: OvermapRootState) => {
+    fileAttachments: Stored<AssetAttachment>[];
+    imageAttachments: Stored<AssetAttachment>[];
+};
+export declare const assetReducer: Reducer<AssetState>;

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

@@ -0,0 +1,15 @@
+import { Reducer, PayloadAction } from "@reduxjs/toolkit";
+import { CompletedStagesMapping, Asset, OvermapRootState, SelectorWithArgs, AssetStageCompletion } from "../../typings";
+export interface AssetStageCompletionState {
+    completionsByAssetId: CompletedStagesMapping;
+}
+export declare const assetStageCompletionSlice: import("@reduxjs/toolkit").Slice<AssetStageCompletionState, {
+    addStageCompletion: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<AssetStageCompletion>) => void;
+    addStageCompletions: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<CompletedStagesMapping>) => void;
+    removeStageCompletions: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<AssetStageCompletion[]>) => void;
+    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: OvermapRootState) => CompletedStagesMapping;
+export declare const selectCompletedStageIdsForAsset: SelectorWithArgs<Asset, string[]>;
+export declare const assetStageCompletionReducer: Reducer<AssetStageCompletionState>;

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

@@ -0,0 +1,32 @@
+import { Reducer, PayloadAction } from "@reduxjs/toolkit";
+import { AssetStage, OvermapRootState, SelectorWithArgs } from "../../typings";
+export interface AssetStageState {
+    stages: Record<string, AssetStage>;
+}
+export declare const assetStageSlice: import("@reduxjs/toolkit").Slice<AssetStageState, {
+    addStages: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<AssetStage[]>) => void;
+    updateStages: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<AssetStage[]>) => void;
+    removeStages: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<string[]>) => void;
+    linkStageToForm: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<{
+        stageId: string;
+        formId: string;
+    }>) => void;
+    unlinkStageToForm: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<{
+        stageId: string;
+    }>) => void;
+}, "assetStages">;
+export declare const selectStageMapping: (state: OvermapRootState) => Record<string, AssetStage>;
+export declare const selectStage: SelectorWithArgs<string, AssetStage | undefined>;
+export declare const selectStages: (state: OvermapRootState) => 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 addStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStage[], "assetStages/addStages">, updateStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStage[], "assetStages/updateStages">, removeStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetStages/removeStages">, linkStageToForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    stageId: string;
+    formId: string;
+}, "assetStages/linkStageToForm">, unlinkStageToForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    stageId: string;
+}, "assetStages/unlinkStageToForm">;
+export declare const assetStageReducer: Reducer<AssetStageState>;

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

@@ -0,0 +1,74 @@
+import type { Reducer } from "@reduxjs/toolkit";
+import type { AssetType, AssetTypeAttachment, OvermapRootState, Selector, SelectorWithArgs, Stored } from "../../typings";
+export interface AssetTypeState {
+    assetTypes: Record<string, AssetType>;
+    hiddenAssetTypeIds: Record<string, boolean>;
+    attachments: Record<string, AssetTypeAttachment>;
+}
+export declare const assetTypeSlice: import("@reduxjs/toolkit").Slice<AssetTypeState, {
+    addAssetType: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: AssetType;
+    }) => void;
+    setAssetTypes: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: AssetType[];
+    }) => void;
+    toggleAssetTypeVisibility: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: string;
+    }) => void;
+    deleteAssetType: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: string;
+    }) => void;
+    setAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: Stored<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: Stored<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    removeAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    removeAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetTypes">;
+export declare const addAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetType, "assetTypes/addAssetType">, setAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetType[], "assetTypes/setAssetTypes">, toggleAssetTypeVisibility: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/toggleAssetTypeVisibility">, deleteAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, setAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypes/setAssetTypeAttachment">, setAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypes/setAssetTypeAttachments">, addAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>, "assetTypes/addAssetTypeAttachment">, addAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>[], "assetTypes/addAssetTypeAttachments">, updateAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>, "assetTypes/updateAssetTypeAttachment">, updateAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>[], "assetTypes/updateAssetTypeAttachments">, removeAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/removeAssetTypeAttachment">, removeAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetTypes/removeAssetTypeAttachments">;
+export declare const selectAssetTypesMapping: Selector<Record<string, AssetType>>;
+export declare const selectAssetTypes: Selector<AssetType[]>;
+export declare const selectAssetType: SelectorWithArgs<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 selectAssetTypeAttachmentMapping: (state: OvermapRootState) => Record<string, AssetTypeAttachment>;
+export declare const selectAssetTypeAttachments: Selector<Stored<AssetTypeAttachment>[]>;
+export declare const selectAssetTypeAttachment: SelectorWithArgs<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>[];
+};
+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 { OvermapRootState } 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: OvermapRootState) => string;
+export declare const selectIsLoggedIn: (state: OvermapRootState) => boolean;
 export declare const authReducer: Reducer<AuthState>;

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

@@ -1,6 +1,6 @@
 /// <reference types="@redux-offline/redux-offline" />
 import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { Category, CSSColor, Offline, RootState, Selector, SelectorWithArgs } from "../../typings";
+import { Category, CSSColor, Offline, OvermapRootState, Selector, SelectorWithArgs } from "../../typings";
 interface CategoryVisibility {
     hiddenCategoryIds: string[];
     isNullCategoryHidden: boolean;
@@ -40,16 +40,16 @@ export declare const categorySlice: import("@reduxjs/toolkit").Slice<CategorySta
     }) => void;
 }, "categories">;
 export declare const setCategories: import("@reduxjs/toolkit").ActionCreatorWithPayload<Category[], "categories/setCategories">, addCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Category, "categories/addCategory">, replaceCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Category, "categories/replaceCategory">, patchCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<Offline<Partial<Category>>, "categories/patchCategory">, removeCategory: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "categories/removeCategory">, 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">, removeColor: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "categories/removeColor">, addOrReplaceCategories: import("@reduxjs/toolkit").ActionCreatorWithPayload<Category[], "categories/addOrReplaceCategories">;
-export declare const selectCategoryMapping: (state: RootState) => Record<string, Category>;
+export declare const selectCategoryMapping: (state: OvermapRootState) => Record<string, Category>;
 export declare const selectCategories: ((state: import("redux").EmptyObject & {
     versioning: import('../slices/versioningSlice').VersioningState;
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;
@@ -79,10 +79,10 @@ export declare const selectCategories: ((state: import("redux").EmptyObject & {
     clearCache: () => void;
 };
 export declare const selectCategoriesOfWorkspace: SelectorWithArgs<string, Category[]>;
-export declare const selectCategory: (offline_id: string | null) => (state: RootState) => Category | undefined;
+export declare const selectCategory: (offline_id: string | null) => (state: OvermapRootState) => Category | undefined;
 export declare const selectUsedColors: Selector<CSSColor[]>;
-export declare const selectCategoryVisibility: (state: RootState) => CategoryVisibility;
-export declare const selectHiddenCategoryCount: (state: RootState) => number;
+export declare const selectCategoryVisibility: (state: OvermapRootState) => CategoryVisibility;
+export declare const selectHiddenCategoryCount: (state: OvermapRootState) => number;
 export declare const selectIssueCountOfCategory: SelectorWithArgs<string | null, number>;
 export declare const categoryReducer: Reducer<CategoryState>;
 export {};

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

@@ -1,7 +1,6 @@
 /// <reference types="@redux-offline/redux-offline" />
 import { Reducer } from "@reduxjs/toolkit";
-import { DocumentAttachment, MovePosition, Document, RootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
-import { AppSelector } from "./componentTypeSlice";
+import { DocumentAttachment, MovePosition, Document, OvermapRootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
 export interface DocumentState {
     documents: Record<string, Stored<Document>>;
     attachments: Record<string, Stored<DocumentAttachment>>;
@@ -193,9 +192,9 @@ export declare const setDocuments: import("@reduxjs/toolkit").ActionCreatorWithP
 } & {
     children_documents: string[];
 }, "id" | "created_at" | "created_by">)>>[], "documents/updateDocuments">, moveDocument: import("@reduxjs/toolkit").ActionCreatorWithPayload<MoveDocumentPayload, "documents/moveDocument">, removeDocuments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documents/removeDocuments">, setDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documents/setDocumentAttachment">, setDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documents/setDocumentAttachments">, addDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>, "documents/addDocumentAttachment">, addDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>[], "documents/addDocumentAttachments">, updateDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>, "documents/updateDocumentAttachment">, updateDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>[], "documents/updateDocumentAttachments">, removeDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "documents/removeDocumentAttachment">, removeDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documents/removeDocumentAttachments">;
-export declare const selectDocumentsMapping: AppSelector<Record<string, Stored<Document>>>;
-export declare const selectDocuments: AppSelector<Stored<Document>[]>;
-export declare const selectDocument: (args: string) => (state: RootState) => (import('../../typings/models/base').OfflineModel & import('../../typings/models/base').CreatedByModel & {
+export declare const selectDocumentsMapping: Selector<Record<string, Stored<Document>>>;
+export declare const selectDocuments: Selector<Stored<Document>[]>;
+export declare const selectDocument: (args: string) => (state: OvermapRootState) => (import('../../typings/models/base').OfflineModel & import('../../typings/models/base').CreatedByModel & {
     title: string | null;
     description: string | null;
     content: string | null;
@@ -240,16 +239,16 @@ export declare const selectDocument: (args: string) => (state: RootState) => (im
 } & {
     children_documents: string[];
 }, "id" | "created_at" | "created_by">) | undefined;
-export declare const selectAncestorIdsOfDocument: (args: string) => (state: RootState) => string[];
+export declare const selectAncestorIdsOfDocument: (args: string) => (state: OvermapRootState) => string[];
 export declare const selectRootDocuments: ((state: import("redux").EmptyObject & {
     versioning: import('../slices/versioningSlice').VersioningState;
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import('..').CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import("./componentTypeSlice").ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;
@@ -410,11 +409,11 @@ export declare const selectRootDocuments: ((state: import("redux").EmptyObject &
 }> & {
     clearCache: () => void;
 };
-export declare const selectDocumentAttachmentMapping: (state: RootState) => Record<string, Stored<DocumentAttachment>>;
+export declare const selectDocumentAttachmentMapping: (state: OvermapRootState) => 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 selectAttachmentsOfDocument: (args: string) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
+export declare const selectAttachmentsOfDocumentByType: (args: string) => (state: OvermapRootState) => {
     fileAttachments: Stored<DocumentAttachment>[];
     imageAttachments: Stored<DocumentAttachment>[];
 };

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

@@ -1,6 +1,6 @@
 /// <reference types="@redux-offline/redux-offline" />
 import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { RootState, Selector, SelectorWithArgs, Stored, UserForm, UserFormRevision, UserFormRevisionAttachment } from "../../typings";
+import { OvermapRootState, Selector, SelectorWithArgs, Stored, UserForm, UserFormRevision, UserFormRevisionAttachment } from "../../typings";
 export interface FormRevisionState {
     formRevisions: Record<UserFormRevision["offline_id"], Stored<UserFormRevision>>;
     attachments: Record<UserFormRevisionAttachment["offline_id"], Stored<UserFormRevisionAttachment>>;
@@ -19,16 +19,16 @@ export declare const formRevisionsSlice: import("@reduxjs/toolkit").Slice<FormRe
     deleteFormRevisionAttachments: (state: import("immer/dist/internal.js").WritableDraft<FormRevisionState>, action: PayloadAction<UserFormRevisionAttachment["offline_id"][]>) => void;
 }, "formRevisions">;
 export declare const setFormRevision: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevision<import('../../forms').ISerializedField>>, "formRevisions/setFormRevision">, setFormRevisions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevision<import('../../forms').ISerializedField>>[], "formRevisions/setFormRevisions">, addFormRevision: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevision<import('../../forms').ISerializedField>>, "formRevisions/addFormRevision">, addFormRevisions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevision<import('../../forms').ISerializedField>>[], "formRevisions/addFormRevisions">, deleteFormRevision: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "formRevisions/deleteFormRevision">, deleteFormRevisions: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisions">, setFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevisionAttachment>[], "formRevisions/setFormRevisionAttachments">, addFormRevisionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevisionAttachment>, "formRevisions/addFormRevisionAttachment">, addFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<UserFormRevisionAttachment>[], "formRevisions/addFormRevisionAttachments">, deleteFormRevisionAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "formRevisions/deleteFormRevisionAttachment">, deleteFormRevisionAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "formRevisions/deleteFormRevisionAttachments">;
-export declare const selectFormRevisionMapping: (state: RootState) => Record<string, Stored<UserFormRevision<import('../../forms').ISerializedField>>>;
+export declare const selectFormRevisionMapping: (state: OvermapRootState) => Record<string, Stored<UserFormRevision<import('../../forms').ISerializedField>>>;
 export declare const selectFormRevisions: ((state: import("redux").EmptyObject & {
     versioning: import('../slices/versioningSlice').VersioningState;
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import('..').CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;
@@ -61,7 +61,7 @@ export declare const selectFormRevision: SelectorWithArgs<string, Stored<UserFor
 export declare const _selectLatestFormRevision: (formRevisions: FormRevisionState["formRevisions"], formId: string) => Stored<UserFormRevision>;
 export declare const selectLatestFormRevisionOfForm: SelectorWithArgs<string, Stored<UserFormRevision>>;
 export declare const selectFormRevisionsOfForm: SelectorWithArgs<string, Stored<UserFormRevision>[]>;
-export declare const selectLatestFormRevisionsOfComponentTypes: SelectorWithArgs<string[], Record<string, Stored<UserFormRevision>>>;
+export declare const selectLatestFormRevisionsOfAssetTypes: SelectorWithArgs<string[], Record<string, Stored<UserFormRevision>>>;
 export declare const selectLatestFormRevisionByForm: Selector<Record<Stored<UserForm>["offline_id"], Stored<UserFormRevision>>>;
 export declare const selectUserFormRevisionAttachmentsMapping: Selector<FormRevisionState["attachments"]>;
 export declare const selectAttachmentsOfFormRevision: SelectorWithArgs<string, Stored<UserFormRevisionAttachment>[]>;