@overmap-ai/core 1.0.78-session-auth-dev.4 → 1.0.78-status-models.0

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

@@ -1,12 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { Document, MovePosition, Organization, Payload, Project, UUID } from '../../typings';
+import { Document, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class DocumentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Document>): OptimisticModelResult<Document>;
     update(payload: UUID<Partial<Payload<Document>>>): OptimisticModelResult<Document>;
-    move(documentUuid: Document["uuid"], targetDocumentUuid: Document["uuid"] | null, position: MovePosition): Promise<Document[]>;
     delete(uuid: Document["uuid"]): Promise<Document[]>;
-    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<Document[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Document[]>;
 }

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { EmailDomain, Organization } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 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<EmailDomain[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<EmailDomain[]>;
 }

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

@@ -1,5 +1,5 @@
-import { BaseState } from '../../store';
 import { BaseSDK } from '../base';
+import { BaseState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export interface GetS3UrlSuccessResponse {
     url: string;
@@ -18,7 +18,7 @@ interface DatabaseFileProperties {
     file: string;
 }
 export declare abstract class FileService<TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    protected readonly host: string;
+    host: string;
     private _dbPromise;
     private renewUploadUrl;
     /**

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

@@ -0,0 +1,11 @@
+import { FormIdentifier, Organization, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class FormIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<FormIdentifier>): OptimisticModelResult<FormIdentifier>;
+    update(payload: UUID<Partial<Payload<FormIdentifier>>>): OptimisticModelResult<FormIdentifier>;
+    delete(uuid: FormIdentifier["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormIdentifier[]>;
+}

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

@@ -0,0 +1,11 @@
+import { FormIdentifierValue, Organization, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class FormIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<FormIdentifierValue>): OptimisticModelResult<FormIdentifierValue>;
+    update(payload: UUID<Partial<Payload<FormIdentifierValue>>>): OptimisticModelResult<FormIdentifierValue>;
+    delete(uuid: FormIdentifierValue["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormIdentifierValue[]>;
+}

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { FormRevision, FormRevisionAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class FormRevisionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -9,5 +9,5 @@ export declare abstract class FormRevisionAttachmentService<TState extends Overm
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<FormRevisionAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<FormRevisionAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormRevisionAttachment[]>;
 }

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { FormRevision, FormRevisionPayload, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class FormRevisionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     add(payload: FormRevisionPayload): OptimisticModelResult<FormRevision>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<FormRevision[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormRevision[]>;
 }

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { Created, Form, FormRevision, Organization, Payload, Stored } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class FormService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     add(payload: Payload<Form>, initialRevision: Pick<FormRevision, "title" | "description" | "fields">): [Stored<Form>, Stored<FormRevision>, Promise<Created<FormRevision>>];
     delete(uuid: Form["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<Form[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Form[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
-import { FormSubmission, FormSubmissionAttachment, Project } from '../../typings';
+import { FormSubmission, FormSubmissionAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class FormSubmissionAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -10,5 +10,5 @@ export declare abstract class FormSubmissionAttachmentService<TState extends Ove
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<FormSubmissionAttachment>>;
     bulkDelete(uuids: FormSubmissionAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<FormSubmissionAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormSubmissionAttachment[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { FormSubmission, Payload, Project, UUID } from '../../typings';
+import { FormSubmission, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class FormSubmissionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     add(payload: Payload<FormSubmission>): OptimisticModelResult<FormSubmission>;
     update(payload: UUID<Partial<Payload<FormSubmission>>>): OptimisticModelResult<FormSubmission>;
     delete(uuid: FormSubmission["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<FormSubmission[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormSubmission[]>;
 }

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

@@ -1,12 +1,12 @@
-import { OvermapRootState } from '../../store';
 import { BulkGeoImagePayload, GeoImage, GeoImagePayload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class GeoImageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     add(payload: GeoImagePayload): Promise<OptimisticModelResult<GeoImage>>;
     bulkAdd(payloads: BulkGeoImagePayload[], projectUuid: string): Promise<OptimisticMultipleModelResult<GeoImage>>;
     update(payload: UUID<Partial<Pick<GeoImagePayload, "title" | "description">>>): OptimisticModelResult<GeoImage>;
     delete(uuid: GeoImage["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<GeoImage[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<GeoImage[]>;
 }

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

@@ -1,10 +1,10 @@
-import { OvermapRootState } from '../../store';
 import { IssueAssociation, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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(uuid: IssueAssociation["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueAssociation[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAssociation[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { Issue, IssueAttachment, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
 export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueAttachment> {
     name: string;
@@ -37,5 +37,5 @@ export declare abstract class IssueAttachmentService<TState extends OvermapRootS
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
     delete(uuid: IssueAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAttachment[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { IssueComment, IssueCommentAttachment, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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;
@@ -37,5 +37,5 @@ export declare abstract class IssueCommentAttachmentService<TState extends Overm
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueCommentAttachment>>;
     delete(uuid: IssueCommentAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueCommentAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueCommentAttachment[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { IssueComment, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<IssueComment>>>): OptimisticModelResult<IssueComment>;
     remove(uuid: IssueComment["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueComment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueComment[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { Issue, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<Issue>>>): OptimisticModelResult<Issue>;
     remove(uuid: Issue["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<Issue[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Issue[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { IssueType, IssueTypeAttachment, Organization, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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;
@@ -37,5 +37,5 @@ export declare abstract class IssueTypeAttachmentService<TState extends OvermapR
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueTypeAttachment>>;
     delete(uuid: IssueTypeAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueTypeAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeAttachment[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -10,5 +10,5 @@ export declare abstract class IssueTypeFieldValuesAttachmentService<TState exten
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldValuesAttachment>>;
     bulkDelete(uuids: IssueTypeFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueTypeFieldValuesAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldValuesAttachment[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { IssueTypeFieldValues, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<IssueTypeFieldValues>>>): OptimisticModelResult<IssueTypeFieldValues>;
     delete(uuid: IssueTypeFieldValues["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueTypeFieldValues[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldValues[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { IssueTypeFields, IssueTypeFieldsAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseUploadService } from './BaseUploadService';
 export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
     bulkAdd(payloads: {
@@ -9,5 +9,5 @@ export declare abstract class IssueTypeFieldsAttachmentService<TState extends Ov
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldsAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueTypeFieldsAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldsAttachment[]>;
 }

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { IssueTypeFields, Organization, Payload } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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(organizationUuid: Organization["uuid"]): Promise<IssueTypeFields[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeFields[]>;
 }

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

@@ -0,0 +1,11 @@
+import { IssueTypeIdentifier, Organization, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class IssueTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<IssueTypeIdentifier>): OptimisticModelResult<IssueTypeIdentifier>;
+    update(payload: UUID<Partial<Payload<IssueTypeIdentifier>>>): OptimisticModelResult<IssueTypeIdentifier>;
+    delete(uuid: IssueTypeIdentifier["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeIdentifier[]>;
+}

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

@@ -0,0 +1,11 @@
+import { IssueTypeIdentifierValue, Payload, Project, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class IssueTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<IssueTypeIdentifierValue>): OptimisticModelResult<IssueTypeIdentifierValue>;
+    update(payload: UUID<Partial<Payload<IssueTypeIdentifierValue>>>): OptimisticModelResult<IssueTypeIdentifierValue>;
+    delete(uuid: IssueTypeIdentifierValue["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueTypeIdentifierValue[]>;
+}

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { IssueType, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<IssueType>>>): OptimisticModelResult<IssueType>;
     delete(uuid: IssueType["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueType[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueType[]>;
 }

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

@@ -0,0 +1,11 @@
+import { IssueTypeStatus, Organization, Payload, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseApiService } from './BaseApiService';
+export declare abstract class IssueTypeStatusService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+    add(payload: Payload<IssueTypeStatus>): OptimisticModelResult<IssueTypeStatus>;
+    update(payload: UUID<Partial<Payload<IssueTypeStatus>>>): OptimisticModelResult<IssueTypeStatus>;
+    delete(uuid: IssueTypeStatus["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeStatus[]>;
+}

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { IssueUpdate, Project } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class IssueUpdateService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    refreshStore(projectUuid: Project["uuid"]): Promise<IssueUpdate[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueUpdate[]>;
 }

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

@@ -1,12 +1,12 @@
-import { default as request, SuperAgentRequest } from 'superagent';
-import { BaseState } from '../../store';
+import { default as request } from 'superagent';
 import { BaseSDK } from '../base';
 import { TokenPair } from '../typings';
+import { BaseState } from '../../store';
 import { BaseAuthService } from './BaseAuthService';
 /**
  * Handles login, logout and renewing tokens
  */
-export declare abstract class JWTAuthService<TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseAuthService<TState, TSDK> {
+export declare abstract class JWTService<TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseAuthService<TState, TSDK> {
     protected abstract initTokensUrl: string;
     protected abstract refreshTokensUrl: string;
     protected abstract setTokens: (tokens: TokenPair) => void;
@@ -28,10 +28,9 @@ export declare abstract class JWTAuthService<TState extends BaseState, TSDK exte
      * Attempts to renew tokens
      */
     renewTokens(): Promise<undefined>;
-    protected tokenIsExpiringSoon(): boolean;
+    tokenIsExpiringSoon(): boolean;
+    getAuthHeader(): string;
     prepareAuth(): Promise<undefined>;
-    private getAuthHeader;
-    prepareRequest(request: SuperAgentRequest): SuperAgentRequest;
     handleUnauthorized(request: request.SuperAgentRequest, response: request.Response): Promise<void>;
     initAuth(payload: object): Promise<void>;
 }

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

@@ -1,10 +1,10 @@
-import { OvermapRootState } from '../../store';
 import { Organization, OrganizationAccess, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class OrganizationAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     update(payload: UUID<Payload<OrganizationAccess>>): OptimisticModelResult<OrganizationAccess>;
     remove(uuid: OrganizationAccess["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<OrganizationAccess[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<OrganizationAccess[]>;
 }

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

@@ -1,10 +1,10 @@
-import { OvermapRootState } from '../../store';
 import { Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class OrganizationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<Organization>): Promise<Organization>;
     update(payload: UUID<Partial<Payload<Organization>>>): Promise<Organization>;
     invite(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
-    refreshStore(): Promise<Organization[]>;
+    refreshStore(signal?: AbortSignal): Promise<Organization[]>;
 }

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

@@ -1,11 +1,12 @@
-import { OvermapRootState } from '../../store';
-import { Organization, Payload, ProjectAccess, UUID } from '../../typings';
+import { Organization, Payload, ProjectAccess, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class ProjectAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<ProjectAccess>): OptimisticModelResult<ProjectAccess>;
+    bulkAdd(payloads: Payload<ProjectAccess>[]): (Submitted<ProjectAccess>[] | Promise<ProjectAccess[]>)[];
     update(payload: UUID<Payload<ProjectAccess>>): OptimisticModelResult<ProjectAccess>;
     remove(uuid: ProjectAccess["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<ProjectAccess[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProjectAccess[]>;
 }

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

@@ -1,9 +1,9 @@
-import { OvermapRootState } from '../../store';
 import { Organization, Project, ProjectAttachment, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, Stored<ProjectAttachment>> {
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, ProjectAttachment> {
     name: string;
     url: string;
     addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
@@ -11,7 +11,7 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
     removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
     removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
     setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, ProjectAttachment | undefined>;
+    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAttachment> | undefined>;
     protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
         file: string;
         file_sha1: string;
@@ -36,5 +36,5 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
     delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<ProjectAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProjectAttachment[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { Project, ProjectFile } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticGenericResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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(uuid: ProjectFile["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<ProjectFile[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProjectFile[]>;
 }

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

@@ -1,10 +1,10 @@
-import { OvermapRootState } from '../../store';
 import { Organization, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 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(uuid: Project["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<Project[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Project[]>;
 }

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

@@ -1,10 +1,11 @@
-import { OvermapRootState } from '../../store';
-import { Organization, Payload, TeamMembership } from '../../typings';
+import { Organization, Payload, Submitted, TeamMembership } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class TeamMembershipService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
     add(payload: Payload<TeamMembership>): OptimisticModelResult<TeamMembership>;
+    bulkAdd(payloads: Payload<TeamMembership>[]): (Submitted<TeamMembership>[] | Promise<TeamMembership[]>)[];
     delete(uuid: TeamMembership["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<TeamMembership[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<TeamMembership[]>;
 }

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

@@ -1,11 +1,11 @@
-import { OvermapRootState } from '../../store';
 import { Organization, Payload, Team, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
 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: UUID<Partial<Payload<Team>>>): OptimisticModelResult<Team>;
     delete(uuid: Team["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<Team[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Team[]>;
 }

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

@@ -1,7 +1,7 @@
-import { OvermapRootState } from '../../store';
 import { Organization, User } from '../../typings';
 import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class UserService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<User[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<User[]>;
 }