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

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

@@ -36,5 +36,17 @@ 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";
 export * from "./assetProcedureSlice";
 export * from "./assetProcedureInstanceSlice";
+export * from "./assetProcedureFieldsSlice";
+export * from "./assetProcedureFieldValuesSlice";
+export * from "./assetProcedureFieldsAttachmentSlice";
+export * from "./assetProcedureFieldValuesAttachmentSlice";

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

@@ -0,0 +1,53 @@
+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 selectIssueTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment> | undefined>;
+export declare const selectIssueTypeFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeFieldValuesAttachment>[];
+export declare const selectAttachmentsOfIssueTypeFieldValues: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment>[]>;
+export declare const issueTypeFieldValuesAttachmentReducer: Reducer<IssueTypeFieldValuesAttachmentState>;

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

@@ -0,0 +1,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,54 @@
+import { Reducer } from "@reduxjs/toolkit";
+import type { IssueTypeFields, IssueTypeFieldValues, 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 selectLatestIssueTypeFieldsOfIssueType: OvermapSelectorWithArgs<string, IssueTypeFields | undefined>;
+export declare const selectIssueTypeValuesOfIssueType: OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues>[]>;
+export declare const selectIssueTypeFieldsById: OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
+export declare const issueTypeFieldsReducer: Reducer<IssueTypeFieldsState>;

package/dist/store/store.d.ts

@@ -4,7 +4,7 @@ import { Config, OfflineAction, OfflineMetadata } from "@redux-offline/redux-off
 import request from "superagent";
 import { type BaseSDK, type OfflineMetaEffect, OutboxCoordinator, RequestDetails } from "../sdk";
 import type { BaseState, OvermapRootState } from "../typings";
-import { AgentsState, AssetAttachmentState, AssetProcedureInstanceState, AssetProcedureState, 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, AssetProcedureInstanceState, AssetProcedureState, AssetProcedureFieldsState, AssetProcedureFieldValuesState, AssetProcedureFieldsAttachmentState, AssetProcedureFieldValuesAttachmentState, 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";
 export declare const VERSION_REDUCER_KEY = "versioning";
 export declare const overmapReducers: {
     versioning: Reducer<VersioningState>;
@@ -45,8 +45,20 @@ export declare const overmapReducers: {
     issueUpdateReducer: Reducer<IssueUpdateState>;
     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>;
     assetProcedureReducer: Reducer<AssetProcedureState>;
     assetProcedureInstanceReducer: Reducer<AssetProcedureInstanceState>;
+    assetProcedureFieldsReducer: Reducer<AssetProcedureFieldsState>;
+    assetProcedureFieldValuesReducer: Reducer<AssetProcedureFieldValuesState>;
+    assetProcedureFieldsAttachmentReducer: Reducer<AssetProcedureFieldsAttachmentState>;
+    assetProcedureFieldValuesAttachmentReducer: Reducer<AssetProcedureFieldValuesAttachmentState>;
 };
 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,12 +1,15 @@
+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;
-    label?: string | null;
-    description?: string | null;
+    label: string | null;
+    description?: string;
+    project: number;
 }
 export interface AssetType extends OfflineModel, TimestampedModel, SubmittedAtModel, CreatedByModel, IconModel, ColorModel {
-    project: number;
+    organization: number;
     name?: string | null;
     description?: string | null;
 }
@@ -18,13 +21,13 @@ export interface AssetProcedure extends OfflineModel, TimestampedModel, Submitte
 export interface AssetProcedureInstance extends OfflineModel, TimestampedModel, SubmittedAtModel, CreatedByModel {
     asset_procedure: string;
     asset_type: string;
+    project: number;
 }
 export interface AssetStage extends OfflineModel, TimestampedModel, SubmittedAtModel, CreatedByModel, ColorModel {
     asset_procedure: string;
     name?: string | null;
     description?: string | null;
     priority: number;
-    form?: string;
 }
 export interface AssetStageCompletion extends OfflineModel, TimestampedModel, SubmittedAtModel, CreatedByModel {
     asset: string;
@@ -32,3 +35,30 @@ export interface AssetStageCompletion extends OfflineModel, TimestampedModel, Su
     asset_procedure_instance: 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;
+}
+export interface AssetProcedureFields<TFields extends BaseSerializedObject = ISerializedField> extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel<TFields> {
+    asset_procedure: string;
+}
+export interface AssetProcedureFieldsAttachment extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
+    fields_revision: string;
+}
+export interface AssetProcedureFieldValues extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldValuesModel {
+    fields_revision: string;
+    asset_procedure_instance: string;
+    asset: string;
+}
+export interface AssetProcedureFieldValuesAttachment 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;
+}

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

@@ -1,41 +1,24 @@
 import type { CreatedByModel, OfflineModel, Payload, SubmittedAtModel, TimestampedModel } from "./base";
-import type { Attachment } from "./attachments";
-import type { BaseSerializedObject, FieldValue, ISerializedField } from "@overmap-ai/forms";
+import type { BaseSerializedObject, ISerializedField } from "@overmap-ai/forms";
+import type { FieldsAttachmentModel, FieldsModel, FieldValuesAttachmentModel, FieldValuesModel } from "./fields";
 export interface Form extends OfflineModel, SubmittedAtModel, CreatedByModel {
-    asset_type?: string;
-    issue_type?: string;
-    organization?: number;
-    project?: number;
+    organization: number;
 }
-export type SubmittedForm = Form & OfflineModel & {
-    created_by: number;
-    submitted_at: string;
-};
-export type CachedForm = SubmittedForm & {
-    latestRevision: FormRevision;
-};
-export interface FormRevision<TFields extends BaseSerializedObject = ISerializedField> extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel {
+export interface FormRevision<TFields extends BaseSerializedObject = ISerializedField> extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel<TFields> {
     form: string;
     title: string;
     description?: string;
-    fields: TFields[];
-    revision: number | "Pending";
 }
-export type FormRevisionPayload = Omit<Payload<FormRevision>, "revision" | "form">;
-export interface FormSubmission extends OfflineModel, SubmittedAtModel, CreatedByModel {
-    published_at?: string | null;
+export type FormRevisionPayload = Omit<Payload<FormRevision>, "revision">;
+export interface FormSubmission extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldValuesModel {
     form_revision: string;
     project: number;
-    values: Record<string, FieldValue>;
-    issue?: string;
-    asset?: string;
-    asset_stage?: string;
+    issue?: string | null;
+    asset?: string | null;
 }
-export interface FormSubmissionAttachment extends Attachment {
-    submission: string;
-    field_identifier: string;
+export interface FormSubmissionAttachment extends FieldValuesAttachmentModel {
+    form_submission: string;
 }
-export interface FormRevisionAttachment extends Attachment {
-    revision: string;
-    field_identifier: string;
+export interface FormRevisionAttachment extends FieldsAttachmentModel {
+    form_revision: string;
 }

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

@@ -4,6 +4,7 @@ export * from "./base";
 export * from "./categories";
 export * from "./assets";
 export * from "./forms";
+export * from "./fields";
 export * from "./geo";
 export * from "./issues";
 export * from "./issueTypes";

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

@@ -4,6 +4,8 @@ import type { WorkspaceIndexedModel } from "./workspace";
 import type { CanvasMarkableModel, MarkableModel } from "./geo";
 import type { User } from "./users";
 import type { CSSColor } from "../colors";
+import type { BaseSerializedObject, ISerializedField } from "@overmap-ai/forms";
+import type { FieldsAttachmentModel, FieldsModel, FieldValuesModel } from "./fields";
 /**
  * Represents a model instance that has been submitted to the backend. Some properties (depending on which model, but in
  * all cases, the `offline_id`) are guaranteed to be set.
@@ -95,3 +97,16 @@ export interface IssueAssociation extends OfflineModel, SubmittedAtModel, Create
     issue?: string;
     asset?: string;
 }
+export interface IssueTypeFields<TFields extends BaseSerializedObject = ISerializedField> extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel<TFields> {
+    issue_type: string;
+}
+export interface IssueTypeFieldsAttachment extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
+    fields_revision: string;
+}
+export interface IssueTypeFieldValues extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldValuesModel {
+    fields_revision: string;
+    issue: string;
+}
+export interface IssueTypeFieldValuesAttachment extends OfflineModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
+    field_values: string;
+}

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

@@ -1,6 +1,6 @@
 /// <reference types="@redux-offline/redux-offline" />
 import { OfflineState } from "@redux-offline/redux-offline/lib/types";
-import type { AgentsState, AssetAttachmentState, AssetProcedureInstanceState, AssetProcedureState, 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, VERSION_REDUCER_KEY, VersioningState, WorkspaceState } from "../../store";
+import type { AgentsState, AssetAttachmentState, AssetProcedureInstanceState, AssetProcedureState, AssetProcedureFieldsState, AssetProcedureFieldValuesState, AssetProcedureFieldsAttachmentState, AssetProcedureFieldValuesAttachmentState, 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, VERSION_REDUCER_KEY, VersioningState, WorkspaceState } from "../../store";
 export interface BaseState {
     outboxReducer: OutboxState;
     offline: OfflineState;
@@ -43,6 +43,18 @@ export interface OvermapRootState extends BaseState {
     agentsReducer: AgentsState;
     geoImageReducer: GeoImageSliceState;
     issueAssociationReducer: IssueAssociationSliceState;
+    issueTypeFieldsReducer: IssueTypeFieldsState;
+    issueTypeFieldValuesReducer: IssueTypeFieldValuesState;
+    issueTypeFieldsAttachmentReducer: IssueTypeFieldsAttachmentState;
+    issueTypeFieldValuesAttachmentReducer: IssueTypeFieldValuesAttachmentState;
+    assetTypeFieldsReducer: AssetTypeFieldsState;
+    assetTypeFieldValuesReducer: AssetTypeFieldValuesState;
+    assetTypeFieldsAttachmentReducer: AssetTypeFieldsAttachmentState;
+    assetTypeFieldValuesAttachmentReducer: AssetTypeFieldValuesAttachmentState;
     assetProcedureReducer: AssetProcedureState;
     assetProcedureInstanceReducer: AssetProcedureInstanceState;
+    assetProcedureFieldsReducer: AssetProcedureFieldsState;
+    assetProcedureFieldValuesReducer: AssetProcedureFieldValuesState;
+    assetProcedureFieldsAttachmentReducer: AssetProcedureFieldsAttachmentState;
+    assetProcedureFieldValuesAttachmentReducer: AssetProcedureFieldValuesAttachmentState;
 }

package/dist/utils/file.d.ts

@@ -1,4 +1,4 @@
-import { FileUploadPayload } from "../typings";
+import type { FilePayload } from "../typings";
 export declare const getFileS3Key: (file: File, hash?: string) => Promise<string>;
 export declare function hashFile(file: Blob): Promise<string>;
 export declare function getFileIdentifier(file: File): string;
@@ -6,7 +6,7 @@ export declare function getRenamedFile(file: File, newName: string): File & {
     name: string;
 };
 export declare function downloadInMemoryFile(filename: string, text: string): void;
-export declare const constructUploadedFilePayloads: (files: File[]) => Promise<FileUploadPayload[]>;
+export declare const constructUploadedFilePayloads: (files: File[]) => Promise<FilePayload[]>;
 export declare const fileToBlob: (dataUrl: string) => Promise<Blob>;
 export declare const blobToBase64: (blob: Blob) => Promise<string>;
 /** Converts a profile `file` and `fileSha1` into an img src that can be rendered. This relies on an API request. */

package/package.json

@@ -3,7 +3,7 @@
 	"description": "Core functionality for Overmap",
 	"author": "Wôrdn Inc.",
 	"license": "UNLICENSED",
-	"version": "1.0.71-procedures-temp.0",
+	"version": "1.0.71-procedures.1",
 	"type": "module",
 	"main": "dist/overmap-core.umd.cjs",
 	"module": "dist/overmap-core.js",