@overmap-ai/core 1.0.59 → 1.0.60-model-adapter.0

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

@@ -1,10 +1,16 @@
 import { BaseAttachmentService } from "./BaseAttachmentService";
-import { AttachmentModel, AssetAttachment } from "../../typings";
+import { AttachmentModel, AssetAttachment, Stored } from "../../typings";
 import { OptimisticMultipleModelResult } from "../typings";
-export declare class AssetAttachmentService extends BaseAttachmentService {
+export declare class AssetAttachmentService extends BaseAttachmentService<string, AssetAttachment> {
     attachmentModel: AttachmentModel;
+    initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">;
+    addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">;
+    updateAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">;
+    removeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
+    removeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">;
+    setAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">;
+    selectAttachment: import('../../typings/store').SelectorWithArgs<string, Stored<AssetAttachment>>;
     private buildOfflineAttachment;
     attachFilesToAsset(files: File[], assetId: string): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
     deleteAssetAttachment(attachmentId: string): Promise<void>;
-    refreshStore(): Promise<void>;
 }

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

@@ -1,10 +1,16 @@
 import { BaseAttachmentService } from "./BaseAttachmentService";
-import { AttachmentModel, AssetTypeAttachment } from "../../typings";
+import { AttachmentModel, AssetTypeAttachment, Stored } from "../../typings";
 import { OptimisticMultipleModelResult } from "../typings";
-export declare class AssetTypeAttachmentService extends BaseAttachmentService {
+export declare class AssetTypeAttachmentService extends BaseAttachmentService<string, AssetTypeAttachment> {
     attachmentModel: AttachmentModel;
+    initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/initializeAssetTypeAttachments">;
+    addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/addAssetTypeAttachments">;
+    updateAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypeAttachments/updateAssetTypeAttachments">;
+    removeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetTypeAttachments/deleteAssetTypeAttachments">;
+    removeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypeAttachments/deleteAssetTypeAttachment">;
+    setAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypeAttachments/setAssetTypeAttachment">;
+    selectAttachment: import('../../typings/store').SelectorWithArgs<string, Stored<AssetTypeAttachment>>;
     private buildOfflineAttachment;
     attachFilesToAssetType(files: File[], assetTypeId: string): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
     deleteAssetTypeAttachment(attachmentId: string): Promise<void>;
-    refreshStore(): Promise<void>;
 }

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

@@ -10,22 +10,18 @@ export interface BuildOfflineAttachmentData<TModelId> {
     description?: string;
     modelId: TModelId;
 }
-export declare abstract class BaseAttachmentService extends BaseApiService {
+export declare abstract class BaseAttachmentService<TModelId extends string | number, TAttachment extends Attachment> extends BaseApiService {
     abstract readonly attachmentModel: AttachmentModel;
+    abstract readonly initializeAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly addAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly updateAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly removeAttachments: ActionCreatorWithPayload<string[]>;
+    abstract readonly setAttachment: ActionCreatorWithPayload<Stored<TAttachment>>;
+    abstract readonly removeAttachment: ActionCreatorWithPayload<string>;
+    abstract readonly selectAttachment: SelectorWithArgs<string, Stored<TAttachment>>;
     private getNumberOfAttachmentsWithSha1;
     private processPresignedUrls;
-    protected getAttachments<TAttachment extends Attachment>(actions: {
-        setAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
-    }): Promise<void>;
-    protected attachFiles<TAttachment extends Attachment, TModelId = string | number>(files: File[], modelId: TModelId, buildOfflineAttachment: (data: BuildOfflineAttachmentData<TModelId>) => Stored<TAttachment>, actions: {
-        addAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
-        updateAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
-        removeAttachments: ActionCreatorWithPayload<string[]>;
-    }): Promise<OptimisticMultipleModelResult<TAttachment>>;
-    protected deleteAttachment<TAttachment extends Attachment>(attachmendId: string, actions: {
-        setAttachment: ActionCreatorWithPayload<Stored<TAttachment>>;
-        removeAttachment: ActionCreatorWithPayload<string>;
-    }, selectors: {
-        selectAttachment: SelectorWithArgs<string, Stored<TAttachment>>;
-    }): Promise<void>;
+    protected attachFiles(files: File[], modelId: TModelId, buildOfflineAttachment: (data: BuildOfflineAttachmentData<TModelId>) => Stored<TAttachment>): Promise<OptimisticMultipleModelResult<TAttachment>>;
+    protected deleteAttachment(attachmendId: string): Promise<void>;
+    refreshStore(): Promise<void>;
 }

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

@@ -1,32 +1,13 @@
 import { BaseApiService } from "./BaseApiService";
 import { Category, Offline, Payload } from "../../typings";
-import { OptimisticGenericResult, OptimisticModelResult } from "../typings";
+import { OptimisticModelResult } from "../typings";
 /**
  * Handles the creation of Category Service
  * TODO: Support editing and deleting categories
  */
 export declare class CategoryService extends BaseApiService {
     add(category: Omit<Payload<Category>, "workspace">, workspaceId: string): OptimisticModelResult<Category>;
-    fetchAll(projectId: number): OptimisticGenericResult<Category[]>;
     update(category: Offline<Partial<Category>>, workspaceId: string): OptimisticModelResult<Category>;
     remove(category: Category, workspaceId: string): Promise<undefined>;
-    /**
-     * Overwrites the store with whatever categories are on the server.
-     * @returns A promise that resolves to an empty result.
-     * @throws An APIError if the request fails.
-     * @throws An Error if there is no active project, or for any other unexpected error.
-     * @example
-     * ```typescript
-     * try {
-     * 	 await sdk.category.refreshStore()
-     * } catch (e) {
-     * 	 if (e instanceof APIError) {
-     * 	   // handle error
-     * 	   return
-     * 	 }
-     * 	 throw e
-     * }
-     * ```
-     */
     refreshStore(): Promise<undefined>;
 }

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

@@ -1,10 +1,16 @@
 import { BaseAttachmentService } from "./BaseAttachmentService";
-import { AttachmentModel, DocumentAttachment } from "../../typings";
+import { AttachmentModel, DocumentAttachment, Stored } from "../../typings";
 import { OptimisticMultipleModelResult } from "../typings";
-export declare class DocumentAttachmentService extends BaseAttachmentService {
+export declare class DocumentAttachmentService extends BaseAttachmentService<string, DocumentAttachment> {
     attachmentModel: AttachmentModel;
+    initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/initializeDocumentAttachments">;
+    addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/addDocumentAttachments">;
+    updateAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documentAttachments/updateDocumentAttachments">;
+    removeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documentAttachments/deleteDocumentAttachments">;
+    removeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "documentAttachments/deleteDocumentAttachment">;
+    setAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documentAttachments/setDocumentAttachment">;
+    selectAttachment: import('../../typings/store').SelectorWithArgs<string, Stored<DocumentAttachment>>;
     private buildOfflineAttachment;
     attachFilesToDocument(files: File[], documentId: string): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
     deleteDocumentAttachment(attachmentId: string): Promise<void>;
-    refreshStore(): Promise<void>;
 }

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

@@ -1,7 +1,6 @@
 import { BaseApiService } from "./BaseApiService";
 import { EmailDomain } from "../../typings";
 export declare class EmailDomainsService extends BaseApiService {
-    fetchAll(orgId: number): Promise<EmailDomain[]>;
     add(orgId: number, email: string): Promise<undefined>;
     remove(emailDomain: EmailDomain): Promise<undefined>;
     refreshStore(): Promise<undefined>;

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

@@ -1,10 +1,16 @@
 import { BaseAttachmentService } from "./BaseAttachmentService";
 import { OptimisticMultipleModelResult } from "../typings";
-import { AttachmentModel, IssueAttachment } from "../../typings";
-export declare class IssueAttachmentService extends BaseAttachmentService {
+import { AttachmentModel, IssueAttachment, Stored } from "../../typings";
+export declare class IssueAttachmentService extends BaseAttachmentService<string, IssueAttachment> {
     attachmentModel: AttachmentModel;
+    initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
+    addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
+    updateAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
+    removeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
+    removeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">;
+    setAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">;
+    selectAttachment: import('../../typings/store').SelectorWithArgs<string, Stored<IssueAttachment>>;
     private buildOfflineAttachment;
     attachFilesToIssue(files: File[], issueId: string): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
     deleteIssueAttachment(attachmentId: string): Promise<void>;
-    refreshStore(): Promise<void>;
 }

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

@@ -1,12 +1,11 @@
 import { BaseApiService } from "./BaseApiService";
-import { OptimisticModelResult, OptimisticMultipleModelResult } from "../typings";
+import { OptimisticModelResult } from "../typings";
 import { Issue, IssueType, Submitted } from "../../typings";
 /**
  * Handles CRUD operations on issues
  */
 export declare class IssueService extends BaseApiService {
     add(issue: Issue, issueType?: IssueType["offline_id"] | null): OptimisticModelResult<Issue>;
-    fetchAll(projectId: number): OptimisticMultipleModelResult<Issue>;
     update(issue: Submitted<Partial<Issue>>): OptimisticModelResult<Issue>;
     remove(id: string): Promise<undefined>;
     refreshStore(): Promise<undefined>;

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

@@ -1,10 +1,16 @@
 import { BaseAttachmentService } from "./BaseAttachmentService";
-import { AttachmentModel, ProjectAttachment } from "../../typings";
+import { AttachmentModel, ProjectAttachment, Stored } from "../../typings";
 import { OptimisticMultipleModelResult } from "../typings";
-export declare class ProjectAttachmentService extends BaseAttachmentService {
+export declare class ProjectAttachmentService extends BaseAttachmentService<number, ProjectAttachment> {
     attachmentModel: AttachmentModel;
+    initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
+    addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
+    updateAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
+    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>;
     private buildOfflineAttachment;
     attachFilesToProject(files: File[], projectId: number): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
     deleteProjectAttachment(attachmentId: string): Promise<void>;
-    refreshStore(): Promise<void>;
 }

package/dist/store/adapter.d.ts

@@ -0,0 +1,15 @@
+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;
+    getInitialState: <TState extends object>(state: TState) => TState & ModelState<TModel>;
+}
+export declare function createModelAdapter<TModel>(computeModelId: (model: TModel) => string): OvermapModelAdapter<TModel>;

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

@@ -1,16 +1,27 @@
-import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { AgentUserConversation, Offline, OfflineIdMapping, RootState, Selector } from "../../typings";
-export interface AgentsState {
-    conversations: OfflineIdMapping<AgentUserConversation>;
-}
-export declare const agentsSlice: import("@reduxjs/toolkit").Slice<AgentsState, {
-    setConversations: (state: import("immer/dist/internal.js").WritableDraft<AgentsState>, action: PayloadAction<AgentUserConversation[]>) => void;
-    addConversation: (state: import("immer/dist/internal.js").WritableDraft<AgentsState>, action: PayloadAction<AgentUserConversation>) => void;
-    setConversation: (state: import("immer/dist/internal.js").WritableDraft<AgentsState>, action: PayloadAction<AgentUserConversation>) => void;
-    updateConversation: (state: import("immer/dist/internal.js").WritableDraft<AgentsState>, action: PayloadAction<Offline<Partial<AgentUserConversation>>>) => void;
+import { Reducer } from "@reduxjs/toolkit";
+import { AgentUserConversation, RootState, Selector } 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: {
+        payload: AgentUserConversation[];
+        type: string;
+    }) => void;
+    addConversation: <TState_1 extends ModelState<AgentUserConversation>>(state: TState_1, action: {
+        payload: AgentUserConversation;
+        type: string;
+    }) => void;
+    setConversation: <TState_2 extends ModelState<AgentUserConversation>>(state: TState_2, action: {
+        payload: AgentUserConversation;
+        type: string;
+    }) => void;
+    updateConversation: <TState_3 extends ModelState<AgentUserConversation>>(state: TState_3, action: {
+        payload: AgentUserConversation;
+        type: string;
+    }) => 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 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 agentsReducer: Reducer<AgentsState>;

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

@@ -0,0 +1,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import { ModelState } from "../typings";
+import { AssetAttachment, RootState, Selector, SelectorWithArgs, 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: {
+        payload: Stored<AssetAttachment>[];
+        type: string;
+    }) => void;
+    addAssetAttachment: <TState_1 extends ModelState<Stored<AssetAttachment>>>(state: TState_1, action: {
+        payload: Stored<AssetAttachment>;
+        type: string;
+    }) => void;
+    addAssetAttachments: <TState_2 extends ModelState<Stored<AssetAttachment>>>(state: TState_2, action: {
+        payload: Stored<AssetAttachment>[];
+        type: string;
+    }) => void;
+    setAssetAttachment: <TState_3 extends ModelState<Stored<AssetAttachment>>>(state: TState_3, action: {
+        payload: Stored<AssetAttachment>;
+        type: string;
+    }) => void;
+    setAssetAttachments: <TState_4 extends ModelState<Stored<AssetAttachment>>>(state: TState_4, action: {
+        payload: Stored<AssetAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetAttachment: <TState_5 extends ModelState<Stored<AssetAttachment>>>(state: TState_5, action: {
+        payload: Stored<AssetAttachment>;
+        type: string;
+    }) => void;
+    updateAssetAttachments: <TState_6 extends ModelState<Stored<AssetAttachment>>>(state: TState_6, 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">;
+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) => {
+    fileAttachments: Stored<AssetAttachment>[];
+    imageAttachments: Stored<AssetAttachment>[];
+};
+export declare const assetAttachmentReducer: Reducer<AssetAttachmentState>;

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

@@ -1,65 +1,24 @@
 import { PayloadAction, Reducer } from "@reduxjs/toolkit";
-import { Asset, AssetAttachment, AssetType, RootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
-export interface AssetState {
-    assets: Record<string, Asset | Submitted<Asset>>;
-    attachments: Record<string, Stored<AssetAttachment>>;
-}
+import { Asset, AssetType, RootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
+import { ModelState } from "../typings";
+export type AssetState = ModelState<Stored<Asset>>;
 export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
+    initializeAssets: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset[]>) => void;
     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;
+    addAssets: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<(Asset | Submitted<Asset>)[]>) => void;
+    setAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<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;
     updateAssets: (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;
-    removeAssets: (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;
+    deleteAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string>) => void;
+    deleteAssets: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string[]>) => void;
 }, "assets">;
-export declare const addAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/addAsset">, updateAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/updateAsset">, updateAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset[], "assets/updateAssets">, removeAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAsset">, removeAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assets/removeAssets">, 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 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, Asset | Submitted<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 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) => {
-    fileAttachments: Stored<AssetAttachment>[];
-    imageAttachments: Stored<AssetAttachment>[];
-};
 export declare const assetReducer: Reducer<AssetState>;

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

@@ -1,19 +1,32 @@
-import { Reducer, PayloadAction } from "@reduxjs/toolkit";
-import { AssetStage, RootState, 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;
+import { Reducer } from "@reduxjs/toolkit";
+import { AssetStage, RootState, SelectorWithArgs, Stored } from "../../typings";
+import { ModelState } from "../typings";
+export type AssetStageState = ModelState<Stored<AssetStage>>;
+export declare const assetStageSlice: import("@reduxjs/toolkit").Slice<ModelState<Stored<AssetStage>>, {
+    initializeStages: <TState extends ModelState<Stored<AssetStage>>>(state: TState, action: {
+        payload: Stored<AssetStage>[];
+        type: string;
+    }) => void;
+    setStage: <TState_1 extends ModelState<Stored<AssetStage>>>(state: TState_1, action: {
+        payload: Stored<AssetStage>;
+        type: string;
+    }) => void;
+    addStages: <TState_2 extends ModelState<Stored<AssetStage>>>(state: TState_2, action: {
+        payload: Stored<AssetStage>[];
+        type: string;
+    }) => void;
+    updateStage: <TState_3 extends ModelState<Stored<AssetStage>>>(state: TState_3, action: {
+        payload: Stored<AssetStage>;
+        type: string;
+    }) => void;
+    updateStages: <TState_4 extends ModelState<Stored<AssetStage>>>(state: TState_4, action: {
+        payload: Stored<AssetStage>[];
+        type: string;
+    }) => void;
+    removeStages: <TState_5 extends ModelState<Stored<AssetStage>>>(state: TState_5, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetStages">;
 export declare const selectStageMapping: (state: RootState) => Record<string, AssetStage>;
 export declare const selectStage: SelectorWithArgs<string, AssetStage | undefined>;
@@ -23,10 +36,5 @@ export declare const selectAssetTypeStagesMapping: SelectorWithArgs<string, Reco
 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 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

@@ -0,0 +1,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import { AssetTypeAttachment, type RootState, type Selector, type SelectorWithArgs, 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: {
+        payload: Stored<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeAttachment: <TState_1 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_1, action: {
+        payload: Stored<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeAttachments: <TState_2 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_2, action: {
+        payload: Stored<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    setAssetTypeAttachment: <TState_3 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_3, action: {
+        payload: Stored<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeAttachments: <TState_4 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_4, action: {
+        payload: Stored<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeAttachment: <TState_5 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_5, action: {
+        payload: Stored<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeAttachments: <TState_6 extends ModelState<Stored<AssetTypeAttachment>>>(state: TState_6, 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">;
+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) => {
+    fileAttachments: Stored<AssetTypeAttachment>[];
+    imageAttachments: Stored<AssetTypeAttachment>[];
+};
+export declare const assetTypeAttachmentReducer: Reducer<AssetTypeAttachmentState>;

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

@@ -1,57 +1,27 @@
 import type { Reducer } from "@reduxjs/toolkit";
-import type { AssetType, AssetTypeAttachment, RootState, Selector, SelectorWithArgs, Stored } from "../../typings";
-export interface AssetTypeState {
-    assetTypes: Record<string, AssetType>;
+import type { AssetType, Selector, SelectorWithArgs, Stored } from "../../typings";
+import { ModelState } from "../typings";
+export interface AssetTypeState extends ModelState<Stored<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>[];
+    initializeAssetTypes: <TState extends ModelState<Stored<AssetType>>>(state: TState, action: {
+        payload: Stored<AssetType>[];
         type: string;
     }) => void;
-    addAssetTypeAttachment: (state: AssetTypeState, action: {
-        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>;
+    addAssetType: <TState_1 extends ModelState<Stored<AssetType>>>(state: TState_1, action: {
+        payload: Stored<AssetType>;
         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: {
+    deleteAssetType: <TState_2 extends ModelState<Stored<AssetType>>>(state: TState_2, action: {
         payload: string;
         type: string;
     }) => void;
-    removeAssetTypeAttachments: (state: AssetTypeState, action: {
-        payload: string[];
-        type: string;
+    toggleAssetTypeVisibility: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: 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 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>;
@@ -62,13 +32,5 @@ interface selectNumberOfAssetTypesMatchingCaseInsensitiveNameProps {
 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: RootState) => 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: RootState) => Stored<AssetTypeAttachment>[];
-export declare const selectAttachmentsOfAssetTypeByType: (args: string) => (state: RootState) => {
-    fileAttachments: Stored<AssetTypeAttachment>[];
-    imageAttachments: Stored<AssetTypeAttachment>[];
-};
 export declare const assetTypeReducer: Reducer<AssetTypeState>;
 export {};