@overmap-ai/core 1.0.74-procedures.3 → 1.0.74-standardizations.0

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { IssueAssociation, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueAssociationSliceState = ModelState<Stored<IssueAssociation>>;
+export type IssueAssociationSliceState = ModelState<IssueAssociation["uuid"], Stored<IssueAssociation>>;
 export declare const issueAssociationSlice: import('@reduxjs/toolkit').Slice<IssueAssociationSliceState, {
-    initializeIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    initializeIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    addIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
+    addIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    addIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    addIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    setIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
+    setIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    setIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    setIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    updateIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
+    updateIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    updateIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
+    updateIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    deleteIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueAssociation: (state: ModelState<string, Stored<IssueAssociation>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueAssociations: (state: ModelState<string, Stored<IssueAssociation>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueAssociations", "issueAssociations", import('@reduxjs/toolkit').SliceSelectors<IssueAssociationSliceState>>;
 export declare const initializeIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/initializeIssueAssociations">, setIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/setIssueAssociations">, setIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/setIssueAssociation">, updateIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/updateIssueAssociation">, updateIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/updateIssueAssociations">, addIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>, "issueAssociations/addIssueAssociation">, addIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAssociation>[], "issueAssociations/addIssueAssociations">, deleteIssueAssociation: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAssociations/deleteIssueAssociation">, deleteIssueAssociations: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAssociations/deleteIssueAssociations">;
 export declare const selectIssueAssociationMapping: (state: OvermapRootState) => Record<string, Stored<IssueAssociation>>;
@@ -57,8 +62,8 @@ export declare const selectIssueAssociations: ((state: OvermapRootState) => Stor
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectIssueAssociationById: OvermapSelectorWithArgs<string, Stored<IssueAssociation> | undefined>;
+export declare const selectIssueAssociationById: OvermapSelectorWithArgs<IssueAssociation["uuid"], Stored<IssueAssociation> | undefined>;
 export declare const selectIssueAssociationsToIssue: (args: string) => (state: OvermapRootState) => Stored<IssueAssociation>[];
 export declare const selectIssueAssociationsOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueAssociation>[];
 export declare const selectIssueAssociationsOfAsset: (args: string) => (state: OvermapRootState) => Stored<IssueAssociation>[];
-export declare const issueAssociationReducer: Reducer<IssueAssociationSliceState>;
+export declare const issueAssociationReducer: import('redux').Reducer<IssueAssociationSliceState>;

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

@@ -1,42 +1,47 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { IssueAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueAttachmentState = ModelState<Stored<IssueAttachment>>;
+export type IssueAttachmentState = ModelState<IssueAttachment["uuid"], Stored<IssueAttachment>>;
 export declare const issueAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueAttachmentState, {
-    initializeIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    initializeIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    addIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
+    addIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    addIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    addIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    setIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
+    setIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    setIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    setIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    updateIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
+    updateIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    updateIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
+    updateIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    deleteIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueAttachment: (state: ModelState<string, Stored<IssueAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueAttachments: (state: ModelState<string, Stored<IssueAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueAttachments", "issueAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueAttachmentState>>;
 export declare const initializeIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">, addIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/addIssueAttachment">, addIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">, setIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">, setIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/setIssueAttachments">, updateIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/updateIssueAttachment">, updateIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">, deleteIssueAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">, deleteIssueAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
 export declare const selectIssueAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueAttachment>>;
 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 issueAttachmentReducer: Reducer<IssueAttachmentState>;
+export declare const selectIssueAttachmentById: OvermapSelectorWithArgs<IssueAttachment["uuid"], Stored<IssueAttachment> | undefined>;
+export declare const issueAttachmentReducer: import('redux').Reducer<IssueAttachmentState>;

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

@@ -1,42 +1,47 @@
-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: {
+export type IssueCommentAttachmentState = ModelState<IssueCommentAttachment["uuid"], Stored<IssueCommentAttachment>>;
+export declare const issueCommentAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueCommentAttachmentState, {
+    initializeIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    addIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    addIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>;
         type: string;
     }) => void;
-    addIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    addIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    setIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    setIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>;
         type: string;
     }) => void;
-    setIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    setIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>[];
         type: string;
     }) => void;
-    updateIssueCommentAttachment: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    updateIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
         payload: Stored<IssueCommentAttachment>;
         type: string;
     }) => void;
-    updateIssueCommentAttachments: (state: ModelState<Stored<IssueCommentAttachment>>, action: {
+    updateIssueCommentAttachments: (state: ModelState<string, 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>>>>;
+    deleteIssueCommentAttachment: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueCommentAttachments: (state: ModelState<string, Stored<IssueCommentAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "issueCommentAttachments", "issueCommentAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueCommentAttachmentState>>;
 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 selectIssueCommentAttachmentById: OvermapSelectorWithArgs<IssueCommentAttachment["uuid"], Stored<IssueCommentAttachment> | undefined>;
 export declare const selectAttachmentsOfIssueComment: (args: string) => (state: OvermapRootState) => Stored<IssueCommentAttachment>[];
-export declare const issueCommentAttachmentReducer: Reducer<IssueCommentAttachmentState>;
+export declare const issueCommentAttachmentReducer: import('redux').Reducer<IssueCommentAttachmentState>;

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

@@ -1,29 +1,34 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { IssueComment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueCommentState = ModelState<Stored<IssueComment>>;
+export type IssueCommentState = ModelState<IssueComment["uuid"], Stored<IssueComment>>;
 export declare const issueCommentSlice: import('@reduxjs/toolkit').Slice<IssueCommentState, {
-    addIssueComment: (state: ModelState<Stored<IssueComment>>, action: {
+    addIssueComment: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>;
         type: string;
     }) => void;
-    addIssueComments: (state: ModelState<Stored<IssueComment>>, action: {
+    addIssueComments: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>[];
         type: string;
     }) => void;
-    setIssueComment: (state: ModelState<Stored<IssueComment>>, action: {
+    setIssueComment: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>;
         type: string;
     }) => void;
-    setIssueComments: (state: ModelState<Stored<IssueComment>>, action: {
+    setIssueComments: (state: ModelState<string, Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>[];
         type: string;
     }) => void;
-    deleteIssueComment: (state: ModelState<Stored<IssueComment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueComments: (state: ModelState<Stored<IssueComment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueComment: (state: ModelState<string, Stored<IssueComment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueComments: (state: ModelState<string, Stored<IssueComment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueComments", "issueComments", import('@reduxjs/toolkit').SliceSelectors<IssueCommentState>>;
 export declare const setIssueComments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/setIssueComments">, setIssueComment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/setIssueComment">, addIssueComment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/addIssueComment">, addIssueComments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/addIssueComments">, deleteIssueComment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueComments/deleteIssueComment">, deleteIssueComments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueComments/deleteIssueComments">;
 export declare const selectIssueCommentMapping: (state: OvermapRootState) => Record<string, Stored<IssueComment>>;
-export declare const selectIssueCommentById: OvermapSelectorWithArgs<string, Stored<IssueComment> | undefined>;
+export declare const selectIssueCommentById: OvermapSelectorWithArgs<IssueComment["uuid"], Stored<IssueComment> | undefined>;
 export declare const selectCommentsOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueComment>[];
-export declare const issueCommentReducer: Reducer<IssueCommentState>;
+export declare const issueCommentReducer: import('redux').Reducer<IssueCommentState>;

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

@@ -1,29 +1,34 @@
-import { Reducer } from '@reduxjs/toolkit';
 import { Issue, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueState = ModelState<Stored<Issue>>;
+export type IssueState = ModelState<Issue["uuid"], Stored<Issue>>;
 export declare const issueSlice: import('@reduxjs/toolkit').Slice<IssueState, {
-    initializeIssues: (state: ModelState<Stored<Issue>>, action: {
+    initializeIssues: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>[];
         type: string;
     }) => void;
-    addIssue: (state: ModelState<Stored<Issue>>, action: {
+    addIssue: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>;
         type: string;
     }) => void;
-    addIssues: (state: ModelState<Stored<Issue>>, action: {
+    addIssues: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>[];
         type: string;
     }) => void;
-    updateIssue: (state: ModelState<Stored<Issue>>, action: {
+    updateIssue: (state: ModelState<string, Stored<Issue>>, action: {
         payload: Stored<Issue>;
         type: string;
     }) => void;
-    deleteIssue: (state: ModelState<Stored<Issue>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssues: (state: ModelState<Stored<Issue>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssue: (state: ModelState<string, Stored<Issue>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssues: (state: ModelState<string, Stored<Issue>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issues", "issues", import('@reduxjs/toolkit').SliceSelectors<IssueState>>;
 export declare const initializeIssues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/initializeIssues">, addIssue: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/addIssue">, addIssues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/addIssues">, updateIssue: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/updateIssue">, deleteIssue: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issues/deleteIssue">, deleteIssues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issues/deleteIssues">;
 export declare const selectIssueMapping: (state: OvermapRootState) => Record<string, Stored<Issue>>;
-export declare const selectIssueById: OvermapSelectorWithArgs<string, Stored<Issue> | undefined>;
+export declare const selectIssueById: OvermapSelectorWithArgs<Issue["uuid"], Stored<Issue> | undefined>;
 export declare const selectIssuesByIds: (args: string[]) => (state: OvermapRootState) => Stored<Issue>[];
-export declare const issueReducer: Reducer<IssueState>;
+export declare const issueReducer: import('redux').Reducer<IssueState>;

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

@@ -1,42 +1,47 @@
-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: {
+export type IssueTypeAttachmentState = ModelState<IssueTypeAttachment["uuid"], Stored<IssueTypeAttachment>>;
+export declare const issueTypeAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueTypeAttachmentState, {
+    initializeIssueTypeAttachments: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
         payload: Stored<IssueTypeAttachment>[];
         type: string;
     }) => void;
-    addIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+    addIssueTypeAttachment: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
         payload: Stored<IssueTypeAttachment>;
         type: string;
     }) => void;
-    addIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+    addIssueTypeAttachments: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
         payload: Stored<IssueTypeAttachment>[];
         type: string;
     }) => void;
-    setIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+    setIssueTypeAttachment: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
         payload: Stored<IssueTypeAttachment>;
         type: string;
     }) => void;
-    setIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+    setIssueTypeAttachments: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
         payload: Stored<IssueTypeAttachment>[];
         type: string;
     }) => void;
-    updateIssueTypeAttachment: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+    updateIssueTypeAttachment: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
         payload: Stored<IssueTypeAttachment>;
         type: string;
     }) => void;
-    updateIssueTypeAttachments: (state: ModelState<Stored<IssueTypeAttachment>>, action: {
+    updateIssueTypeAttachments: (state: ModelState<string, 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>>>>;
+    deleteIssueTypeAttachment: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeAttachments: (state: ModelState<string, Stored<IssueTypeAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "issueTypeAttachments", "issueTypeAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueTypeAttachmentState>>;
 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 selectIssueTypeAttachmentById: OvermapSelectorWithArgs<IssueTypeAttachment["uuid"], Stored<IssueTypeAttachment> | undefined>;
 export declare const selectAttachmentsOfIssueType: (args: string) => (state: OvermapRootState) => Stored<IssueTypeAttachment>[];
-export declare const issueTypeAttachmentReducer: Reducer<IssueTypeAttachmentState>;
+export declare const issueTypeAttachmentReducer: import('redux').Reducer<IssueTypeAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { IssueTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueTypeFieldValuesAttachmentState = ModelState<Stored<IssueTypeFieldValuesAttachment>>;
+export type IssueTypeFieldValuesAttachmentState = ModelState<IssueTypeFieldValuesAttachment["uuid"], Stored<IssueTypeFieldValuesAttachment>>;
 export declare const issueTypeFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldValuesAttachmentState, {
-    initializeIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    initializeIssueTypeFieldValuesAttachments: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    addIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    addIssueTypeFieldValuesAttachment: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    addIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    addIssueTypeFieldValuesAttachments: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    setIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    setIssueTypeFieldValuesAttachment: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    setIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    setIssueTypeFieldValuesAttachments: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    updateIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    updateIssueTypeFieldValuesAttachment: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>;
         type: string;
     }) => void;
-    updateIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+    updateIssueTypeFieldValuesAttachments: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
         payload: Stored<IssueTypeFieldValuesAttachment>[];
         type: string;
     }) => void;
-    deleteIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueTypeFieldValuesAttachment: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldValuesAttachments: (state: ModelState<string, Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueTypeFieldValuesAttachments", "issueTypeFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldValuesAttachmentState>>;
 export declare const initializeIssueTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/initializeIssueTypeFieldValuesAttachments">, addIssueTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachment">, addIssueTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachments">, setIssueTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachment">, setIssueTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachments">, updateIssueTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachment">, updateIssueTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachments">, deleteIssueTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldValuesAttachments/deleteIssueTypeFieldValuesAttachment">, deleteIssueTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldValuesAttachments/deleteIssueTypeFieldValuesAttachments">;
 export declare const selectIssueTypeFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValuesAttachment>>;
@@ -57,7 +62,7 @@ export declare const selectIssueTypeFieldValuesAttachments: ((state: OvermapRoot
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectIssueTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment> | undefined>;
+export declare const selectIssueTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<IssueTypeFieldValuesAttachment["uuid"], Stored<IssueTypeFieldValuesAttachment> | undefined>;
 export declare const selectIssueTypeFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeFieldValuesAttachment>[];
-export declare const selectAttachmentsOfIssueTypeFieldValues: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment>[]>;
-export declare const issueTypeFieldValuesAttachmentReducer: Reducer<IssueTypeFieldValuesAttachmentState>;
+export declare const selectAttachmentsOfIssueTypeFieldValues: OvermapSelectorWithArgs<IssueTypeFieldValues["uuid"], Stored<IssueTypeFieldValuesAttachment>[]>;
+export declare const issueTypeFieldValuesAttachmentReducer: import('redux').Reducer<IssueTypeFieldValuesAttachmentState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { Issue, IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueTypeFieldValuesState = ModelState<Stored<IssueTypeFieldValues>>;
+export type IssueTypeFieldValuesState = ModelState<IssueTypeFieldValues["uuid"], Stored<IssueTypeFieldValues>>;
 export declare const issueTypeFieldValuesSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldValuesState, {
-    initializeIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    initializeIssueTypeFieldValues: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    addIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    addIssueTypeFieldValues: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>;
         type: string;
     }) => void;
-    addIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    addIssueTypeFieldValuesMany: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    setIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    setIssueTypeFieldValues: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>;
         type: string;
     }) => void;
-    setIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    setIssueTypeFieldValuesMany: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    updateIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    updateIssueTypeFieldValues: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>;
         type: string;
     }) => void;
-    updateIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+    updateIssueTypeFieldValuesMany: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
         payload: Stored<IssueTypeFieldValues>[];
         type: string;
     }) => void;
-    deleteIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueTypeFieldValues: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldValuesMany: (state: ModelState<string, Stored<IssueTypeFieldValues>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueTypeFieldValues", "issueTypeFieldValues", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldValuesState>>;
 export declare const initializeIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/initializeIssueTypeFieldValues">, addIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/addIssueTypeFieldValues">, addIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/addIssueTypeFieldValuesMany">, setIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/setIssueTypeFieldValues">, setIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/setIssueTypeFieldValuesMany">, updateIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/updateIssueTypeFieldValues">, updateIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/updateIssueTypeFieldValuesMany">, deleteIssueTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldValues/deleteIssueTypeFieldValues">, deleteIssueTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldValues/deleteIssueTypeFieldValuesMany">;
 export declare const selectIssueTypeFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValues>>;
@@ -57,6 +62,6 @@ export declare const selectIssueTypeFieldValues: ((state: OvermapRootState) => S
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectIssueTypeFieldValuesOfIssue: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues>[]>;
-export declare const selectIssueTypeFieldValuesById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues> | undefined>;
-export declare const issueTypeFieldValuesReducer: Reducer<IssueTypeFieldValuesState>;
+export declare const selectIssueTypeFieldValuesOfIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<IssueTypeFieldValues>[]>;
+export declare const selectIssueTypeFieldValuesById: OvermapSelectorWithArgs<IssueTypeFieldValues["uuid"], Stored<IssueTypeFieldValues> | undefined>;
+export declare const issueTypeFieldValuesReducer: import('redux').Reducer<IssueTypeFieldValuesState>;

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

@@ -1,38 +1,43 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { IssueTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { IssueTypeFields, IssueTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type IssueTypeFieldsAttachmentState = ModelState<Stored<IssueTypeFieldsAttachment>>;
+export type IssueTypeFieldsAttachmentState = ModelState<IssueTypeFieldsAttachment["uuid"], Stored<IssueTypeFieldsAttachment>>;
 export declare const issueTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldsAttachmentState, {
-    initializeIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    initializeIssueTypeFieldsAttachments: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    addIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    addIssueTypeFieldsAttachment: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>;
         type: string;
     }) => void;
-    addIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    addIssueTypeFieldsAttachments: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    setIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    setIssueTypeFieldsAttachment: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>;
         type: string;
     }) => void;
-    setIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    setIssueTypeFieldsAttachments: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    updateIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    updateIssueTypeFieldsAttachment: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>;
         type: string;
     }) => void;
-    updateIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+    updateIssueTypeFieldsAttachments: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
         payload: Stored<IssueTypeFieldsAttachment>[];
         type: string;
     }) => void;
-    deleteIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteIssueTypeFieldsAttachment: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldsAttachments: (state: ModelState<string, Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "issueTypeFieldsAttachments", "issueTypeFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldsAttachmentState>>;
 export declare const initializeIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">, addIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">, addIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">, setIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">, setIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">, updateIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">, updateIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachments">, deleteIssueTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachment">, deleteIssueTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachments">;
 export declare const selectIssueTypeFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldsAttachment>>;
@@ -57,6 +62,6 @@ export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment>[]>;
-export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment> | undefined>;
-export declare const issueTypeFieldsAttachmentReducer: Reducer<IssueTypeFieldsAttachmentState>;
+export declare const selectAttachmentsOfIssueTypeFields: OvermapSelectorWithArgs<IssueTypeFields["uuid"], Stored<IssueTypeFieldsAttachment>[]>;
+export declare const selectIssueTypeFieldsAttachmentById: OvermapSelectorWithArgs<IssueTypeFieldsAttachment["uuid"], Stored<IssueTypeFieldsAttachment> | undefined>;
+export declare const issueTypeFieldsAttachmentReducer: import('redux').Reducer<IssueTypeFieldsAttachmentState>;