@overmap-ai/core 1.0.75-more-clean-ups.0 → 1.0.75

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

@@ -21,13 +21,13 @@ export interface BuildAttachmentPayloadData<TModelId> extends AttachmentPayload
 export declare abstract class BaseAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string | number, TAttachment extends Attachment> extends BaseUploadService<TState, TSDK> {
     abstract readonly name: string;
     abstract readonly url: string;
-    abstract readonly addAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
-    abstract readonly updateAttachments: ActionCreatorWithPayload<Submitted<TAttachment>[]>;
+    abstract readonly addAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
+    abstract readonly updateAttachments: ActionCreatorWithPayload<Stored<TAttachment>[]>;
     abstract readonly removeAttachments: ActionCreatorWithPayload<string[]>;
     abstract readonly setAttachment: ActionCreatorWithPayload<Stored<TAttachment>>;
     abstract readonly removeAttachment: ActionCreatorWithPayload<string>;
     abstract readonly selectAttachment: OvermapSelectorWithArgs<string, Stored<TAttachment> | undefined>;
-    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData<TModelId>): Stored<TAttachment>;
+    protected abstract buildOfflineAttachment(data: BuildOfflineAttachmentData<TModelId>): Submitted<TAttachment>;
     protected abstract buildAttachmentPayload(data: BuildAttachmentPayloadData<TModelId>): AttachmentPayload;
     _bulkAdd(payloads: {
         modelId: TModelId;

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

@@ -5,6 +5,7 @@ import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachme
 export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueAttachment> {
     name: string;
     url: string;
+    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">;

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

@@ -0,0 +1,40 @@
+import { IssueCommentAttachment, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueCommentAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue_comment: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        issue_comment: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        issueCommentId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueCommentAttachment>>;
+    delete(id: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+import { IssueTypeAttachment, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueTypeAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue_type: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+        issue_type: string;
+        modelId: string;
+        offline_id: import('../..').OfflineModel["offline_id"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        issueTypeId: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueTypeAttachment>>;
+    delete(id: string): Promise<void>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -2,7 +2,7 @@ import { OvermapRootState, ProjectAttachment, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment> {
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, Stored<ProjectAttachment>> {
     name: string;
     url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;

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

@@ -24,8 +24,10 @@ export * from './FormSubmissionService';
 export * from './GeoImageService';
 export * from './IssueAssociationService';
 export * from './IssueAttachmentService';
+export * from './IssueCommentAttachmentService';
 export * from './IssueCommentService';
 export * from './IssueService';
+export * from './IssueTypeAttachmentService';
 export * from './IssueTypeFieldsAttachmentService';
 export * from './IssueTypeFieldsService';
 export * from './IssueTypeFieldValuesAttachmentService';

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

@@ -39,8 +39,4 @@ export declare const selectAssetAttachmentMapping: (state: OvermapRootState) =>
 export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
 export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
 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 assetAttachmentReducer: Reducer<AssetAttachmentState>;

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

@@ -57,8 +57,8 @@ export declare const selectAssets: ((state: OvermapRootState) => Stored<Asset>[]
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<string, Asset[]>;
-export declare const selectAssetById: OvermapSelectorWithArgs<string, Asset | undefined>;
+export declare const selectAssetsOfAssetType: OvermapSelectorWithArgs<string, Stored<Asset>[]>;
+export declare const selectAssetById: OvermapSelectorWithArgs<string, Stored<Asset> | undefined>;
 export declare const selectAssetsByIds: (args: string[]) => (state: OvermapRootState) => Stored<Asset>[];
 export declare const selectNumberOfAssetsOfAssetType: OvermapSelectorWithArgs<string, number>;
 export declare const assetReducer: Reducer<AssetState>;

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

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

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

@@ -36,21 +36,21 @@ export declare const assetStageSlice: import('@reduxjs/toolkit').Slice<ModelStat
 }, "assetStages", "assetStages", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetStage>>>>;
 export declare const initializeAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeAssetStages">, setAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setAssetStage">, setAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/setAssetStages">, addAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/addAssetStage">, addAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addAssetStages">, updateAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateAssetStage">, updateAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateAssetStages">, deleteAssetStage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStages/deleteAssetStage">, deleteAssetStages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStages/deleteAssetStages">;
 export declare const assetStageReducer: Reducer<AssetStageState>;
-export declare const selectStageMapping: OvermapSelector<Record<AssetStage["offline_id"], AssetStage>>;
-export declare const selectAssetStageById: OvermapSelectorWithArgs<string, AssetStage | undefined>;
-export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => AssetStage[]) & {
+export declare const selectStageMapping: OvermapSelector<Record<AssetStage["offline_id"], Stored<AssetStage>>>;
+export declare const selectAssetStageById: OvermapSelectorWithArgs<string, Stored<AssetStage> | undefined>;
+export declare const selectAssetStages: ((state: import('../..').OvermapRootState) => Stored<AssetStage>[]) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[];
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, AssetStage>) => AssetStage[]) & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetStage>>) => Stored<AssetStage>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetStage>>) => Stored<AssetStage>[]) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => AssetStage[];
-    dependencies: [OvermapSelector<Record<string, AssetStage>>];
+    lastResult: () => Stored<AssetStage>[];
+    dependencies: [OvermapSelector<Record<string, Stored<AssetStage>>>];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;
@@ -59,6 +59,6 @@ export declare const selectAssetStages: ((state: import('../..').OvermapRootStat
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeStagesMapping: OvermapSelectorWithArgs<string, Record<string, AssetStage>>;
-export declare const selectStagesOfAssetType: OvermapSelectorWithArgs<string, AssetStage[]>;
+export declare const selectAssetTypeStagesMapping: OvermapSelectorWithArgs<string, Record<string, Stored<AssetStage>>>;
+export declare const selectStagesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetStage>[]>;
 export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../..').OvermapRootState) => Stored<AssetStage>[];

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

@@ -39,8 +39,4 @@ export declare const selectAssetTypeAttachmentMapping: (state: OvermapRootState)
 export declare const selectAssetTypeAttachments: OvermapSelector<Stored<AssetTypeAttachment>[]>;
 export declare const selectAssetTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
 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 assetTypeAttachmentReducer: Reducer<AssetTypeAttachmentState>;

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

@@ -57,7 +57,7 @@ export declare const selectAssetTypeFieldValuesAttachments: ((state: OvermapRoot
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldValuesAttachment | undefined>;
+export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment> | undefined>;
 export declare const selectAssetTypeFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[];
 export declare const selectAttachmentsOfAssetTypeFieldValues: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment>[]>;
 export declare const assetTypeFieldValuesAttachmentReducer: Reducer<AssetTypeFieldValuesAttachmentState>;

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

@@ -57,7 +57,7 @@ export declare const selectAssetTypeFieldValues: ((state: OvermapRootState) => S
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, AssetTypeFieldValues[]>;
+export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
 export declare const selectAssetTypeValuesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
-export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, AssetTypeFieldValues | undefined>;
+export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues> | undefined>;
 export declare const assetTypeFieldValuesReducer: Reducer<AssetTypeFieldValuesState>;

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

@@ -57,6 +57,6 @@ export declare const selectAssetTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment[]>;
-export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment | undefined>;
+export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment>[]>;
+export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment> | undefined>;
 export declare const assetTypeFieldsAttachmentReducer: Reducer<AssetTypeFieldsAttachmentState>;

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

@@ -57,7 +57,7 @@ export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields[]>;
-export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
-export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+export declare const selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFields>[]>;
+export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFields> | undefined>;
+export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, Stored<AssetTypeFields> | undefined>;
 export declare const assetTypeFieldsReducer: Reducer<AssetTypeFieldsState>;

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

@@ -35,8 +35,8 @@ export declare const assetTypeSlice: import('@reduxjs/toolkit').Slice<AssetTypeS
     deleteAssetTypes: (state: ModelState<Stored<AssetType>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "assetTypes", "assetTypes", import('@reduxjs/toolkit').SliceSelectors<AssetTypeState>>;
 export declare const initializeAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/initializeAssetTypes">, setAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/setAssetType">, setAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/setAssetTypes">, addAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/addAssetType">, addAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/addAssetTypes">, updateAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>, "assetTypes/updateAssetType">, updateAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetType>[], "assetTypes/updateAssetTypes">, deleteAssetType: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, deleteAssetTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypes/deleteAssetTypes">;
-export declare const selectAssetTypesMapping: OvermapSelector<Record<string, AssetType>>;
-export declare const selectAssetTypes: OvermapSelector<AssetType[]>;
+export declare const selectAssetTypesMapping: OvermapSelector<Record<string, Stored<AssetType>>>;
+export declare const selectAssetTypes: OvermapSelector<Stored<AssetType>[]>;
 export declare const selectAssetTypeById: OvermapSelectorWithArgs<AssetType["offline_id"], Stored<AssetType> | undefined>;
 export declare const selectAssetTypesByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetType>[];
 export declare const assetTypeReducer: Reducer<AssetTypeState>;

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

@@ -39,8 +39,4 @@ export declare const selectDocumentAttachmentMapping: (state: OvermapRootState)
 export declare const selectAllDocumentAttachments: OvermapSelector<Stored<DocumentAttachment>[]>;
 export declare const selectDocumentAttachmentById: OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
 export declare const selectAttachmentsOfDocument: (args: string) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
-export declare const selectAttachmentsOfDocumentByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<DocumentAttachment>[];
-    imageAttachments: Stored<DocumentAttachment>[];
-};
 export declare const documentAttachmentReducer: Reducer<DocumentAttachmentState>;

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

@@ -1,19 +1,19 @@
 import { Reducer } from '@reduxjs/toolkit';
-import { EmailDomain, OvermapRootState, OvermapSelector } from '../../typings';
+import { EmailDomain, OvermapRootState, OvermapSelector, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type EmailDomainState = ModelState<EmailDomain>;
-export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<EmailDomain>, {
-    initializeEmailDomains: (state: ModelState<EmailDomain>, action: {
-        payload: EmailDomain[];
+export type EmailDomainState = ModelState<Stored<EmailDomain>>;
+export declare const emailDomainsSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<EmailDomain>>, {
+    initializeEmailDomains: (state: ModelState<Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>[];
         type: string;
     }) => void;
-    addEmailDomain: (state: ModelState<EmailDomain>, action: {
-        payload: EmailDomain;
+    addEmailDomain: (state: ModelState<Stored<EmailDomain>>, action: {
+        payload: Stored<EmailDomain>;
         type: string;
     }) => void;
-    deleteEmailDomain: (state: ModelState<EmailDomain>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<EmailDomain>>>;
-export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<EmailDomain, "emailDomains/addEmailDomain">, deleteEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
+    deleteEmailDomain: (state: ModelState<Stored<EmailDomain>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "emailDomains", "emailDomains", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<EmailDomain>>>>;
+export declare const initializeEmailDomains: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<EmailDomain>[], "emailDomains/initializeEmailDomains">, addEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<EmailDomain>, "emailDomains/addEmailDomain">, deleteEmailDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "emailDomains/deleteEmailDomain">;
 export declare const selectEmailDomainsAsMapping: OvermapSelector<Record<number, EmailDomain>>;
 export declare const selectEmailDomains: ((state: OvermapRootState) => EmailDomain[]) & {
     clearCache: () => void;

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

@@ -46,7 +46,6 @@ export declare const selectFormRevisions: ((state: OvermapRootState) => Stored<F
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectFormRevisionById: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
-export declare const _selectLatestFormRevision: (formRevisions: FormRevisionState["instances"], formId: string) => Stored<FormRevision>;
 export declare const selectLatestFormRevisionOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
 export declare const selectFormRevisionsOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision>[]>;
 export declare const formRevisionReducer: Reducer<FormRevisionState>;

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

@@ -54,4 +54,3 @@ export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[])
     memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;

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

@@ -3,38 +3,38 @@ import { GeoImage, OvermapRootState, Stored } from '../../typings';
 import { ModelState } from '../typings';
 export type GeoImageSliceState = ModelState<Stored<GeoImage>>;
 export declare const geoImageSlice: import('@reduxjs/toolkit').Slice<GeoImageSliceState, {
-    initializeGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    initializeGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    setGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    setGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    setGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    setGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    addGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    addGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    addGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    addGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    updateGeoImage: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage;
+    updateGeoImage: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>;
         type: string;
     }) => void;
-    updateGeoImages: (state: ModelState<GeoImage>, action: {
-        payload: GeoImage[];
+    updateGeoImages: (state: ModelState<Stored<GeoImage>>, action: {
+        payload: Stored<GeoImage>[];
         type: string;
     }) => void;
-    deleteGeoImage: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteGeoImages: (state: ModelState<GeoImage>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteGeoImage: (state: ModelState<Stored<GeoImage>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteGeoImages: (state: ModelState<Stored<GeoImage>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
 }, "geoImages", "geoImages", import('@reduxjs/toolkit').SliceSelectors<GeoImageSliceState>>;
-export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<GeoImage[], "geoImages/updateGeoImages">, deleteGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
+export declare const initializeGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/initializeGeoImages">, setGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/setGeoImage">, setGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/setGeoImages">, addGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/addGeoImage">, addGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/addGeoImages">, updateGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>, "geoImages/updateGeoImage">, updateGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<GeoImage>[], "geoImages/updateGeoImages">, deleteGeoImage: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "geoImages/deleteGeoImage">, deleteGeoImages: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "geoImages/deleteGeoImages">;
 export declare const selectGeoImageMapping: (state: OvermapRootState) => Record<string, Stored<GeoImage>>;
 export declare const selectGeoImages: ((state: OvermapRootState) => Stored<GeoImage>[]) & {
     clearCache: () => void;

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

@@ -23,8 +23,10 @@ export * from './formSubmissionSlice';
 export * from './geoImageSlice';
 export * from './issueAssociationSlice';
 export * from './issueAttachmentSlice';
+export * from './issueCommentAttachmentSlice';
 export * from './issueCommentSlice';
 export * from './issueSlice';
+export * from './issueTypeAttachmentSlice';
 export * from './issueTypeFieldsAttachmentSlice';
 export * from './issueTypeFieldsSlice';
 export * from './issueTypeFieldValuesAttachmentSlice';

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

@@ -39,8 +39,4 @@ export declare const selectIssueAttachmentMapping: (state: OvermapRootState) =>
 export declare const selectIssueAttachments: OvermapSelector<Stored<IssueAttachment>[]>;
 export declare const selectAttachmentsOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueAttachment>[];
 export declare const selectIssueAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-export declare const selectAttachmentsOfIssueByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<IssueAttachment>[];
-    imageAttachments: Stored<IssueAttachment>[];
-};
 export declare const issueAttachmentReducer: Reducer<IssueAttachmentState>;

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

@@ -0,0 +1,42 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueCommentAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueCommentAttachmentState = ModelState<Stored<IssueCommentAttachment>>;
+export declare const issueCommentAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<IssueCommentAttachment>>, {
+    initializeIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    addIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>;
+        type: string;
+    }) => void;
+    addIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    setIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>;
+        type: string;
+    }) => void;
+    setIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>;
+        type: string;
+    }) => void;
+    updateIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+        payload: Stored<IssueCommentAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueCommentAttachments", "issueCommentAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<IssueCommentAttachment>>>>;
+export declare const initializeIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">, addIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/addIssueCommentAttachment">, addIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">, setIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">, setIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/setIssueCommentAttachments">, updateIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/updateIssueCommentAttachment">, updateIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">, deleteIssueCommentAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">, deleteIssueCommentAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
+export declare const selectIssueCommentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueCommentAttachment>>;
+export declare const selectIssueCommentAttachments: OvermapSelector<Stored<IssueCommentAttachment>[]>;
+export declare const selectIssueCommentAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
+export declare const selectAttachmentsOfIssueComment: (args: string) => (state: OvermapRootState) => Stored<IssueCommentAttachment>[];
+export declare const issueCommentAttachmentReducer: Reducer<IssueCommentAttachmentState>;

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

@@ -0,0 +1,42 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeAttachmentState = ModelState<Stored<IssueTypeAttachment>>;
+export declare const issueTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<IssueTypeAttachment>>, {
+    initializeIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+        payload: Stored<IssueTypeAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeAttachments", "issueTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<IssueTypeAttachment>>>>;
+export declare const initializeIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">, addIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/addIssueTypeAttachment">, addIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">, setIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">, setIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/setIssueTypeAttachments">, updateIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/updateIssueTypeAttachment">, updateIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">, deleteIssueTypeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">, deleteIssueTypeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+export declare const selectIssueTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeAttachment>>;
+export declare const selectIssueTypeAttachments: OvermapSelector<Stored<IssueTypeAttachment>[]>;
+export declare const selectIssueTypeAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+export declare const selectAttachmentsOfIssueType: (args: string) => (state: OvermapRootState) => Stored<IssueTypeAttachment>[];
+export declare const issueTypeAttachmentReducer: Reducer<IssueTypeAttachmentState>;

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

@@ -57,6 +57,6 @@ export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment[]>;
-export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, IssueTypeFieldsAttachment | undefined>;
+export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment>[]>;
+export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment> | undefined>;
 export declare const issueTypeFieldsAttachmentReducer: Reducer<IssueTypeFieldsAttachmentState>;