@overmap-ai/core 1.0.74-document-fix.0 → 1.0.74-gcs.1

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

@@ -1,9 +1,9 @@
-import { IssueAssociation, OvermapRootState, Payload } from '../../typings';
+import { IssueAssociation, OvermapRootState, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class IssueAssociationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<IssueAssociation>): OptimisticModelResult<IssueAssociation>;
-    delete(id: string): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    delete(uuid: IssueAssociation["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,39 +1,40 @@
-import { IssueAttachment, OvermapRootState, Stored } from '../../typings';
+import { Issue, IssueAttachment, OvermapRootState, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, string, IssueAttachment> {
+export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueAttachment> {
     name: string;
     url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
     updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
     removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<string>): import('../..').Offline<{
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: number | undefined;
+        created_by: string | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;
         description: string | undefined;
         issue: string;
     }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<string>): {
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
         issue: string;
-        modelId: string;
-        offline_id: import('../..').OfflineModel["offline_id"];
+        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: {
-        issueId: string;
+        issueUuid: Issue["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
-    delete(id: string): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    delete(uuid: IssueAttachment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -0,0 +1,40 @@
+import { IssueComment, IssueCommentAttachment, OvermapRootState, Project, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueCommentAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
+        file: string;
+        file_sha1: string;
+        created_by: string | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue_comment: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
+        issue_comment: 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: {
+        issueCommentUuid: IssueComment["uuid"];
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueCommentAttachment>>;
+    delete(uuid: IssueCommentAttachment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,40 @@
+import { IssueType, IssueTypeAttachment, Organization, OvermapRootState, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticMultipleModelResult } from '../typings';
+import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
+export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueTypeAttachment> {
+    name: string;
+    url: string;
+    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">;
+    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">;
+    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">;
+    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">;
+    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
+        file: string;
+        file_sha1: string;
+        created_by: string | undefined;
+        file_name: string;
+        file_type: string;
+        submitted_at: string;
+        description: string | undefined;
+        issue_type: string;
+    }>;
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
+        issue_type: 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: {
+        issueTypeUuid: IssueType["uuid"];
+        file: File;
+    }[]): Promise<OptimisticMultipleModelResult<IssueTypeAttachment>>;
+    delete(uuid: IssueTypeAttachment["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+}

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

@@ -1,13 +1,13 @@
-import { IssueTypeFieldValuesAttachment, OvermapRootState } from '../../typings';
+import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, OvermapRootState, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
-        fieldValuesId: string;
+        fieldValuesUuid: IssueTypeFieldValues["uuid"];
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldValuesAttachment>>;
-    bulkDelete(attachmentsIds: string[]): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    bulkDelete(uuids: IssueTypeFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,10 +1,10 @@
-import { IssueTypeFieldValues, Offline, OvermapRootState, Payload } from '../../typings';
+import { IssueTypeFieldValues, OvermapRootState, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class IssueTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<IssueTypeFieldValues>): OptimisticModelResult<IssueTypeFieldValues>;
-    update(payload: Offline<Partial<Payload<IssueTypeFieldValues>>>): OptimisticModelResult<IssueTypeFieldValues>;
-    delete(id: string): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    update(payload: UUID<Partial<Payload<IssueTypeFieldValues>>>): OptimisticModelResult<IssueTypeFieldValues>;
+    delete(uuid: IssueTypeFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

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

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

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

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

@@ -1,10 +1,10 @@
-import { IssueType, Offline, OvermapRootState, Payload } from '../../typings';
+import { IssueType, Organization, OvermapRootState, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class IssueTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<IssueType>): OptimisticModelResult<IssueType>;
-    update(payload: Offline<Partial<Payload<IssueType>>>): OptimisticModelResult<IssueType>;
-    delete(id: string): Promise<void>;
-    refreshStore(organizationId: number): Promise<void>;
+    update(payload: UUID<Partial<Payload<IssueType>>>): OptimisticModelResult<IssueType>;
+    delete(uuid: IssueType["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

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

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

@@ -1,4 +1,4 @@
-import { OrganizationAccess, OvermapRootState } from '../../typings';
+import { Organization, OrganizationAccess, OvermapRootState } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
 /**
@@ -7,5 +7,5 @@ import { BaseApiService } from './BaseApiService';
 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>;
-    refreshStore(organizationId: number): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,9 +1,9 @@
-import { Organization, OvermapRootState } from '../../typings';
+import { Organization, OvermapRootState, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class OrganizationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     create(name: string): Promise<Organization>;
     update(organization: Organization): Promise<Organization>;
-    invite(organizationId: number, email: string): Promise<undefined>;
-    refreshStore(projectId: number, organizationId: number): Promise<void>;
+    invite(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { OvermapRootState, ProjectAccess } from '../../typings';
+import { OvermapRootState, Project, ProjectAccess } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
 /**
@@ -6,6 +6,6 @@ import { BaseApiService } from './BaseApiService';
  */
 export declare abstract class ProjectAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     update(projectAccess: ProjectAccess): Promise<ProjectAccess>;
-    remove(id: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<undefined>;
+    remove(uuid: ProjectAccess["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<undefined>;
 }

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

@@ -1,8 +1,8 @@
-import { OvermapRootState, ProjectAttachment, Stored } from '../../typings';
+import { OvermapRootState, Project, ProjectAttachment, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, number, ProjectAttachment> {
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, Stored<ProjectAttachment>> {
     name: string;
     url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
@@ -11,29 +11,29 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
     selectAttachment: import('../..').OvermapSelectorWithArgs<string, ProjectAttachment | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData<number>): import('../..').Offline<{
+    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
-        created_by: number | undefined;
+        created_by: string | undefined;
         file_name: string;
         file_type: string;
         submitted_at: string;
         description: string | undefined;
-        project: number;
+        project: string;
     }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData<number>): {
-        project: number;
-        modelId: number;
-        offline_id: import('../..').OfflineModel["offline_id"];
+    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
+        project: 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: {
-        projectId: number;
+        projectUuid: Project["uuid"];
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    delete(attachmentId: string): Promise<void>;
-    refreshStore(projectId: number): Promise<void>;
+    delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { OvermapRootState, ProjectFile } from '../../typings';
+import { OvermapRootState, Project, ProjectFile } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticGenericResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
@@ -8,6 +8,6 @@ import { BaseApiService } from './BaseApiService';
 export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     saveExisting(file: ProjectFile): Promise<ProjectFile>;
     saveActive(): OptimisticGenericResult<ProjectFile>;
-    delete(projectFileId: string): Promise<undefined>;
-    refreshStore(projectId: number): Promise<void>;
+    delete(uuid: ProjectFile["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { OvermapRootState, Payload, Project } from '../../typings';
+import { OvermapRootState, Payload, Project, User } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
 interface JoinProjectResponse {
@@ -7,9 +7,9 @@ interface JoinProjectResponse {
 export declare abstract class ProjectService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Project>): Promise<Project>;
     update(project: Project): Promise<Project>;
-    delete(projectId: number): Promise<void>;
-    invite(projectId: number, email: string): Promise<undefined>;
-    joinProject(projectId: number, userId: number, inviteCode: string): Promise<JoinProjectResponse>;
-    acceptInvite(projectId: number): Promise<void>;
+    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>;
+    acceptInvite(projectUuid: Project["uuid"]): Promise<void>;
 }
 export {};

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

@@ -1,13 +1,13 @@
-import { Offline, OvermapRootState, Payload, Team, User } from '../../typings';
+import { Organization, OvermapRootState, 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["uuid"][]): Promise<undefined>;
+    addMembers(teamUuid: Team["uuid"], members: User["uuid"][]): Promise<undefined>;
+    removeMembers(teamUuid: Team["uuid"], members: User["uuid"][]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
 }

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

@@ -1,6 +1,6 @@
-import { OvermapRootState } from '../../typings';
+import { Organization, OvermapRootState, 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,11 @@
 export * from './AgentService';
 export * from './AssetAttachmentService';
+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';
@@ -13,7 +19,6 @@ export * from './BaseApiService';
 export * from './CategoryService';
 export * from './DocumentAttachmentService';
 export * from './DocumentService';
-export * from './EmailDomainsService';
 export * from './EmailVerificationService';
 export * from './FileService';
 export * from './FormRevisionAttachmentService';
@@ -24,8 +29,10 @@ export * from './FormSubmissionService';
 export * from './GeoImageService';
 export * from './IssueAssociationService';
 export * from './IssueAttachmentService';
+export * from './IssueCommentAttachmentService';
 export * from './IssueCommentService';
 export * from './IssueService';
+export * from './IssueTypeAttachmentService';
 export * from './IssueTypeFieldsAttachmentService';
 export * from './IssueTypeFieldsService';
 export * from './IssueTypeFieldValuesAttachmentService';
@@ -33,7 +40,6 @@ 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/slices/agentsSlice.d.ts

@@ -1,8 +1,7 @@
-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>, {
+export declare const agentsSlice: import('@reduxjs/toolkit').Slice<AgentsState, {
     initializeConversations: (state: ModelState<AgentUserConversation>, action: {
         payload: AgentUserConversation[];
         type: string;
@@ -19,9 +18,9 @@ export declare const agentsSlice: import('@reduxjs/toolkit').Slice<ModelState<Ag
         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,8 +1,7 @@
-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>>, {
+export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<AssetAttachmentState, {
     initializeAssetAttachments: (state: ModelState<Stored<AssetAttachment>>, action: {
         payload: Stored<AssetAttachment>[];
         type: string;
@@ -33,14 +32,10 @@ export declare const assetAttachmentSlice: import('@reduxjs/toolkit').Slice<Mode
     }) => 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>>>>;
+}, "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 selectAttachmentsOfAssetByType: (args: string) => (state: OvermapRootState) => {
-    fileAttachments: Stored<AssetAttachment>[];
-    imageAttachments: Stored<AssetAttachment>[];
-};
-export declare const assetAttachmentReducer: Reducer<AssetAttachmentState>;
+export declare const assetAttachmentReducer: import('redux').Reducer<AssetAttachmentState>;

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

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