@overmap-ai/core 1.0.71-mapbox.6 → 1.0.71-mapbox.7

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

@@ -32,3 +32,14 @@ export * from './TeamService';
 export * from './UserService';
 export * from './GeoImageService';
 export * from './IssueAssociationService';
+export * from './FormRevisionAttachmentService';
+export * from './FormSubmissionAttachmentService';
+export * from './FormRevisionService';
+export * from './AssetTypeFieldsAttachmentService';
+export * from './AssetTypeFieldsService';
+export * from './AssetTypeFieldValuesService';
+export * from './AssetTypeFieldValuesAttachmentService';
+export * from './IssueTypeFieldsAttachmentService';
+export * from './IssueTypeFieldsService';
+export * from './IssueTypeFieldValuesAttachmentService';
+export * from './IssueTypeFieldValuesService';

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

@@ -63,4 +63,3 @@ export declare const selectAssetStages: ((state: import('../..').OvermapRootStat
 export declare const selectAssetTypeStagesMapping: OvermapSelectorWithArgs<string, Record<string, AssetStage>>;
 export declare const selectStagesOfAssetType: OvermapSelectorWithArgs<string, AssetStage[]>;
 export declare const selectAssetStagesByIds: (args: string[]) => (state: import('../..').OvermapRootState) => Stored<AssetStage>[];
-export declare const selectStageFormIdsFromStageIds: OvermapSelectorWithArgs<string[], Record<string, string>>;

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

@@ -0,0 +1,64 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
+export type AssetTypeFieldValuesAttachmentState = ModelState<Stored<AssetTypeFieldValuesAttachment>>;
+export declare const assetTypeFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldValuesAttachmentState, {
+    initializeAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValuesAttachment: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldValuesAttachments: (state: ModelState<Stored<AssetTypeFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFieldValuesAttachments", "assetTypeFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldValuesAttachmentState>>;
+export declare const initializeAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/initializeAssetTypeFieldValuesAttachments">, addAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachment">, addAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/addAssetTypeFieldValuesAttachments">, setAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachment">, setAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/setAssetTypeFieldValuesAttachments">, updateAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>, "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachment">, updateAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValuesAttachment>[], "assetTypeFieldValuesAttachments/updateAssetTypeFieldValuesAttachments">, deleteAssetTypeFieldValuesAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachment">, deleteAssetTypeFieldValuesAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValuesAttachments/deleteAssetTypeFieldValuesAttachments">;
+export declare const selectAssetTypeFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValuesAttachment>>;
+export declare const selectAssetTypeFieldValuesAttachments: ((state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValuesAttachment>>) => Stored<AssetTypeFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValuesAttachment>>) => Stored<AssetTypeFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldValuesAttachment | undefined>;
+export declare const selectAssetTypeFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[];
+export declare const selectAttachmentsOfAssetTypeFieldValues: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment>[]>;
+export declare const assetTypeFieldValuesAttachmentReducer: Reducer<AssetTypeFieldValuesAttachmentState>;

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

@@ -0,0 +1,64 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
+export type AssetTypeFieldValuesState = ModelState<Stored<AssetTypeFieldValues>>;
+export declare const assetTypeFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldValuesState, {
+    initializeAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValues: (state: ModelState<Stored<AssetTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldValuesMany: (state: ModelState<Stored<AssetTypeFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFieldValues", "assetTypeFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldValuesState>>;
+export declare const initializeAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/initializeAssetTypeFieldValues">, addAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/addAssetTypeFieldValues">, addAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/addAssetTypeFieldValuesMany">, setAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/setAssetTypeFieldValues">, setAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/setAssetTypeFieldValuesMany">, updateAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>, "assetTypeFieldValues/updateAssetTypeFieldValues">, updateAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldValues>[], "assetTypeFieldValues/updateAssetTypeFieldValuesMany">, deleteAssetTypeFieldValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldValues/deleteAssetTypeFieldValues">, deleteAssetTypeFieldValuesMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldValues/deleteAssetTypeFieldValuesMany">;
+export declare const selectAssetTypeFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValues>>;
+export declare const selectAssetTypeFieldValues: ((state: OvermapRootState) => Stored<AssetTypeFieldValues>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValues>>) => Stored<AssetTypeFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFieldValues>>) => Stored<AssetTypeFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, AssetTypeFieldValues[]>;
+export declare const selectAssetTypeValuesOfAssetType: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues>[]>;
+export declare const selectAssetTypeFieldValuesById: OvermapSelectorWithArgs<string, AssetTypeFieldValues | undefined>;
+export declare const assetTypeFieldValuesReducer: Reducer<AssetTypeFieldValuesState>;

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

@@ -0,0 +1,63 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
+export type AssetTypeFieldsAttachmentState = ModelState<Stored<AssetTypeFieldsAttachment>>;
+export declare const assetTypeFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsAttachmentState, {
+    initializeAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsAttachment: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldsAttachments: (state: ModelState<Stored<AssetTypeFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFieldsAttachments", "assetTypeFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsAttachmentState>>;
+export declare const initializeAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/initializeAssetTypeFieldsAttachments">, addAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/addAssetTypeFieldsAttachment">, addAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/addAssetTypeFieldsAttachments">, setAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/setAssetTypeFieldsAttachment">, setAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/setAssetTypeFieldsAttachments">, updateAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>, "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachment">, updateAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFieldsAttachment>[], "assetTypeFieldsAttachments/updateAssetTypeFieldsAttachments">, deleteAssetTypeFieldsAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachment">, deleteAssetTypeFieldsAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFieldsAttachments/deleteAssetTypeFieldsAttachments">;
+export declare const selectAssetTypeFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFieldsAttachment>>;
+export declare const selectAssetTypeFieldsAttachments: ((state: OvermapRootState) => Stored<AssetTypeFieldsAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFieldsAttachment>>) => Stored<AssetTypeFieldsAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFieldsAttachment>>) => Stored<AssetTypeFieldsAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFieldsAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFieldsAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAttachmentsOfAssetTypeFields: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment[]>;
+export declare const selectAssetTypeFieldsAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldsAttachment | undefined>;
+export declare const assetTypeFieldsAttachmentReducer: Reducer<AssetTypeFieldsAttachmentState>;

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

@@ -0,0 +1,64 @@
+import { Reducer } from '@reduxjs/toolkit';
+import { AssetTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+
+export type AssetTypeFieldsState = ModelState<Stored<AssetTypeFields>>;
+export declare const assetTypeFieldsSlice: import('@reduxjs/toolkit').Slice<AssetTypeFieldsState, {
+    initializeAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    addAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    setAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: {
+        payload: Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFields: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
+    deleteAssetTypeFieldsMany: (state: ModelState<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+}, "assetTypeFields", "assetTypeFields", import('@reduxjs/toolkit').SliceSelectors<AssetTypeFieldsState>>;
+export declare const initializeAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/initializeAssetTypeFields">, addAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/addAssetTypeFields">, addAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/addAssetTypeFieldsMany">, setAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/setAssetTypeFields">, setAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/setAssetTypeFieldsMany">, updateAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>, "assetTypeFields/updateAssetTypeFields">, updateAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[], "assetTypeFields/updateAssetTypeFieldsMany">, deleteAssetTypeFields: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetTypeFields/deleteAssetTypeFields">, deleteAssetTypeFieldsMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetTypeFields/deleteAssetTypeFieldsMany">;
+export declare const selectAssetTypeFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>;
+export declare const selectAssetTypeFields: ((state: OvermapRootState) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>>) => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetTypeFields<import('@overmap-ai/forms').ISerializedField>>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetTypeFields<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 selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields[]>;
+export declare const selectLatestAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+export declare const assetTypeFieldsReducer: Reducer<AssetTypeFieldsState>;

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

@@ -1,5 +1,5 @@
 import { Reducer } from '@reduxjs/toolkit';
-import { Form, FormRevision, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { FormRevision, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
 
 export type FormRevisionState = ModelState<Stored<FormRevision>>;
@@ -50,5 +50,4 @@ export declare const selectFormRevisionById: OvermapSelectorWithArgs<string, Sto
 export declare const _selectLatestFormRevision: (formRevisions: FormRevisionState["instances"], formId: string) => Stored<FormRevision>;
 export declare const selectLatestFormRevisionOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision> | undefined>;
 export declare const selectFormRevisionsOfForm: OvermapSelectorWithArgs<string, Stored<FormRevision>[]>;
-export declare const selectLatestFormRevisionByForm: OvermapSelector<Record<Stored<Form>["offline_id"], Stored<FormRevision>>>;
 export declare const formRevisionReducer: Reducer<FormRevisionState>;

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

@@ -57,9 +57,5 @@ export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[])
     argsMemoize: typeof import('reselect').weakMapMemoize;
     memoize: typeof import('reselect').weakMapMemoize;
 };
-export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;
 export declare const selectFormById: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFormOfAssetType: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFormOfIssueType: OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-export declare const selectFormsCount: OvermapSelector<number>;
-export declare const selectGeneralFormCount: OvermapSelector<number>;
+export declare const selectFilteredForms: OvermapSelectorWithArgs<FormSearchArgs, Stored<Form>[]>;

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

@@ -40,12 +40,6 @@ export declare const selectFormSubmissionsMapping: OvermapSelector<FormSubmissio
 export declare const selectFormSubmissions: OvermapSelector<Stored<FormSubmission>[]>;
 export declare const selectFormSubmissionById: OvermapSelectorWithArgs<string, Stored<FormSubmission> | undefined>;
 export declare const selectFormSubmissionsOfForm: OvermapSelectorWithArgs<string, Stored<FormSubmission>[]>;
-export declare const selectFormSubmissionsByFormRevisions: OvermapSelector<Record<string, Stored<FormSubmission>[]>>;
-export declare const selectSortedFormSubmissionsOfForm: OvermapSelectorWithArgs<string, Stored<FormSubmission>[]>;
 export declare const selectFormSubmissionsOfIssue: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectAttachedFormSubmissionsOfIssue: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectFormSubmissionsByIssues: OvermapSelectorWithArgs<string[], Record<string, Stored<FormSubmission>[]>>;
 export declare const selectFormSubmissionsOfAsset: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectAttachedFormSubmissionsOfAsset: (args: string) => (state: OvermapRootState) => Stored<FormSubmission>[];
-export declare const selectFormSubmissionsByAssets: OvermapSelector<Record<string, Stored<FormSubmission>[]>>;
 export declare const formSubmissionReducer: Reducer<FormSubmissionState>;

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

@@ -36,3 +36,11 @@ export * from './issueAttachmentSlice';
 export * from './versioningSlice';
 export * from './geoImageSlice';
 export * from './issueAssociationSlice';
+export * from './issueTypeFieldsSlice';
+export * from './issueTypeFieldValuesSlice';
+export * from './issueTypeFieldsAttachmentSlice';
+export * from './issueTypeFieldValuesAttachmentSlice';
+export * from './assetTypeFieldsSlice';
+export * from './assetTypeFieldValuesSlice';
+export * from './assetTypeFieldsAttachmentSlice';
+export * from './assetTypeFieldValuesAttachmentSlice';

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

@@ -0,0 +1,64 @@
+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,63 @@
+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,63 @@
+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>;