@overmap-ai/core 1.0.75 → 1.0.77-store-typing-improvements.0

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

@@ -1,13 +1,14 @@
-import { Offline, OvermapRootState, Payload, Team, User } from '../../typings';
+import { OvermapRootState } from '../../store';
+import { Organization, Payload, Team, User, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class TeamService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Team>): OptimisticModelResult<Team>;
-    update(payload: Offline<Partial<Payload<Team>>>): OptimisticModelResult<Team>;
-    delete(id: string): Promise<undefined>;
-    setMembers(teamId: string, members: User["id"][]): Promise<undefined>;
-    addMembers(teamId: string, members: User["id"][]): Promise<undefined>;
-    removeMembers(teamId: string, members: User["id"][]): Promise<undefined>;
-    refreshStore(organizationId: number): Promise<void>;
+    update(payload: UUID<Partial<Payload<Team>>>): OptimisticModelResult<Team>;
+    delete(uuid: Team["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/UserService.d.ts

@@ -1,6 +1,7 @@
-import { OvermapRootState } from '../../typings';
+import { OvermapRootState } from '../../store';
+import { Organization, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class UserService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    refreshStore(projectId: number, organizationId: number): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,5 +1,12 @@
 export * from './AgentService';
 export * from './AssetAttachmentService';
+export * from './AssetProcedureAttachmentService';
+export * from './AssetProcedureFieldsAttachmentService';
+export * from './AssetProcedureFieldsService';
+export * from './AssetProcedureFieldValuesAttachmentService';
+export * from './AssetProcedureFieldValuesService';
+export * from './AssetProcedureInstanceService';
+export * from './AssetProcedureService';
 export * from './AssetService';
 export * from './AssetStageCompletionService';
 export * from './AssetStageService';

package/dist/sdk/typings.d.ts

@@ -1,7 +1,8 @@
 import { Store } from '@reduxjs/toolkit';
 import { default as request } from 'superagent';
 import { HttpMethod } from '../enums';
-import { BaseState, Created, Model, Stored, Submitted } from '../typings';
+import { BaseState } from '../store';
+import { Created, Model, Stored, Submitted } from '../typings';
 import { DeferredPromise } from '../utils';
 import { BaseSDK } from './base';
 import { GetS3UrlResponse, GetS3UrlSuccessResponse } from './services';

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

@@ -0,0 +1,3 @@
+export * from './modelAdapter';
+export * from './selectionAdapter';
+export type * from './typings';

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

@@ -0,0 +1,15 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { ModelState } from './typings';
+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<TId extends string | number | symbol, TModel>(computeModelId: (model: TModel) => TId): OvermapModelAdapter<TId, TModel>;

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

@@ -0,0 +1,13 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { SelectionState } from './typings';
+export interface SelectionAdapter<TSelection> {
+    selectOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
+    selectMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
+    unselectOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
+    unselectMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
+    toggleOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
+    toggleMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
+    initializeSelection: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
+    getInitialState: <TState extends object>(state: TState) => TState & SelectionState<TSelection>;
+}
+export declare function createSelectionAdapter<TSelection>(): SelectionAdapter<TSelection>;

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

@@ -0,0 +1,6 @@
+export interface ModelState<TId extends number | string | symbol, TModel> {
+    instances: Record<TId, TModel>;
+}
+export interface SelectionState<TSelection> {
+    selection: TSelection[];
+}

package/dist/store/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION_REDUCER_KEY = "versioning";
+export declare const resetStore = "RESET";

package/dist/store/index.d.ts

@@ -1,4 +1,6 @@
-export * from './adapter';
+export * from './adapters';
+export * from './constants';
+export * from './reducers';
 export * from './slices';
 export * from './store';
-export * from './typings';
+export type * from './typings';

package/dist/store/migrations.d.ts

@@ -1,2 +1,2 @@
-import { Manifest } from '../typings';
+import { Manifest } from './typings';
 export declare const manifest: Manifest;

package/dist/store/reducers.d.ts

@@ -0,0 +1,181 @@
+export declare const baseReducers: {
+    outboxReducer: import('redux').Reducer<import('./slices').OutboxState>;
+    fileReducer: import('redux').Reducer<import('./slices').FileState>;
+    authReducer: import('redux').Reducer<import('./slices').AuthState>;
+};
+export declare const baseReducer: import('redux').Reducer<{
+    outboxReducer: import('./slices').OutboxState;
+    fileReducer: import('./slices').FileState;
+    authReducer: import('./slices').AuthState;
+}, import('redux').UnknownAction, Partial<{
+    outboxReducer: import('./slices').OutboxState | undefined;
+    fileReducer: import('./slices').FileState | undefined;
+    authReducer: import('./slices').AuthState | undefined;
+}>>;
+export declare const overmapReducers: {
+    versioning: import('redux').Reducer<import('./slices').VersioningState>;
+    categoryReducer: import('redux').Reducer<import('./slices').CategoryState>;
+    assetReducer: import('redux').Reducer<import('./slices').AssetState>;
+    assetAttachmentReducer: import('redux').Reducer<import('./slices').AssetAttachmentState>;
+    assetStageCompletionReducer: import('redux').Reducer<import('./slices').AssetStageCompletionState>;
+    assetStageReducer: import('redux').Reducer<import('./slices').AssetStageState>;
+    assetTypeReducer: import('redux').Reducer<import('./slices').AssetTypeState>;
+    assetTypeAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeAttachmentState>;
+    issueReducer: import('redux').Reducer<import('./slices').IssueState>;
+    issueAttachmentReducer: import('redux').Reducer<import('./slices').IssueAttachmentState>;
+    issueTypeReducer: import('redux').Reducer<import('./slices').IssueTypeState>;
+    issueTypeAttachmentReducer: import('redux').Reducer<import('./slices').IssueTypeAttachmentState>;
+    organizationReducer: import('redux').Reducer<import('./slices').OrganizationState>;
+    projectReducer: import('redux').Reducer<import('./slices').ProjectState>;
+    projectAttachmentReducer: import('redux').Reducer<import('./slices').ProjectAttachmentState>;
+    projectAccessReducer: import('redux').Reducer<import('./slices').ProjectAccessState>;
+    organizationAccessReducer: import('redux').Reducer<import('./slices').OrganizationAccessState>;
+    projectFileReducer: import('redux').Reducer<import('./slices').ProjectFileState>;
+    rehydratedReducer: import('redux').Reducer<import('./slices').RehydratedState>;
+    formReducer: import('redux').Reducer<import('./slices').FormState>;
+    formRevisionReducer: import('redux').Reducer<import('./slices').FormRevisionState>;
+    formRevisionAttachmentReducer: import('redux').Reducer<import('./slices').FormRevisionAttachmentState>;
+    formSubmissionAttachmentReducer: import('redux').Reducer<import('./slices').FormSubmissionAttachmentState>;
+    formSubmissionReducer: import('redux').Reducer<import('./slices').FormSubmissionState>;
+    userReducer: import('redux').Reducer<import('./slices').UserState>;
+    emailDomainsReducer: import('redux').Reducer<import('./slices').EmailDomainState>;
+    licenseReducer: import('redux').Reducer<import('./slices').LicenseState>;
+    documentsReducer: import('redux').Reducer<import('./slices').DocumentState>;
+    documentAttachmentReducer: import('redux').Reducer<import('./slices').DocumentAttachmentState>;
+    teamReducer: import('redux').Reducer<import('./slices').TeamState>;
+    agentsReducer: import('redux').Reducer<import('./slices').AgentsState>;
+    issueCommentReducer: import('redux').Reducer<import('./slices').IssueCommentState>;
+    issueCommentAttachmentReducer: import('redux').Reducer<import('./slices').IssueCommentAttachmentState>;
+    issueUpdateReducer: import('redux').Reducer<import('./slices').IssueUpdateState>;
+    geoImageReducer: import('redux').Reducer<import('./slices').GeoImageSliceState>;
+    issueAssociationReducer: import('redux').Reducer<import('./slices').IssueAssociationSliceState>;
+    issueTypeFieldsReducer: import('redux').Reducer<import('./slices').IssueTypeFieldsState>;
+    issueTypeFieldValuesReducer: import('redux').Reducer<import('./slices').IssueTypeFieldValuesState>;
+    issueTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').IssueTypeFieldsAttachmentState>;
+    issueTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').IssueTypeFieldValuesAttachmentState>;
+    assetTypeFieldsReducer: import('redux').Reducer<import('./slices').AssetTypeFieldsState>;
+    assetTypeFieldValuesReducer: import('redux').Reducer<import('./slices').AssetTypeFieldValuesState>;
+    assetTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeFieldsAttachmentState>;
+    assetTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeFieldValuesAttachmentState>;
+    assetProcedureReducer: import('redux').Reducer<import('./slices').AssetProcedureState>;
+    assetProcedureInstanceReducer: import('redux').Reducer<import('./slices').AssetProcedureInstanceState>;
+    assetProcedureFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldsState>;
+    assetProcedureFieldValuesReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldValuesState>;
+    assetProcedureFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldsAttachmentState>;
+    assetProcedureFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldValuesAttachmentState>;
+    assetProcedureAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureAttachmentState>;
+    outboxReducer: import('redux').Reducer<import('./slices').OutboxState>;
+    fileReducer: import('redux').Reducer<import('./slices').FileState>;
+    authReducer: import('redux').Reducer<import('./slices').AuthState>;
+};
+export declare const overmapReducer: import('redux').Reducer<{
+    versioning: import('./slices').VersioningState;
+    categoryReducer: import('./slices').CategoryState;
+    assetReducer: import('./slices').AssetState;
+    assetAttachmentReducer: import('./slices').AssetAttachmentState;
+    assetStageCompletionReducer: import('./slices').AssetStageCompletionState;
+    assetStageReducer: import('./slices').AssetStageState;
+    assetTypeReducer: import('./slices').AssetTypeState;
+    assetTypeAttachmentReducer: import('./slices').AssetTypeAttachmentState;
+    issueReducer: import('./slices').IssueState;
+    issueAttachmentReducer: import('./slices').IssueAttachmentState;
+    issueTypeReducer: import('./slices').IssueTypeState;
+    issueTypeAttachmentReducer: import('./slices').IssueTypeAttachmentState;
+    organizationReducer: import('./slices').OrganizationState;
+    projectReducer: import('./slices').ProjectState;
+    projectAttachmentReducer: import('./slices').ProjectAttachmentState;
+    projectAccessReducer: import('./slices').ProjectAccessState;
+    organizationAccessReducer: import('./slices').OrganizationAccessState;
+    projectFileReducer: import('./slices').ProjectFileState;
+    rehydratedReducer: import('./slices').RehydratedState;
+    formReducer: import('./slices').FormState;
+    formRevisionReducer: import('./slices').FormRevisionState;
+    formRevisionAttachmentReducer: import('./slices').FormRevisionAttachmentState;
+    formSubmissionAttachmentReducer: import('./slices').FormSubmissionAttachmentState;
+    formSubmissionReducer: import('./slices').FormSubmissionState;
+    userReducer: import('./slices').UserState;
+    emailDomainsReducer: import('./slices').EmailDomainState;
+    licenseReducer: import('./slices').LicenseState;
+    documentsReducer: import('./slices').DocumentState;
+    documentAttachmentReducer: import('./slices').DocumentAttachmentState;
+    teamReducer: import('./slices').TeamState;
+    agentsReducer: import('./slices').AgentsState;
+    issueCommentReducer: import('./slices').IssueCommentState;
+    issueCommentAttachmentReducer: import('./slices').IssueCommentAttachmentState;
+    issueUpdateReducer: import('./slices').IssueUpdateState;
+    geoImageReducer: import('./slices').GeoImageSliceState;
+    issueAssociationReducer: import('./slices').IssueAssociationSliceState;
+    issueTypeFieldsReducer: import('./slices').IssueTypeFieldsState;
+    issueTypeFieldValuesReducer: import('./slices').IssueTypeFieldValuesState;
+    issueTypeFieldsAttachmentReducer: import('./slices').IssueTypeFieldsAttachmentState;
+    issueTypeFieldValuesAttachmentReducer: import('./slices').IssueTypeFieldValuesAttachmentState;
+    assetTypeFieldsReducer: import('./slices').AssetTypeFieldsState;
+    assetTypeFieldValuesReducer: import('./slices').AssetTypeFieldValuesState;
+    assetTypeFieldsAttachmentReducer: import('./slices').AssetTypeFieldsAttachmentState;
+    assetTypeFieldValuesAttachmentReducer: import('./slices').AssetTypeFieldValuesAttachmentState;
+    assetProcedureReducer: import('./slices').AssetProcedureState;
+    assetProcedureInstanceReducer: import('./slices').AssetProcedureInstanceState;
+    assetProcedureFieldsReducer: import('./slices').AssetProcedureFieldsState;
+    assetProcedureFieldValuesReducer: import('./slices').AssetProcedureFieldValuesState;
+    assetProcedureFieldsAttachmentReducer: import('./slices').AssetProcedureFieldsAttachmentState;
+    assetProcedureFieldValuesAttachmentReducer: import('./slices').AssetProcedureFieldValuesAttachmentState;
+    assetProcedureAttachmentReducer: import('./slices').AssetProcedureAttachmentState;
+    outboxReducer: import('./slices').OutboxState;
+    fileReducer: import('./slices').FileState;
+    authReducer: import('./slices').AuthState;
+}, import('redux').UnknownAction, Partial<{
+    versioning: import('./slices').VersioningState | undefined;
+    categoryReducer: import('./slices').CategoryState | undefined;
+    assetReducer: import('./slices').AssetState | undefined;
+    assetAttachmentReducer: import('./slices').AssetAttachmentState | undefined;
+    assetStageCompletionReducer: import('./slices').AssetStageCompletionState | undefined;
+    assetStageReducer: import('./slices').AssetStageState | undefined;
+    assetTypeReducer: import('./slices').AssetTypeState | undefined;
+    assetTypeAttachmentReducer: import('./slices').AssetTypeAttachmentState | undefined;
+    issueReducer: import('./slices').IssueState | undefined;
+    issueAttachmentReducer: import('./slices').IssueAttachmentState | undefined;
+    issueTypeReducer: import('./slices').IssueTypeState | undefined;
+    issueTypeAttachmentReducer: import('./slices').IssueTypeAttachmentState | undefined;
+    organizationReducer: import('./slices').OrganizationState | undefined;
+    projectReducer: import('./slices').ProjectState | undefined;
+    projectAttachmentReducer: import('./slices').ProjectAttachmentState | undefined;
+    projectAccessReducer: import('./slices').ProjectAccessState | undefined;
+    organizationAccessReducer: import('./slices').OrganizationAccessState | undefined;
+    projectFileReducer: import('./slices').ProjectFileState | undefined;
+    rehydratedReducer: import('./slices').RehydratedState | undefined;
+    formReducer: import('./slices').FormState | undefined;
+    formRevisionReducer: import('./slices').FormRevisionState | undefined;
+    formRevisionAttachmentReducer: import('./slices').FormRevisionAttachmentState | undefined;
+    formSubmissionAttachmentReducer: import('./slices').FormSubmissionAttachmentState | undefined;
+    formSubmissionReducer: import('./slices').FormSubmissionState | undefined;
+    userReducer: import('./slices').UserState | undefined;
+    emailDomainsReducer: import('./slices').EmailDomainState | undefined;
+    licenseReducer: import('./slices').LicenseState | undefined;
+    documentsReducer: import('./slices').DocumentState | undefined;
+    documentAttachmentReducer: import('./slices').DocumentAttachmentState | undefined;
+    teamReducer: import('./slices').TeamState | undefined;
+    agentsReducer: import('./slices').AgentsState | undefined;
+    issueCommentReducer: import('./slices').IssueCommentState | undefined;
+    issueCommentAttachmentReducer: import('./slices').IssueCommentAttachmentState | undefined;
+    issueUpdateReducer: import('./slices').IssueUpdateState | undefined;
+    geoImageReducer: import('./slices').GeoImageSliceState | undefined;
+    issueAssociationReducer: import('./slices').IssueAssociationSliceState | undefined;
+    issueTypeFieldsReducer: import('./slices').IssueTypeFieldsState | undefined;
+    issueTypeFieldValuesReducer: import('./slices').IssueTypeFieldValuesState | undefined;
+    issueTypeFieldsAttachmentReducer: import('./slices').IssueTypeFieldsAttachmentState | undefined;
+    issueTypeFieldValuesAttachmentReducer: import('./slices').IssueTypeFieldValuesAttachmentState | undefined;
+    assetTypeFieldsReducer: import('./slices').AssetTypeFieldsState | undefined;
+    assetTypeFieldValuesReducer: import('./slices').AssetTypeFieldValuesState | undefined;
+    assetTypeFieldsAttachmentReducer: import('./slices').AssetTypeFieldsAttachmentState | undefined;
+    assetTypeFieldValuesAttachmentReducer: import('./slices').AssetTypeFieldValuesAttachmentState | undefined;
+    assetProcedureReducer: import('./slices').AssetProcedureState | undefined;
+    assetProcedureInstanceReducer: import('./slices').AssetProcedureInstanceState | undefined;
+    assetProcedureFieldsReducer: import('./slices').AssetProcedureFieldsState | undefined;
+    assetProcedureFieldValuesReducer: import('./slices').AssetProcedureFieldValuesState | undefined;
+    assetProcedureFieldsAttachmentReducer: import('./slices').AssetProcedureFieldsAttachmentState | undefined;
+    assetProcedureFieldValuesAttachmentReducer: import('./slices').AssetProcedureFieldValuesAttachmentState | undefined;
+    assetProcedureAttachmentReducer: import('./slices').AssetProcedureAttachmentState | undefined;
+    outboxReducer: import('./slices').OutboxState | undefined;
+    fileReducer: import('./slices').FileState | undefined;
+    authReducer: import('./slices').AuthState | undefined;
+}>>;

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

@@ -1,27 +1,27 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AgentUserConversation, OvermapRootState, OvermapSelector } from '../../typings';
-import { ModelState } from '../typings';
-export type AgentsState = ModelState<AgentUserConversation>;
-export declare const agentsSlice: import('@reduxjs/toolkit').Slice<ModelState<AgentUserConversation>, {
-    initializeConversations: (state: ModelState<AgentUserConversation>, action: {
+import { AgentUserConversation } from '../../typings';
+import { ModelState } from '../adapters';
+import { OvermapRootState, OvermapSelector } from '../typings';
+export type AgentsState = ModelState<AgentUserConversation["uuid"], AgentUserConversation>;
+export declare const agentsSlice: import('@reduxjs/toolkit').Slice<AgentsState, {
+    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;
-}, "agents", "agents", import('@reduxjs/toolkit').SliceSelectors<ModelState<AgentUserConversation>>>;
+}, "agents", "agents", import('@reduxjs/toolkit').SliceSelectors<AgentsState>>;
 export declare const initializeConversations: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation[], "agents/initializeConversations">, addConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/addConversation">, setConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/setConversation">, updateConversation: import('@reduxjs/toolkit').ActionCreatorWithPayload<AgentUserConversation, "agents/updateConversation">;
 export declare const selectConversationMapping: (state: OvermapRootState) => Record<string, AgentUserConversation>;
 export declare const selectConversations: OvermapSelector<AgentUserConversation[]>;
 export declare const selectConversation: (args: string) => (state: OvermapRootState) => AgentUserConversation | undefined;
-export declare const agentsReducer: Reducer<AgentsState>;
+export declare const agentsReducer: import('redux').Reducer<AgentsState>;

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

@@ -1,42 +1,48 @@
-import { Reducer } from '@reduxjs/toolkit';
-import { AssetAttachment, OvermapRootState, OvermapSelector, OvermapSelectorWithArgs, Stored } from '../../typings';
-import { ModelState } from '../typings';
-export type AssetAttachmentState = ModelState<Stored<AssetAttachment>>;
-export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<ModelState<Stored<AssetAttachment>>, {
-    initializeAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
+import { AssetAttachment, Stored } from '../../typings';
+import { ModelState } from '../adapters';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export type AssetAttachmentState = ModelState<AssetAttachment["uuid"], Stored<AssetAttachment>>;
+export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetAttachmentState, {
+    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;
-}, "assetAttachments", "assetAttachments", import('@reduxjs/toolkit').SliceSelectors<ModelState<Stored<AssetAttachment>>>>;
+    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>>;
 export declare const selectAssetAttachments: OvermapSelector<Stored<AssetAttachment>[]>;
-export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
+export declare const selectAssetAttachmentById: OvermapSelectorWithArgs<AssetAttachment["uuid"], Stored<AssetAttachment> | undefined>;
 export declare const selectAttachmentsOfAsset: (args: string) => (state: OvermapRootState) => Stored<AssetAttachment>[];
-export declare const assetAttachmentReducer: Reducer<AssetAttachmentState>;
+export declare const assetAttachmentReducer: import('redux').Reducer<AssetAttachmentState>;

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

@@ -0,0 +1,48 @@
+import { AssetProcedureAttachment, Stored } from '../../typings';
+import { ModelState } from '../adapters';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } 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

@@ -0,0 +1,126 @@
+import { AssetProcedureFieldValues, AssetProcedureFieldValuesAttachment, Stored } from '../../typings';
+import { ModelState } from '../adapters';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
+export type AssetProcedureFieldValuesAttachmentState = ModelState<AssetProcedureFieldValuesAttachment["uuid"], Stored<AssetProcedureFieldValuesAttachment>>;
+export declare const assetProcedureFieldValuesAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetProcedureFieldValuesAttachmentState, {
+    initializeAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    addAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    setAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachment: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>;
+        type: string;
+    }) => void;
+    updateAssetProcedureFieldValuesAttachments: (state: ModelState<string, Stored<AssetProcedureFieldValuesAttachment>>, action: {
+        payload: Stored<AssetProcedureFieldValuesAttachment>[];
+        type: 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>>;
+export declare const selectAssetProcedureFieldValuesAttachments: ((state: {
+    versioning: import('./versioningSlice').VersioningState;
+    categoryReducer: import('./categorySlice').CategoryState;
+    assetReducer: import('./assetSlice').AssetState;
+    assetAttachmentReducer: import('./assetAttachmentSlice').AssetAttachmentState;
+    assetStageCompletionReducer: import('./assetStageCompletionSlice').AssetStageCompletionState;
+    assetStageReducer: import('./assetStageSlice').AssetStageState;
+    assetTypeReducer: import('./assetTypeSlice').AssetTypeState;
+    assetTypeAttachmentReducer: import('./assetTypeAttachmentSlice').AssetTypeAttachmentState;
+    issueReducer: import('./issueSlice').IssueState;
+    issueAttachmentReducer: import('./issueAttachmentSlice').IssueAttachmentState;
+    issueTypeReducer: import('./issueTypeSlice').IssueTypeState;
+    issueTypeAttachmentReducer: import('./issueTypeAttachmentSlice').IssueTypeAttachmentState;
+    organizationReducer: import('./organizationSlice').OrganizationState;
+    projectReducer: import('./projectSlice').ProjectState;
+    projectAttachmentReducer: import('./projectAttachmentSlice').ProjectAttachmentState;
+    projectAccessReducer: import('./projectAccessSlice').ProjectAccessState;
+    organizationAccessReducer: import('./organizationAccessSlice').OrganizationAccessState;
+    projectFileReducer: import('./projectFileSlice').ProjectFileState;
+    rehydratedReducer: import('./rehydratedSlice').RehydratedState;
+    formReducer: import('./formSlice').FormState;
+    formRevisionReducer: import('./formRevisionSlice').FormRevisionState;
+    formRevisionAttachmentReducer: import('./formRevisionAttachmentSlice').FormRevisionAttachmentState;
+    formSubmissionAttachmentReducer: import('./formSubmissionAttachmentSlice').FormSubmissionAttachmentState;
+    formSubmissionReducer: import('./formSubmissionSlice').FormSubmissionState;
+    userReducer: import('./userSlice').UserState;
+    emailDomainsReducer: import('./emailDomainsSlice').EmailDomainState;
+    licenseReducer: import('./licenseSlice').LicenseState;
+    documentsReducer: import('./documentSlice').DocumentState;
+    documentAttachmentReducer: import('./documentAttachmentSlice').DocumentAttachmentState;
+    teamReducer: import('./teamSlice').TeamState;
+    agentsReducer: import('./agentsSlice').AgentsState;
+    issueCommentReducer: import('./issueCommentSlice').IssueCommentState;
+    issueCommentAttachmentReducer: import('./issueCommentAttachmentSlice').IssueCommentAttachmentState;
+    issueUpdateReducer: import('./issueUpdateSlice').IssueUpdateState;
+    geoImageReducer: import('./geoImageSlice').GeoImageSliceState;
+    issueAssociationReducer: import('./issueAssociationSlice').IssueAssociationSliceState;
+    issueTypeFieldsReducer: import('./issueTypeFieldsSlice').IssueTypeFieldsState;
+    issueTypeFieldValuesReducer: import('./issueTypeFieldValuesSlice').IssueTypeFieldValuesState;
+    issueTypeFieldsAttachmentReducer: import('./issueTypeFieldsAttachmentSlice').IssueTypeFieldsAttachmentState;
+    issueTypeFieldValuesAttachmentReducer: import('./issueTypeFieldValuesAttachmentSlice').IssueTypeFieldValuesAttachmentState;
+    assetTypeFieldsReducer: import('./assetTypeFieldsSlice').AssetTypeFieldsState;
+    assetTypeFieldValuesReducer: import('./assetTypeFieldValuesSlice').AssetTypeFieldValuesState;
+    assetTypeFieldsAttachmentReducer: import('./assetTypeFieldsAttachmentSlice').AssetTypeFieldsAttachmentState;
+    assetTypeFieldValuesAttachmentReducer: import('./assetTypeFieldValuesAttachmentSlice').AssetTypeFieldValuesAttachmentState;
+    assetProcedureReducer: import('./assetProcedureSlice').AssetProcedureState;
+    assetProcedureInstanceReducer: import('./assetProcedureInstanceSlice').AssetProcedureInstanceState;
+    assetProcedureFieldsReducer: import('./assetProcedureFieldsSlice').AssetProcedureFieldsState;
+    assetProcedureFieldValuesReducer: import('./assetProcedureFieldValuesSlice').AssetProcedureFieldValuesState;
+    assetProcedureFieldsAttachmentReducer: import('./assetProcedureFieldsAttachmentSlice').AssetProcedureFieldsAttachmentState;
+    assetProcedureFieldValuesAttachmentReducer: AssetProcedureFieldValuesAttachmentState;
+    assetProcedureAttachmentReducer: import('./assetProcedureAttachmentSlice').AssetProcedureAttachmentState;
+    outboxReducer: import('./outboxSlice').OutboxState;
+    fileReducer: import('./fileSlice').FileState;
+    authReducer: import('./authSlice').AuthState;
+} & {
+    offline: import('@redux-offline/redux-offline/lib/types').OfflineState;
+}) => Stored<AssetProcedureFieldValuesAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<AssetProcedureFieldValuesAttachment>>) => Stored<AssetProcedureFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<AssetProcedureFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<AssetProcedureFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectAssetProcedureFieldValuesAttachmentById: OvermapSelectorWithArgs<AssetProcedureFieldValuesAttachment["uuid"], Stored<AssetProcedureFieldValuesAttachment> | undefined>;
+export declare const selectAssetProcedureFieldValuesAttachmentsByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureFieldValuesAttachment>[];
+export declare const selectAttachmentsOfAssetProcedureFieldValues: OvermapSelectorWithArgs<AssetProcedureFieldValues["uuid"], Stored<AssetProcedureFieldValuesAttachment>[]>;
+export declare const assetProcedureFieldValuesAttachmentReducer: import('redux').Reducer<AssetProcedureFieldValuesAttachmentState>;