@overmap-ai/core 1.0.71-depend-on-forms.0 → 1.0.71-fields.0

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

@@ -0,0 +1,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetTypeFieldValuesAttachmentState = ModelState<Stored<AssetTypeFieldValuesAttachment>>;
+export declare const assetTypeFieldValuesAttachmentSlice: import("@reduxjs/toolkit").Slice<AssetTypeFieldValuesAttachmentState, {
+    initializeAssetTypeFieldValuesAttachments: <TState extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesAttachment: <TState_1 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_1, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesAttachments: <TState_2 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_2, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesAttachment: <TState_3 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_3, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesAttachments: <TState_4 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_4, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesAttachment: <TState_5 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_5, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesAttachments: <TState_6 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_6, action: {
+        payload: Stored<AssetTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValuesAttachment: <TState_7 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValuesAttachments: <TState_8 extends ModelState<Stored<AssetTypeFieldValuesAttachment>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetTypeFieldValuesAttachments">;
+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>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetTypeFieldValuesAttachment>>) => Stored<AssetTypeFieldValuesAttachment>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAttachmentsOfAssetTypeFieldValues: OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment>[]>;
+export declare const selectAssetTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, AssetTypeFieldValuesAttachment | undefined>;
+export declare const assetTypeFieldValuesAttachmentReducer: Reducer<AssetTypeFieldValuesAttachmentState>;

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

@@ -0,0 +1,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetTypeFieldValuesState = ModelState<Stored<AssetTypeFieldValues>>;
+export declare const assetTypeFieldValuesSlice: import("@reduxjs/toolkit").Slice<AssetTypeFieldValuesState, {
+    initializeAssetTypeFieldValues: <TState extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldValues: <TState_1 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_1, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldValuesMany: <TState_2 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_2, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldValues: <TState_3 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_3, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldValuesMany: <TState_4 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_4, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValues: <TState_5 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_5, action: {
+        payload: Stored<AssetTypeFieldValues>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldValuesMany: <TState_6 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_6, action: {
+        payload: Stored<AssetTypeFieldValues>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValues: <TState_7 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldValuesMany: <TState_8 extends ModelState<Stored<AssetTypeFieldValues>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetTypeFieldValues">;
+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>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetTypeFieldValues>>) => Stored<AssetTypeFieldValues>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAssetTypeFieldValuesOfAsset: OvermapSelectorWithArgs<string, 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,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetTypeFieldsAttachmentState = ModelState<Stored<AssetTypeFieldsAttachment>>;
+export declare const assetTypeFieldsAttachmentSlice: import("@reduxjs/toolkit").Slice<AssetTypeFieldsAttachmentState, {
+    initializeAssetTypeFieldsAttachments: <TState extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeFieldsAttachment: <TState_1 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_1, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldsAttachments: <TState_2 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_2, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setAssetTypeFieldsAttachment: <TState_3 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_3, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldsAttachments: <TState_4 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_4, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsAttachment: <TState_5 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_5, action: {
+        payload: Stored<AssetTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsAttachments: <TState_6 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_6, action: {
+        payload: Stored<AssetTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsAttachment: <TState_7 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsAttachments: <TState_8 extends ModelState<Stored<AssetTypeFieldsAttachment>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetTypeFieldsAttachments">;
+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>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetTypeFieldsAttachment>>) => Stored<AssetTypeFieldsAttachment>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+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,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetTypeFieldsState = ModelState<Stored<AssetTypeFields>>;
+export declare const assetTypeFieldsSlice: import("@reduxjs/toolkit").Slice<AssetTypeFieldsState, {
+    initializeAssetTypeFields: <TState extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    addAssetTypeFields: <TState_1 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_1, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    addAssetTypeFieldsMany: <TState_2 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_2, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    setAssetTypeFields: <TState_3 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_3, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    setAssetTypeFieldsMany: <TState_4 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_4, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateAssetTypeFields: <TState_5 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_5, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    updateAssetTypeFieldsMany: <TState_6 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_6, action: {
+        payload: Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteAssetTypeFields: <TState_7 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetTypeFieldsMany: <TState_8 extends ModelState<Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetTypeFields">;
+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>>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>>) => Stored<AssetTypeFields<import("@overmap-ai/forms").ISerializedField>>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAssetTypeFieldsOfAssetType: OvermapSelectorWithArgs<string, AssetTypeFields[]>;
+export declare const selectAssetTypeFieldsById: OvermapSelectorWithArgs<string, AssetTypeFields | undefined>;
+export declare const assetTypeFieldsReducer: Reducer<AssetTypeFieldsState>;

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

@@ -45,7 +45,5 @@ export declare const selectForms: ((state: OvermapRootState) => Stored<Form>[])
 };
 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>;

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

@@ -48,9 +48,5 @@ export declare const selectFormSubmissionsOfForm: OvermapSelectorWithArgs<string
 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,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { IssueTypeFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type IssueTypeFieldValuesAttachmentState = ModelState<Stored<IssueTypeFieldValuesAttachment>>;
+export declare const issueTypeFieldValuesAttachmentSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldValuesAttachmentState, {
+    initializeIssueTypeFieldValuesAttachments: <TState extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeFieldValuesAttachment: <TState_1 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_1, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldValuesAttachments: <TState_2 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_2, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeFieldValuesAttachment: <TState_3 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_3, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldValuesAttachments: <TState_4 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_4, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValuesAttachment: <TState_5 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_5, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValuesAttachments: <TState_6 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_6, action: {
+        payload: Stored<IssueTypeFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldValuesAttachment: <TState_7 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldValuesAttachments: <TState_8 extends ModelState<Stored<IssueTypeFieldValuesAttachment>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "issueTypeFieldValuesAttachments">;
+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>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFieldValuesAttachment>>) => Stored<IssueTypeFieldValuesAttachment>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAttachmentsOfIssueTypeFieldValues: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment>[]>;
+export declare const selectIssueTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment> | undefined>;
+export declare const issueTypeFieldValuesAttachmentReducer: Reducer<IssueTypeFieldValuesAttachmentState>;

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

@@ -0,0 +1,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { IssueTypeFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type IssueTypeFieldValuesState = ModelState<Stored<IssueTypeFieldValues>>;
+export declare const issueTypeFieldValuesSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldValuesState, {
+    initializeIssueTypeFieldValues: <TState extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    addIssueTypeFieldValues: <TState_1 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_1, action: {
+        payload: Stored<IssueTypeFieldValues>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldValuesMany: <TState_2 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_2, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    setIssueTypeFieldValues: <TState_3 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_3, action: {
+        payload: Stored<IssueTypeFieldValues>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldValuesMany: <TState_4 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_4, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValues: <TState_5 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_5, action: {
+        payload: Stored<IssueTypeFieldValues>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldValuesMany: <TState_6 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_6, action: {
+        payload: Stored<IssueTypeFieldValues>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldValues: <TState_7 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldValuesMany: <TState_8 extends ModelState<Stored<IssueTypeFieldValues>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "issueTypeFieldValues">;
+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>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+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,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { IssueTypeFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type IssueTypeFieldsAttachmentState = ModelState<Stored<IssueTypeFieldsAttachment>>;
+export declare const issueTypeFieldsAttachmentSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldsAttachmentState, {
+    initializeIssueTypeFieldsAttachments: <TState extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addIssueTypeFieldsAttachment: <TState_1 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_1, action: {
+        payload: Stored<IssueTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldsAttachments: <TState_2 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_2, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setIssueTypeFieldsAttachment: <TState_3 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_3, action: {
+        payload: Stored<IssueTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldsAttachments: <TState_4 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_4, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFieldsAttachment: <TState_5 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_5, action: {
+        payload: Stored<IssueTypeFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldsAttachments: <TState_6 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_6, action: {
+        payload: Stored<IssueTypeFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldsAttachment: <TState_7 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldsAttachments: <TState_8 extends ModelState<Stored<IssueTypeFieldsAttachment>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "issueTypeFieldsAttachments">;
+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>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFieldsAttachment>>) => Stored<IssueTypeFieldsAttachment>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+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,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { IssueTypeFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type IssueTypeFieldsState = ModelState<Stored<IssueTypeFields>>;
+export declare const issueTypeFieldsSlice: import("@reduxjs/toolkit").Slice<IssueTypeFieldsState, {
+    initializeIssueTypeFields: <TState extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    addIssueTypeFields: <TState_1 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_1, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    addIssueTypeFieldsMany: <TState_2 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_2, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    setIssueTypeFields: <TState_3 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_3, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    setIssueTypeFieldsMany: <TState_4 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_4, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateIssueTypeFields: <TState_5 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_5, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    updateIssueTypeFieldsMany: <TState_6 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_6, action: {
+        payload: Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteIssueTypeFields: <TState_7 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteIssueTypeFieldsMany: <TState_8 extends ModelState<Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "issueTypeFields">;
+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>>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>>) => Stored<IssueTypeFields<import("@overmap-ai/forms").ISerializedField>>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFields>[]>;
+export declare const selectIssueTypeFieldsById: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
+export declare const issueTypeFieldsReducer: Reducer<IssueTypeFieldsState>;

package/dist/store/store.d.ts

@@ -3,7 +3,7 @@ import { Reducer } from "redux";
 import { Config, OfflineAction, OfflineMetadata } from "@redux-offline/redux-offline/lib/types";
 import request from "superagent";
 import { type BaseSDK, type OfflineMetaEffect, OutboxCoordinator, RequestDetails } from "../sdk";
-import { AgentsState, AssetAttachmentState, AssetStageCompletionState, AssetStageState, AssetState, AssetTypeAttachmentState, AssetTypeState, AuthState, CategoryState, DocumentAttachmentState, DocumentState, EmailDomainState, FileState, FormRevisionAttachmentState, FormRevisionState, FormState, FormSubmissionAttachmentState, FormSubmissionState, GeoImageSliceState, IssueAssociationSliceState, IssueAttachmentState, IssueCommentState, IssueState, IssueTypeState, IssueUpdateState, LicenseState, OrganizationAccessState, OrganizationState, OutboxState, ProjectAccessState, ProjectAttachmentState, ProjectFileState, ProjectState, RehydratedState, TeamState, UserState, VersioningState, WorkspaceState } from "./slices";
+import { AgentsState, AssetAttachmentState, AssetStageCompletionState, AssetStageState, AssetState, AssetTypeAttachmentState, AssetTypeFieldsAttachmentState, AssetTypeFieldsState, AssetTypeFieldValuesAttachmentState, AssetTypeFieldValuesState, AssetTypeState, AuthState, CategoryState, DocumentAttachmentState, DocumentState, EmailDomainState, FileState, FormRevisionAttachmentState, FormRevisionState, FormState, FormSubmissionAttachmentState, FormSubmissionState, GeoImageSliceState, IssueAssociationSliceState, IssueAttachmentState, IssueCommentState, IssueState, IssueTypeFieldsAttachmentState, IssueTypeFieldsState, IssueTypeFieldValuesAttachmentState, IssueTypeFieldValuesState, IssueTypeState, IssueUpdateState, LicenseState, OrganizationAccessState, OrganizationState, OutboxState, ProjectAccessState, ProjectAttachmentState, ProjectFileState, ProjectState, RehydratedState, TeamState, UserState, VersioningState, WorkspaceState } from "./slices";
 import type { BaseState, OvermapRootState } from "../typings";
 export declare const VERSION_REDUCER_KEY = "versioning";
 export declare const overmapReducers: {
@@ -45,6 +45,14 @@ export declare const overmapReducers: {
     issueAttachmentReducer: Reducer<IssueAttachmentState>;
     geoImageReducer: Reducer<GeoImageSliceState>;
     issueAssociationReducer: Reducer<IssueAssociationSliceState>;
+    issueTypeFieldsReducer: Reducer<IssueTypeFieldsState>;
+    issueTypeFieldValuesReducer: Reducer<IssueTypeFieldValuesState>;
+    issueTypeFieldsAttachmentReducer: Reducer<IssueTypeFieldsAttachmentState>;
+    issueTypeFieldValuesAttachmentReducer: Reducer<IssueTypeFieldValuesAttachmentState>;
+    assetTypeFieldsReducer: Reducer<AssetTypeFieldsState>;
+    assetTypeFieldValuesReducer: Reducer<AssetTypeFieldValuesState>;
+    assetTypeFieldsAttachmentReducer: Reducer<AssetTypeFieldsAttachmentState>;
+    assetTypeFieldValuesAttachmentReducer: Reducer<AssetTypeFieldValuesAttachmentState>;
 };
 export declare const resetStore = "RESET";
 export declare const overmapRootReducer: Reducer<OvermapRootState>;

package/dist/typings/files.d.ts

@@ -12,10 +12,14 @@ export type FileModel = MaybeObjectURL<{
 export interface FileWithNameModel extends FileModel {
     file_name: string;
 }
-/** the attributes needed to generate a presigned url for a file that is being attempted to be uploaded */
-export interface FileUploadPayload {
-    sha1: string;
-    extension: string;
+export interface FilePayload {
+    sha1: FileModel["file_sha1"];
     file_type: string;
+    extension: string;
     size: number;
 }
+export interface FileModelPayload {
+    file_sha1: FileWithNameModel["file_sha1"];
+    file_name: FileWithNameModel["file_name"];
+    file_extension: string;
+}

package/dist/typings/models/assets.d.ts

@@ -1,5 +1,7 @@
+import type { BaseSerializedObject, ISerializedField } from "@overmap-ai/forms";
 import type { ColorModel, CreatedByModel, IconModel, OfflineModel, SubmittedAtModel, TimestampedModel } from "./base";
 import type { CanvasMarkableModel, MarkableModel } from "./geo";
+import type { FieldsAttachmentModel, FieldsModel, FieldValuesModel } from "./fields";
 export interface Asset extends OfflineModel, TimestampedModel, SubmittedAtModel, CreatedByModel, MarkableModel, CanvasMarkableModel {
     asset_type: string;
     created_at?: string;
@@ -23,3 +25,16 @@ export interface AssetStageCompletion extends OfflineModel, TimestampedModel, Su
     stage: string;
 }
 export type CompletedStagesMapping = Record<string, Record<string, string>>;
+export interface AssetTypeFields<TFields extends BaseSerializedObject = ISerializedField> extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel<TFields> {
+    asset_type: string;
+}
+export interface AssetTypeFieldsAttachment extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
+    fields_revision: string;
+}
+export interface AssetTypeFieldValues extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldValuesModel {
+    fields_revision: string;
+    asset: string;
+}
+export interface AssetTypeFieldValuesAttachment extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
+    field_values: string;
+}

package/dist/typings/models/attachments.d.ts

@@ -1,5 +1,5 @@
 import type { CreatedByModel, OfflineModel, SubmittedAtModel } from "./base";
-import type { FileModel, FileWithNameModel, MaybeObjectURL } from "../files";
+import type { FileModel, FileWithNameModel } from "../files";
 export interface Attachment extends OfflineModel, SubmittedAtModel, FileWithNameModel, CreatedByModel {
     description?: string;
     file_type: string;
@@ -19,9 +19,4 @@ export interface ProjectAttachment extends Attachment {
 export interface DocumentAttachment extends Attachment {
     document: string;
 }
-/** to get an AttachmentPayload for a specific type, pass in the given AttachmentType
- * ex. AttachmentPayload<IssueAttachment> */
-export type AttachmentPayload<TAttachment> = Omit<TAttachment, "file" | "submitted_at" | "created_by"> & {
-    file: MaybeObjectURL<File>;
-};
 export type ProfilePic = FileModel;

package/dist/typings/models/fields.d.ts

@@ -0,0 +1,16 @@
+import { BaseSerializedObject, FieldValue, ISerializedField } from "@overmap-ai/forms";
+import type { FileWithNameModel } from "../files";
+export interface FieldsModel<TFields extends BaseSerializedObject = ISerializedField> {
+    fields: TFields[];
+    revision: number | "Pending";
+}
+export interface FieldValuesModel {
+    published_at?: string | null;
+    values: Record<string, FieldValue>;
+}
+export interface FieldsAttachmentModel extends FileWithNameModel {
+    field_identifier: string;
+}
+export interface FieldValuesAttachmentModel extends FileWithNameModel {
+    field_identifier: string;
+}