@overmap-ai/core 1.0.71-workspace-settings.8 → 1.0.71

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

@@ -1,51 +1,61 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { IssueAssociation, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueAssociation, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type IssueAssociationSliceState = ModelState<Stored<IssueAssociation>>;
-export declare const issueAssociationSlice: import("@reduxjs/toolkit").Slice<IssueAssociationSliceState, {
-    initializeIssueAssociations: <TState extends ModelState<Stored<IssueAssociation>>>(state: TState, action: {
+export declare const issueAssociationSlice: import('@reduxjs/toolkit').Slice<IssueAssociationSliceState, {
+    initializeIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    addIssueAssociation: <TState_1 extends ModelState<Stored<IssueAssociation>>>(state: TState_1, action: {
+    addIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    addIssueAssociations: <TState_2 extends ModelState<Stored<IssueAssociation>>>(state: TState_2, action: {
+    addIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    setIssueAssociation: <TState_3 extends ModelState<Stored<IssueAssociation>>>(state: TState_3, action: {
+    setIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    setIssueAssociations: <TState_4 extends ModelState<Stored<IssueAssociation>>>(state: TState_4, action: {
+    setIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    updateIssueAssociation: <TState_5 extends ModelState<Stored<IssueAssociation>>>(state: TState_5, action: {
+    updateIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>;
         type: string;
     }) => void;
-    updateIssueAssociations: <TState_6 extends ModelState<Stored<IssueAssociation>>>(state: TState_6, action: {
+    updateIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: {
         payload: Stored<IssueAssociation>[];
         type: string;
     }) => void;
-    deleteIssueAssociation: <TState_7 extends ModelState<Stored<IssueAssociation>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueAssociations: <TState_8 extends ModelState<Stored<IssueAssociation>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueAssociations">;
-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">;
+    deleteIssueAssociation: (state: ModelState<Stored<IssueAssociation>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueAssociations: (state: ModelState<Stored<IssueAssociation>>, action: import('@reduxjs/toolkit').PayloadAction<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>>;
-export declare const selectIssueAssociations: ((state: OvermapRootState) => Stored<IssueAssociation>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueAssociation>>) => Stored<IssueAssociation>[], {
-    clearCache: () => void;
-}> & {
+export declare const selectIssueAssociations: ((state: OvermapRootState) => Stored<IssueAssociation>[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueAssociation>>) => Stored<IssueAssociation>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueAssociation>>) => Stored<IssueAssociation>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueAssociation>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueAssociation>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
 };
 export declare const selectIssueAssociationById: OvermapSelectorWithArgs<string, Stored<IssueAssociation> | undefined>;
 export declare const selectIssueAssociationsToIssue: (args: string) => (state: OvermapRootState) => Stored<IssueAssociation>[];

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

@@ -1,46 +1,40 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { IssueAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type IssueAttachmentState = ModelState<Stored<IssueAttachment>>;
-export declare const issueAttachmentSlice: import("@reduxjs/toolkit").Slice<IssueAttachmentState, {
-    initializeIssueAttachments: <TState extends ModelState<Stored<IssueAttachment>>>(state: TState, action: {
+export declare const issueAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueAttachmentState, {
+    initializeIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    addIssueAttachment: <TState_1 extends ModelState<Stored<IssueAttachment>>>(state: TState_1, action: {
+    addIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    addIssueAttachments: <TState_2 extends ModelState<Stored<IssueAttachment>>>(state: TState_2, action: {
+    addIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    setIssueAttachment: <TState_3 extends ModelState<Stored<IssueAttachment>>>(state: TState_3, action: {
+    setIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    setIssueAttachments: <TState_4 extends ModelState<Stored<IssueAttachment>>>(state: TState_4, action: {
+    setIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    updateIssueAttachment: <TState_5 extends ModelState<Stored<IssueAttachment>>>(state: TState_5, action: {
+    updateIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>;
         type: string;
     }) => void;
-    updateIssueAttachments: <TState_6 extends ModelState<Stored<IssueAttachment>>>(state: TState_6, action: {
+    updateIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: {
         payload: Stored<IssueAttachment>[];
         type: string;
     }) => void;
-    deleteIssueAttachment: <TState_7 extends ModelState<Stored<IssueAttachment>>>(state: TState_7, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueAttachments: <TState_8 extends ModelState<Stored<IssueAttachment>>>(state: TState_8, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueAttachments">;
-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">;
+    deleteIssueAttachment: (state: ModelState<Stored<IssueAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueAttachments: (state: ModelState<Stored<IssueAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<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>[];

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

@@ -1,34 +1,28 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { ModelState } from "../typings";
-import type { IssueComment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueComment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type IssueCommentState = ModelState<Stored<IssueComment>>;
-export declare const issueCommentSlice: import("@reduxjs/toolkit").Slice<IssueCommentState, {
-    addIssueComment: <TState extends ModelState<Stored<IssueComment>>>(state: TState, action: {
+export declare const issueCommentSlice: import('@reduxjs/toolkit').Slice<IssueCommentState, {
+    addIssueComment: (state: ModelState<Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>;
         type: string;
     }) => void;
-    addIssueComments: <TState_1 extends ModelState<Stored<IssueComment>>>(state: TState_1, action: {
+    addIssueComments: (state: ModelState<Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>[];
         type: string;
     }) => void;
-    setIssueComment: <TState_2 extends ModelState<Stored<IssueComment>>>(state: TState_2, action: {
+    setIssueComment: (state: ModelState<Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>;
         type: string;
     }) => void;
-    setIssueComments: <TState_3 extends ModelState<Stored<IssueComment>>>(state: TState_3, action: {
+    setIssueComments: (state: ModelState<Stored<IssueComment>>, action: {
         payload: Stored<IssueComment>[];
         type: string;
     }) => void;
-    deleteIssueComment: <TState_4 extends ModelState<Stored<IssueComment>>>(state: TState_4, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssueComments: <TState_5 extends ModelState<Stored<IssueComment>>>(state: TState_5, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issueComments">;
-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">;
+    deleteIssueComment: (state: ModelState<Stored<IssueComment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueComments: (state: ModelState<Stored<IssueComment>>, action: import('@reduxjs/toolkit').PayloadAction<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 selectCommentsOfIssue: (args: string) => (state: OvermapRootState) => Stored<IssueComment>[];

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

@@ -1,40 +1,28 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Issue, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Issue, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type IssueState = ModelState<Stored<Issue>>;
-export declare const issueSlice: import("@reduxjs/toolkit").Slice<IssueState, {
-    initializeIssues: <TState extends ModelState<Stored<Issue>>>(state: TState, action: {
+export declare const issueSlice: import('@reduxjs/toolkit').Slice<IssueState, {
+    initializeIssues: (state: ModelState<Stored<Issue>>, action: {
         payload: Stored<Issue>[];
         type: string;
     }) => void;
-    addIssue: <TState_1 extends ModelState<Stored<Issue>>>(state: TState_1, action: {
+    addIssue: (state: ModelState<Stored<Issue>>, action: {
         payload: Stored<Issue>;
         type: string;
     }) => void;
-    addIssues: <TState_2 extends ModelState<Stored<Issue>>>(state: TState_2, action: {
+    addIssues: (state: ModelState<Stored<Issue>>, action: {
         payload: Stored<Issue>[];
         type: string;
     }) => void;
-    updateIssue: <TState_3 extends ModelState<Stored<Issue>>>(state: TState_3, action: {
+    updateIssue: (state: ModelState<Stored<Issue>>, action: {
         payload: Stored<Issue>;
         type: string;
     }) => void;
-    deleteIssue: <TState_4 extends ModelState<Stored<Issue>>>(state: TState_4, action: {
-        payload: string;
-        type: string;
-    }) => void;
-    deleteIssues: <TState_5 extends ModelState<Stored<Issue>>>(state: TState_5, action: {
-        payload: string[];
-        type: string;
-    }) => void;
-}, "issues">;
-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 interface IssueFilterArgs {
-    filterByAssignedTo: boolean;
-    filterByStatus: boolean;
-    filterByCategory: boolean;
-    filterByWorkspace: boolean;
-}
+    deleteIssue: (state: ModelState<Stored<Issue>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssues: (state: ModelState<Stored<Issue>>, action: import('@reduxjs/toolkit').PayloadAction<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 selectIssuesByIds: (args: string[]) => (state: OvermapRootState) => Stored<Issue>[];

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

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeFieldValuesAttachmentState = ModelState<Stored<IssueTypeFieldValuesAttachment>>;
+export declare const issueTypeFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldValuesAttachmentState, {
+    initializeIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldValuesAttachments: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValuesAttachment: (state: ModelState<Stored<IssueTypeFieldValuesAttachment>>, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValuesAttachments: (state: ModelState<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;
+}, "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>>;
+export declare const selectIssueTypeFieldValuesAttachments: ((state: OvermapRootState) => Stored<IssueTypeFieldValuesAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValuesAttachment>>) => Stored<IssueTypeFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValuesAttachment>>) => Stored<IssueTypeFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectIssueTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, 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>;

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

@@ -0,0 +1,62 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeFieldValuesState = ModelState<Stored<IssueTypeFieldValues>>;
+export declare const issueTypeFieldValuesSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldValuesState, {
+    initializeIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    addIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+        payload: Stored<IssueTypeFieldValues>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    setIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+        payload: Stored<IssueTypeFieldValues>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldValuesMany: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValues: (state: ModelState<Stored<IssueTypeFieldValues>>, action: {
+        payload: Stored<IssueTypeFieldValues>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValuesMany: (state: ModelState<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;
+}, "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>>;
+export declare const selectIssueTypeFieldValues: ((state: OvermapRootState) => Stored<IssueTypeFieldValues>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    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>;

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

@@ -0,0 +1,62 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeFieldsAttachmentState = ModelState<Stored<IssueTypeFieldsAttachment>>;
+export declare const issueTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldsAttachmentState, {
+    initializeIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: Stored<IssueTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: Stored<IssueTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldsAttachments: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFieldsAttachment: (state: ModelState<Stored<IssueTypeFieldsAttachment>>, action: {
+        payload: Stored<IssueTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldsAttachments: (state: ModelState<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;
+}, "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>>;
+export declare const selectIssueTypeFieldsAttachments: ((state: OvermapRootState) => Stored<IssueTypeFieldsAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldsAttachment>>) => Stored<IssueTypeFieldsAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldsAttachment>>) => Stored<IssueTypeFieldsAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldsAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldsAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    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 issueTypeFieldsAttachmentReducer: Reducer<IssueTypeFieldsAttachmentState>;

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

@@ -0,0 +1,64 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { IssueTypeFields, IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type IssueTypeFieldsState = ModelState<Stored<IssueTypeFields>>;
+export declare const issueTypeFieldsSlice: import('@reduxjs/toolkit').Slice<IssueTypeFieldsState, {
+    initializeIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    addIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    setIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeFields: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteIssueTypeFieldsMany: (state: ModelState<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "issueTypeFields", "issueTypeFields", import('@reduxjs/toolkit').SliceSelectors<IssueTypeFieldsState>>;
+export declare const initializeIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/initializeIssueTypeFields">, addIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>, "issueTypeFields/addIssueTypeFields">, addIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/addIssueTypeFieldsMany">, setIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>, "issueTypeFields/setIssueTypeFields">, setIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/setIssueTypeFieldsMany">, updateIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>, "issueTypeFields/updateIssueTypeFields">, updateIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "issueTypeFields/updateIssueTypeFieldsMany">, deleteIssueTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFields/deleteIssueTypeFields">, deleteIssueTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFields/deleteIssueTypeFieldsMany">;
+export declare const selectIssueTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectIssueTypeFields: ((state: OvermapRootState) => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFields<import('@overmap-ai/forms').ISerializedField>>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields>[]>;
+export declare const selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, IssueTypeFields | undefined>;
+export declare const selectIssueTypeValuesOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues>[]>;
+export declare const selectIssueTypeFieldsById: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
+export declare const issueTypeFieldsReducer: Reducer<IssueTypeFieldsState>;

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

@@ -1,30 +1,27 @@
-import { Reducer } from "@reduxjs/toolkit";
-import type { Issue, IssueType, Organization, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
-import type { ModelState } from "../typings";
+import { Reducer } from '@reduxjs/toolkit';
+import { Issue, IssueType, Organization, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
 export type IssueTypeState = ModelState<Stored<IssueType>>;
-export declare const issueTypeSlice: import("@reduxjs/toolkit").Slice<IssueTypeState, {
-    initializeIssueTypes: <TState extends ModelState<Stored<IssueType>>>(state: TState, action: {
+export declare const issueTypeSlice: import('@reduxjs/toolkit').Slice<IssueTypeState, {
+    initializeIssueTypes: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>[];
         type: string;
     }) => void;
-    setIssueType: <TState_1 extends ModelState<Stored<IssueType>>>(state: TState_1, action: {
+    setIssueType: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>;
         type: string;
     }) => void;
-    addIssueType: <TState_2 extends ModelState<Stored<IssueType>>>(state: TState_2, action: {
+    addIssueType: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>;
         type: string;
     }) => void;
-    updateIssueType: <TState_3 extends ModelState<Stored<IssueType>>>(state: TState_3, action: {
+    updateIssueType: (state: ModelState<Stored<IssueType>>, action: {
         payload: Stored<IssueType>;
         type: string;
     }) => void;
-    removeIssueType: <TState_4 extends ModelState<Stored<IssueType>>>(state: TState_4, action: {
-        payload: string;
-        type: string;
-    }) => void;
-}, "issueTypes">;
-export declare const initializeIssueTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/initializeIssueTypes">, setIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/setIssueType">, addIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/addIssueType">, updateIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/updateIssueType">, removeIssueType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "issueTypes/removeIssueType">;
+    removeIssueType: (state: ModelState<Stored<IssueType>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+}, "issueTypes", "issueTypes", import('@reduxjs/toolkit').SliceSelectors<IssueTypeState>>;
+export declare const initializeIssueTypes: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/initializeIssueTypes">, setIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/setIssueType">, addIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/addIssueType">, updateIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/updateIssueType">, removeIssueType: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypes/removeIssueType">;
 export declare const selectIssueTypeMapping: OvermapSelector<IssueTypeState["instances"]>;
 export declare const selectIssueTypes: OvermapSelector<Stored<IssueType>[]>;
 export declare const selectIssueTypeById: OvermapSelectorWithArgs<string, Stored<IssueType> | undefined>;