@overmap-ai/core 1.0.74-gcs.2 → 1.0.74-geojson-layers.0

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

@@ -15,7 +15,7 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -0,0 +1,39 @@
+import { AssetProcedure, AssetProcedureAttachment, Organization, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class AssetProcedureAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, AssetProcedureAttachment> {
+    name: string;
+    url: string;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/addAssetProcedureAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/updateAssetProcedureAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureAttachments/deleteAssetProcedureAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureAttachments/deleteAssetProcedureAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>, "assetProcedureAttachments/setAssetProcedureAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
+        file: string;
+        file_sha1: string;
+        created_by: number | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        asset_procedure: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
+        asset_procedure: string;
+        modelUuid: import('../..').UUIDModel["uuid"];
+        uuid: import('../..').UUIDModel["uuid"];
+        description: import('../..').Attachment["description"];
+        file_sha1: import('../..').FileWithNameModel["file_sha1"];
+        file_name: import('../..').FileWithNameModel["file_name"];
+        file_extension: string;
+    };
+    bulkAdd(payloads: {
+        assetProcedureUuid: AssetProcedure["uuid"];
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<AssetProcedureAttachment>>;
+    delete(uuid: AssetProcedureAttachment["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -14,7 +14,7 @@ export declare abstract class AssetTypeAttachmentService<TState extends OvermapR
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -11,7 +11,7 @@ export interface BuildOfflineAttachmentData {
     file: File;
     file_sha1: string;
     submitted_at: string;
-    created_by?: User["uuid"];
+    created_by?: User["id"];
     description?: string;
     modelUuid: UUIDModel["uuid"];
 }

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

@@ -14,7 +14,7 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -0,0 +1,8 @@
+import { EmailDomain, Organization, OvermapRootState } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class EmailDomainsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
+    remove(emailDomain: EmailDomain): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+}

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

@@ -0,0 +1,10 @@
+import { GeoJsonFeature, GeoJsonLayer, OvermapRootState, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class GeoJsonFeatureService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<GeoJsonFeature>): OptimisticModelResult<GeoJsonFeature>;
+    update(payload: UUID<Partial<Payload<GeoJsonFeature>>>): OptimisticModelResult<GeoJsonFeature>;
+    remove(uuid: GeoJsonFeature["uuid"]): Promise<undefined>;
+    refreshStore(layerUuid: GeoJsonLayer["uuid"]): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { GeoJsonLayer, OvermapRootState, Payload, Project, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class GeoJsonLayerService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<GeoJsonLayer>): OptimisticModelResult<GeoJsonLayer>;
+    update(payload: UUID<Partial<Payload<GeoJsonLayer>>>): OptimisticModelResult<GeoJsonLayer>;
+    remove(uuid: GeoJsonLayer["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+}

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

@@ -15,7 +15,7 @@ export declare abstract class IssueAttachmentService<TState extends OvermapRootS
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -15,7 +15,7 @@ export declare abstract class IssueCommentAttachmentService<TState extends Overm
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -15,7 +15,7 @@ export declare abstract class IssueTypeAttachmentService<TState extends OvermapR
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -0,0 +1,13 @@
+import { License, Organization, OvermapRootState, Project, Transaction } from '../../typings';
+import { BaseSDK } from '../base';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class LicenseService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    getLicense(license: License): Promise<License>;
+    pauseLicense(license: License): Promise<License>;
+    resumeLicense(license: License): Promise<License>;
+    cancelLicense(license: License): Promise<License>;
+    attachLicenseToProject(license: License, project: Project): Promise<License>;
+    detachLicenseFromProject(license: License): Promise<License>;
+    getLatestTransaction(license: License): Promise<Transaction>;
+    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -1,9 +1,6 @@
 import { Organization, OrganizationAccess, OvermapRootState } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
-/**
- * Handles the creation of OrganizationAccess Service
- */
 export declare abstract class OrganizationAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     update(organizationAccess: OrganizationAccess): Promise<OrganizationAccess>;
     remove(organizationAccess: OrganizationAccess): Promise<undefined>;

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

@@ -1,9 +1,6 @@
 import { OvermapRootState, Project, ProjectAccess } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
-/**
- * Handles the creation of ProjectAccess Service
- */
 export declare abstract class ProjectAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     update(projectAccess: ProjectAccess): Promise<ProjectAccess>;
     remove(uuid: ProjectAccess["uuid"]): Promise<undefined>;

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

@@ -14,7 +14,7 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: string | undefined;
+        created_by: number | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;

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

@@ -9,7 +9,7 @@ export declare abstract class ProjectService<TState extends OvermapRootState, TS
     update(project: Project): Promise<Project>;
     delete(uuid: Project["uuid"]): Promise<void>;
     invite(projectUuid: Project["uuid"], email: string): Promise<undefined>;
-    joinProject(projectUuid: Project["uuid"], userUuid: User["uuid"], inviteCode: string): Promise<JoinProjectResponse>;
+    joinProject(projectUuid: Project["uuid"], userUuid: User["id"], inviteCode: string): Promise<JoinProjectResponse>;
     acceptInvite(projectUuid: Project["uuid"]): Promise<void>;
 }
 export {};

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

@@ -6,8 +6,8 @@ export declare abstract class TeamService<TState extends OvermapRootState, TSDK
     add(payload: Payload<Team>): OptimisticModelResult<Team>;
     update(payload: UUID<Partial<Payload<Team>>>): OptimisticModelResult<Team>;
     delete(uuid: Team["uuid"]): Promise<undefined>;
-    setMembers(teamUuid: Team["uuid"], members: User["uuid"][]): Promise<undefined>;
-    addMembers(teamUuid: Team["uuid"], members: User["uuid"][]): Promise<undefined>;
-    removeMembers(teamUuid: Team["uuid"], members: User["uuid"][]): Promise<undefined>;
+    setMembers(teamUuid: Team["uuid"], members: User["id"][]): Promise<undefined>;
+    addMembers(teamUuid: Team["uuid"], members: User["id"][]): Promise<undefined>;
+    removeMembers(teamUuid: Team["uuid"], members: User["id"][]): Promise<undefined>;
     refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,5 +1,6 @@
 export * from './AgentService';
 export * from './AssetAttachmentService';
+export * from './AssetProcedureAttachmentService';
 export * from './AssetProcedureFieldsAttachmentService';
 export * from './AssetProcedureFieldsService';
 export * from './AssetProcedureFieldValuesAttachmentService';
@@ -19,6 +20,7 @@ export * from './BaseApiService';
 export * from './CategoryService';
 export * from './DocumentAttachmentService';
 export * from './DocumentService';
+export * from './EmailDomainsService';
 export * from './EmailVerificationService';
 export * from './FileService';
 export * from './FormRevisionAttachmentService';
@@ -27,6 +29,8 @@ export * from './FormService';
 export * from './FormSubmissionAttachmentService';
 export * from './FormSubmissionService';
 export * from './GeoImageService';
+export * from './GeoJsonFeatureService';
+export * from './GeoJsonLayerService';
 export * from './IssueAssociationService';
 export * from './IssueAttachmentService';
 export * from './IssueCommentAttachmentService';
@@ -40,6 +44,7 @@ export * from './IssueTypeFieldValuesService';
 export * from './IssueTypeService';
 export * from './IssueUpdateService';
 export * from './JWTAuthService';
+export * from './LicenseService';
 export * from './OrganizationAccessService';
 export * from './OrganizationService';
 export * from './ProjectAccessService';

package/dist/store/adapters/modelAdapter.d.ts

@@ -1,15 +1,15 @@
 import { PayloadAction } from '@reduxjs/toolkit';
 import { ModelState } from '../typings';
-export interface OvermapModelAdapter<TModel> {
-    addOne: (state: ModelState<TModel>, action: PayloadAction<TModel>) => void;
-    addMany: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
-    setOne: (state: ModelState<TModel>, action: PayloadAction<TModel>) => void;
-    setMany: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
-    updateOne: (state: ModelState<TModel>, action: PayloadAction<TModel>) => void;
-    updateMany: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
-    deleteOne: (state: ModelState<TModel>, action: PayloadAction<string>) => void;
-    deleteMany: (state: ModelState<TModel>, action: PayloadAction<string[]>) => void;
-    initialize: (state: ModelState<TModel>, action: PayloadAction<TModel[]>) => void;
-    getInitialState: <TState extends object>(state: TState) => TState & ModelState<TModel>;
+export interface OvermapModelAdapter<TId extends string | number | symbol, TModel> {
+    addOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
+    addMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
+    setOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
+    setMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
+    updateOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
+    updateMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
+    deleteOne: (state: ModelState<TId, TModel>, action: PayloadAction<TId>) => void;
+    deleteMany: (state: ModelState<TId, TModel>, action: PayloadAction<TId[]>) => void;
+    initialize: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
+    getInitialState: <TState extends object>(state: TState) => TState & ModelState<TId, TModel>;
 }
-export declare function createModelAdapter<TModel>(computeModelId: (model: TModel) => string): OvermapModelAdapter<TModel>;
+export declare function createModelAdapter<TId extends string | number | symbol, TModel>(computeModelId: (model: TModel) => TId): OvermapModelAdapter<TId, TModel>;

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

@@ -1,20 +1,20 @@
 import { AgentUserConversation, OvermapRootState, OvermapSelector } from '../../typings';
 import { ModelState } from '../typings';
-export type AgentsState = ModelState<AgentUserConversation>;
+export type AgentsState = ModelState<AgentUserConversation["uuid"], AgentUserConversation>;
 export declare const agentsSlice: import('@reduxjs/toolkit').Slice<AgentsState, {
-    initializeConversations: (state: ModelState<AgentUserConversation>, action: {
+    initializeConversations: (state: ModelState<string, AgentUserConversation>, action: {
         payload: AgentUserConversation[];
         type: string;
     }) => void;
-    addConversation: (state: ModelState<AgentUserConversation>, action: {
+    addConversation: (state: ModelState<string, AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-    setConversation: (state: ModelState<AgentUserConversation>, action: {
+    setConversation: (state: ModelState<string, AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;
-    updateConversation: (state: ModelState<AgentUserConversation>, action: {
+    updateConversation: (state: ModelState<string, AgentUserConversation>, action: {
         payload: AgentUserConversation;
         type: string;
     }) => void;

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

@@ -1,37 +1,43 @@
 import { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetAttachmentState = ModelState<Stored<AssetAttachment>>;
+export type AssetAttachmentState = ModelState<AssetAttachment["uuid"], Stored<AssetAttachment>>;
 export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetAttachmentState, {
-    initializeAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    initializeAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    addAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
+    addAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    addAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    addAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    setAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
+    setAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    setAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    setAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    updateAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: {
+    updateAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>;
         type: string;
     }) => void;
-    updateAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+    updateAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
     }) => void;
-    deleteAssetAttachment: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetAttachment: (state: ModelState<string, Stored<AssetAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetAttachments: (state: ModelState<string, Stored<AssetAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetAttachmentState>>;
 export declare const initializeAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/initializeAssetAttachments">, addAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/addAssetAttachment">, addAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/addAssetAttachments">, setAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/setAssetAttachment">, setAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/setAssetAttachments">, updateAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>, "assetAttachments/updateAssetAttachment">, updateAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetAttachment>[], "assetAttachments/updateAssetAttachments">, deleteAssetAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetAttachments/deleteAssetAttachment">, deleteAssetAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetAttachments/deleteAssetAttachments">;
 export declare const selectAssetAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetAttachment>>;

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

@@ -0,0 +1,47 @@
+import { AssetProcedureAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
+import { ModelState } from '../typings';
+export type AssetProcedureAttachmentState = ModelState<AssetProcedureAttachment["uuid"], Stored<AssetProcedureAttachment>>;
+export declare const assetProcedureAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureAttachmentState, {
+    initializeAssetProcedureAttachments: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureAttachment: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureAttachments: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureAttachment: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureAttachments: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureAttachment: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureAttachments: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: Stored<AssetProcedureAttachment>[];
+        type: string;
+    }) => void;
+    deleteAssetProcedureAttachment: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureAttachments: (state: ModelState<string, Stored<AssetProcedureAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetProcedureAttachments", "assetProcedureAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureAttachmentState>>;
+export declare const initializeAssetProcedureAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/initializeAssetProcedureAttachments">, addAssetProcedureAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>, "assetProcedureAttachments/addAssetProcedureAttachment">, addAssetProcedureAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/addAssetProcedureAttachments">, setAssetProcedureAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>, "assetProcedureAttachments/setAssetProcedureAttachment">, setAssetProcedureAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/setAssetProcedureAttachments">, updateAssetProcedureAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>, "assetProcedureAttachments/updateAssetProcedureAttachment">, updateAssetProcedureAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureAttachment>[], "assetProcedureAttachments/updateAssetProcedureAttachments">, deleteAssetProcedureAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureAttachments/deleteAssetProcedureAttachment">, deleteAssetProcedureAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureAttachments/deleteAssetProcedureAttachments">;
+export declare const selectAssetProcedureAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<AssetProcedureAttachment>>;
+export declare const selectAssetProcedureAttachments: OvermapSelector<Stored<AssetProcedureAttachment>[]>;
+export declare const selectAssetProcedureAttachmentById: OvermapSelectorWithArgs<AssetProcedureAttachment["uuid"], Stored<AssetProcedureAttachment> | undefined>;
+export declare const selectAttachmentsOfAssetProcedure: (args: string) => (state: OvermapRootState) => Stored<AssetProcedureAttachment>[];
+export declare const assetProcedureAttachmentReducer: import('redux').Reducer<AssetProcedureAttachmentState>;

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

@@ -1,37 +1,43 @@
 import { AssetProcedureFieldValues, AssetProcedureFieldValuesAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldValuesAttachmentState = ModelState<Stored<AssetProcedureFieldValuesAttachment>>;
+export type AssetProcedureFieldValuesAttachmentState = ModelState<AssetProcedureFieldValuesAttachment["uuid"], Stored<AssetProcedureFieldValuesAttachment>>;
 export declare const assetProcedureFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesAttachmentState, {
-    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    addAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    addAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>;
         type: string;
     }) => void;
-    addAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    addAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    setAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    setAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>;
         type: string;
     }) => void;
-    setAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    setAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    updateAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    updateAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: {
+    updateAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
         payload: Stored<AssetProcedureFieldValuesAttachment>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFieldValuesAttachment: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldValuesAttachments: (state: ModelState<Stored<AssetProcedureFieldValuesAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFieldValuesAttachments", "assetProcedureFieldValuesAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesAttachmentState>>;
 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>>;

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

@@ -1,37 +1,43 @@
 import { Asset, AssetProcedureFieldValues, AssetProcedureInstance, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldValuesState = ModelState<Stored<AssetProcedureFieldValues>>;
+export type AssetProcedureFieldValuesState = ModelState<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValues>>;
 export declare const assetProcedureFieldValuesSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesState, {
-    initializeAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    initializeAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    addAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    addAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>;
         type: string;
     }) => void;
-    addAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    addAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    setAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    setAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>;
         type: string;
     }) => void;
-    setAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    setAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    updateAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    updateAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: {
+    updateAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
         payload: Stored<AssetProcedureFieldValues>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFieldValues: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldValuesMany: (state: ModelState<Stored<AssetProcedureFieldValues>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFieldValues: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldValuesMany: (state: ModelState<string, Stored<AssetProcedureFieldValues>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFieldValues", "assetProcedureFieldValues", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldValuesState>>;
 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>>;

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

@@ -1,37 +1,43 @@
 import { AssetProcedureFieldsAttachment, OvermapRootState, OvermapSelectorWithArgs, Stored } from '../../typings';
 import { ModelState } from '../typings';
-export type AssetProcedureFieldsAttachmentState = ModelState<Stored<AssetProcedureFieldsAttachment>>;
+export type AssetProcedureFieldsAttachmentState = ModelState<AssetProcedureFieldsAttachment["uuid"], Stored<AssetProcedureFieldsAttachment>>;
 export declare const assetProcedureFieldsAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldsAttachmentState, {
-    initializeAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    initializeAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    addAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    addAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>;
         type: string;
     }) => void;
-    addAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    addAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    setAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    setAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>;
         type: string;
     }) => void;
-    setAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    setAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    updateAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    updateAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>;
         type: string;
     }) => void;
-    updateAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: {
+    updateAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
         payload: Stored<AssetProcedureFieldsAttachment>[];
         type: string;
     }) => void;
-    deleteAssetProcedureFieldsAttachment: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string>) => void;
-    deleteAssetProcedureFieldsAttachments: (state: ModelState<Stored<AssetProcedureFieldsAttachment>>, action: import('@reduxjs/toolkit').PayloadAction<string[]>) => void;
+    deleteAssetProcedureFieldsAttachment: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    deleteAssetProcedureFieldsAttachments: (state: ModelState<string, Stored<AssetProcedureFieldsAttachment>>, action: {
+        payload: string[];
+        type: string;
+    }) => void;
 }, "assetProcedureFieldsAttachments", "assetProcedureFieldsAttachments", import('@reduxjs/toolkit').SliceSelectors<AssetProcedureFieldsAttachmentState>>;
 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>>;