@overmap-ai/core 1.0.71-procedures-temp.0 → 1.0.71-procedures.0

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

@@ -0,0 +1,12 @@
+import type { IssueTypeFieldsAttachment, OvermapRootState } from "../../typings";
+import type { BaseSDK } from "../base";
+import { BaseUploadService } from "./BaseUploadService";
+import type { OptimisticMultipleModelResult } from "../typings";
+export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+    bulkAdd(payloads: {
+        fieldsRevisionId: string;
+        fieldIdentifier: string;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldsAttachment>>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { IssueTypeFields, OvermapRootState, Payload } from "../../typings";
+import type { BaseSDK } from "../base";
+import { BaseApiService } from "./BaseApiService";
+import { OptimisticModelResult } from "../typings";
+export declare abstract class IssueTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<IssueTypeFields>): OptimisticModelResult<IssueTypeFields>;
+    refreshStore(organizationId: number): Promise<void>;
+}

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

@@ -1,18 +1,41 @@
-import { BaseAttachmentService } from "./BaseAttachmentService";
+import { AttachmentPayload, BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from "./BaseAttachmentService";
 import type { OvermapRootState, ProjectAttachment, Stored } from "../../typings";
 import type { OptimisticMultipleModelResult } from "../typings";
 import type { BaseSDK } from "../base";
-import { AttachmentModel } from "../../enums";
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment> {
-    attachmentModel: AttachmentModel;
-    initializeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment, AttachmentPayload & {
+    project: number;
+}> {
+    name: string;
+    url: string;
     addAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
     updateAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
     removeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
     removeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
     setAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
     selectAttachment: import('../../typings/store').OvermapSelectorWithArgs<string, ProjectAttachment | undefined>;
-    private buildOfflineAttachment;
-    attachFilesToProject(files: File[], projectId: number): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    deleteProjectAttachment(attachmentId: string): Promise<void>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<number>): import('../../typings/models/base').Offline<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        project: number;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<number>): {
+        project: number;
+        modelId: number;
+        offline_id: string;
+        description: string | undefined;
+        file_sha1: string;
+        file_name: string;
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        projectId: number;
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
+    delete(attachmentId: string): Promise<void>;
+    refreshStore(projectId: number): Promise<void>;
 }

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

@@ -32,5 +32,20 @@ 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";
 export * from "./AssetProcedureInstanceService";
 export * from "./AssetProcedureService";
+export * from "./AssetProcedureFieldsAttachmentService";
+export * from "./AssetProcedureFieldsService";
+export * from "./AssetProcedureFieldValuesAttachmentService";
+export * from "./AssetProcedureFieldValuesService";

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

@@ -0,0 +1,53 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetProcedureFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetProcedureFieldValuesAttachmentState = ModelState<Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const assetProcedureFieldValuesAttachmentSlice: import("@reduxjs/toolkit").Slice<AssetProcedureFieldValuesAttachmentState, {
+    initializeAssetProcedureFieldValuesAttachments: <TState extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachment: <TState_1 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_1, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachments: <TState_2 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_2, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachment: <TState_3 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_3, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachments: <TState_4 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_4, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachment: <TState_5 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_5, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachments: <TState_6 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_6, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesAttachment: <TState_7 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesAttachments: <TState_8 extends ModelState<Stored<AssetProcedureFieldValuesAttachment>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetProcedureFieldValuesAttachments">;
+export declare const initializeAssetProcedureFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/initializeAssetProcedureFieldValuesAttachments">, addAssetProcedureFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachment">, addAssetProcedureFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/addAssetProcedureFieldValuesAttachments">, setAssetProcedureFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachment">, setAssetProcedureFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/setAssetProcedureFieldValuesAttachments">, updateAssetProcedureFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>, "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachment">, updateAssetProcedureFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValuesAttachment>[], "assetProcedureFieldValuesAttachments/updateAssetProcedureFieldValuesAttachments">, deleteAssetProcedureFieldValuesAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachment">, deleteAssetProcedureFieldValuesAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetProcedureFieldValuesAttachments/deleteAssetProcedureFieldValuesAttachments">;
+export declare const selectAssetProcedureFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const selectAssetProcedureFieldValuesAttachments: ((state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAssetProcedureFieldValuesAttachmentById: OvermapSelectorWithArgs<string, AssetProcedureFieldValuesAttachment | undefined>;
+export declare const selectAssetProcedureFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[];
+export declare const selectAttachmentsOfAssetProcedureFieldValues: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValuesAttachment>[]>;
+export declare const assetProcedureFieldValuesAttachmentReducer: Reducer<AssetProcedureFieldValuesAttachmentState>;

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

@@ -0,0 +1,53 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetProcedureFieldValues, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetProcedureFieldValuesState = ModelState<Stored<AssetProcedureFieldValues>>;
+export declare const assetProcedureFieldValuesSlice: import("@reduxjs/toolkit").Slice<AssetProcedureFieldValuesState, {
+    initializeAssetProcedureFieldValues: <TState extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValues: <TState_1 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_1, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesMany: <TState_2 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_2, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValues: <TState_3 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_3, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesMany: <TState_4 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_4, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValues: <TState_5 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_5, action: {
+        payload: Stored<AssetProcedureFieldValues>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesMany: <TState_6 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_6, action: {
+        payload: Stored<AssetProcedureFieldValues>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValues: <TState_7 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesMany: <TState_8 extends ModelState<Stored<AssetProcedureFieldValues>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetProcedureFieldValues">;
+export declare const initializeAssetProcedureFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/initializeAssetProcedureFieldValues">, addAssetProcedureFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/addAssetProcedureFieldValues">, addAssetProcedureFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/addAssetProcedureFieldValuesMany">, setAssetProcedureFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/setAssetProcedureFieldValues">, setAssetProcedureFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/setAssetProcedureFieldValuesMany">, updateAssetProcedureFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>, "assetProcedureFieldValues/updateAssetProcedureFieldValues">, updateAssetProcedureFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldValues>[], "assetProcedureFieldValues/updateAssetProcedureFieldValuesMany">, deleteAssetProcedureFieldValues: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetProcedureFieldValues/deleteAssetProcedureFieldValues">, deleteAssetProcedureFieldValuesMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetProcedureFieldValues/deleteAssetProcedureFieldValuesMany">;
+export declare const selectAssetProcedureFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValues>>;
+export declare const selectAssetProcedureFieldValues: ((state: OvermapRootState) => Stored<AssetProcedureFieldValues>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetProcedureFieldValues>>) => Stored<AssetProcedureFieldValues>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAssetProcedureFieldValuesOfAsset: OvermapSelectorWithArgs<string, AssetProcedureFieldValues[]>;
+export declare const selectAssetProcedureValuesOfAssetProcedure: OvermapSelectorWithArgs<string, Stored<AssetProcedureFieldValues>[]>;
+export declare const selectAssetProcedureFieldValuesById: OvermapSelectorWithArgs<string, AssetProcedureFieldValues | undefined>;
+export declare const assetProcedureFieldValuesReducer: Reducer<AssetProcedureFieldValuesState>;

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

@@ -0,0 +1,52 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetProcedureFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetProcedureFieldsAttachmentState = ModelState<Stored<AssetProcedureFieldsAttachment>>;
+export declare const assetProcedureFieldsAttachmentSlice: import("@reduxjs/toolkit").Slice<AssetProcedureFieldsAttachmentState, {
+    initializeAssetProcedureFieldsAttachments: <TState extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsAttachment: <TState_1 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_1, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsAttachments: <TState_2 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_2, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsAttachment: <TState_3 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_3, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsAttachments: <TState_4 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_4, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsAttachment: <TState_5 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_5, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsAttachments: <TState_6 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_6, action: {
+        payload: Stored<AssetProcedureFieldsAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsAttachment: <TState_7 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsAttachments: <TState_8 extends ModelState<Stored<AssetProcedureFieldsAttachment>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetProcedureFieldsAttachments">;
+export declare const initializeAssetProcedureFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/initializeAssetProcedureFieldsAttachments">, addAssetProcedureFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachment">, addAssetProcedureFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/addAssetProcedureFieldsAttachments">, setAssetProcedureFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachment">, setAssetProcedureFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/setAssetProcedureFieldsAttachments">, updateAssetProcedureFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>, "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachment">, updateAssetProcedureFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFieldsAttachment>[], "assetProcedureFieldsAttachments/updateAssetProcedureFieldsAttachments">, deleteAssetProcedureFieldsAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachment">, deleteAssetProcedureFieldsAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetProcedureFieldsAttachments/deleteAssetProcedureFieldsAttachments">;
+export declare const selectAssetProcedureFieldsAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldsAttachment>>;
+export declare const selectAssetProcedureFieldsAttachments: ((state: OvermapRootState) => Stored<AssetProcedureFieldsAttachment>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetProcedureFieldsAttachment>>) => Stored<AssetProcedureFieldsAttachment>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAttachmentsOfAssetProcedureFields: OvermapSelectorWithArgs<string, AssetProcedureFieldsAttachment[]>;
+export declare const selectAssetProcedureFieldsAttachmentById: OvermapSelectorWithArgs<string, AssetProcedureFieldsAttachment | undefined>;
+export declare const assetProcedureFieldsAttachmentReducer: Reducer<AssetProcedureFieldsAttachmentState>;

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

@@ -0,0 +1,53 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { AssetProcedureFields, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { ModelState } from "../typings";
+export type AssetProcedureFieldsState = ModelState<Stored<AssetProcedureFields>>;
+export declare const assetProcedureFieldsSlice: import("@reduxjs/toolkit").Slice<AssetProcedureFieldsState, {
+    initializeAssetProcedureFields: <TState extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFields: <TState_1 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_1, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldsMany: <TState_2 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_2, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFields: <TState_3 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_3, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldsMany: <TState_4 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_4, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFields: <TState_5 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_5, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldsMany: <TState_6 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_6, action: {
+        payload: Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureFields: <TState_7 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_7, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsMany: <TState_8 extends ModelState<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>>(state: TState_8, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetProcedureFields">;
+export declare const initializeAssetProcedureFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[], "assetProcedureFields/initializeAssetProcedureFields">, addAssetProcedureFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>, "assetProcedureFields/addAssetProcedureFields">, addAssetProcedureFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[], "assetProcedureFields/addAssetProcedureFieldsMany">, setAssetProcedureFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>, "assetProcedureFields/setAssetProcedureFields">, setAssetProcedureFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[], "assetProcedureFields/setAssetProcedureFieldsMany">, updateAssetProcedureFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>, "assetProcedureFields/updateAssetProcedureFields">, updateAssetProcedureFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[], "assetProcedureFields/updateAssetProcedureFieldsMany">, deleteAssetProcedureFields: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetProcedureFields/deleteAssetProcedureFields">, deleteAssetProcedureFieldsMany: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetProcedureFields/deleteAssetProcedureFieldsMany">;
+export declare const selectAssetProcedureFieldsMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>;
+export declare const selectAssetProcedureFields: ((state: OvermapRootState) => Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[]) & import("reselect").OutputSelectorFields<(args_0: Record<string, Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>>) => Stored<AssetProcedureFields<import("@overmap-ai/forms").ISerializedField>>[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const selectAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<string, AssetProcedureFields[]>;
+export declare const selectLatestAssetProcedureFieldsOfAssetProcedure: OvermapSelectorWithArgs<string, AssetProcedureFields | undefined>;
+export declare const selectAssetProcedureFieldsById: OvermapSelectorWithArgs<string, AssetProcedureFields | undefined>;
+export declare const assetProcedureFieldsReducer: Reducer<AssetProcedureFieldsState>;

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

@@ -0,0 +1,53 @@
+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 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,53 @@
+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 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,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,53 @@
+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 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 type { Form, FormRevision, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from "../../typings";
+import type { FormRevision, OvermapRootState, OvermapSelectorWithArgs, Stored } from "../../typings";
 import type { ModelState } from "../typings";
 export type FormRevisionState = ModelState<Stored<FormRevision>>;
 export declare const formRevisionsSlice: import("@reduxjs/toolkit").Slice<FormRevisionState, {
@@ -39,5 +39,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

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

@@ -45,12 +45,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>;