@overmap-ai/core 1.0.78-session-auth.3 → 1.0.78-session-auth-dev.2

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

@@ -7,5 +7,5 @@ export declare abstract class AgentService<TState extends OvermapRootState, TSDK
     continueConversation(prompt: string, conversationUuid: AgentUserConversation["uuid"], projectUuid: Project["uuid"]): Promise<void>;
     fetchDetails(conversationUuid: AgentUserConversation["uuid"]): Promise<void>;
     rate(responseUuid: string, rating: 1 | 5): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AgentUserConversation[]>;
 }

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

@@ -37,5 +37,5 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
     delete(uuid: AssetAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetAttachment[]>;
 }

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

@@ -36,5 +36,5 @@ export declare abstract class AssetProcedureAttachmentService<TState extends Ove
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetProcedureAttachment>>;
     delete(uuid: AssetProcedureAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetProcedureAttachment[]>;
 }

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

@@ -12,5 +12,5 @@ export declare abstract class AssetProcedureFieldValuesAttachmentService<TState
         Promise<Created<AssetProcedureFieldValuesAttachment>[]>[]
     ]>;
     bulkDelete(uuids: AssetProcedureFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetProcedureFieldValuesAttachment[]>;
 }

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

@@ -18,5 +18,5 @@ export declare abstract class AssetProcedureFieldValuesService<TState extends Ov
     }, batchSize?: number): [Stored<AssetProcedureFieldValues>[], Promise<Created<AssetProcedureFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetProcedureFieldValues>>>): OptimisticModelResult<AssetProcedureFieldValues>;
     delete(uuid: AssetProcedureFieldValues["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetProcedureFieldValues[]>;
 }

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

@@ -9,5 +9,5 @@ export declare abstract class AssetProcedureFieldsAttachmentService<TState exten
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetProcedureFieldsAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetProcedureFieldsAttachment[]>;
 }

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

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

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

@@ -7,5 +7,5 @@ export declare abstract class AssetProcedureInstanceService<TState extends Overm
     add(payload: Payload<AssetProcedureInstance>): OptimisticModelResult<AssetProcedureInstance>;
     update(payload: UUID<Partial<Payload<AssetProcedureInstance>>>): OptimisticModelResult<AssetProcedureInstance>;
     remove(uuid: AssetProcedureInstance["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetProcedureInstance[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class AssetProcedureService<TState extends OvermapRootSt
     add(payload: Payload<AssetProcedure>): OptimisticModelResult<AssetProcedure>;
     update(payload: UUID<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;
     remove(uuid: AssetProcedure["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetProcedure[]>;
 }

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

@@ -12,5 +12,5 @@ export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TSt
         Promise<Created<AssetProcedureStepFieldValuesAttachment>[]>[]
     ]>;
     bulkDelete(uuids: AssetProcedureStepFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetProcedureStepFieldValuesAttachment[]>;
 }

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

@@ -19,5 +19,5 @@ export declare abstract class AssetProcedureStepFieldValuesService<TState extend
     }, batchSize?: number): [Stored<AssetProcedureStepFieldValues>[], Promise<Created<AssetProcedureStepFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetProcedureStepFieldValues>>>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     delete(uuid: AssetProcedureStepFieldValues["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetProcedureStepFieldValues[]>;
 }

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

@@ -9,5 +9,5 @@ export declare abstract class AssetProcedureStepFieldsAttachmentService<TState e
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetProcedureStepFieldsAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetProcedureStepFieldsAttachment[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class AssetProcedureStepFieldsService<TState extends Ove
     add(payload: Payload<AssetProcedureStepFields>): OptimisticModelResult<AssetProcedureStepFields>;
     update(payload: UUID<Partial<Payload<AssetProcedureStepFields>>>): OptimisticModelResult<AssetProcedureStepFields>;
     delete(uuid: AssetProcedureStepFields["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetProcedureStepFields[]>;
 }

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

@@ -1,12 +1,11 @@
 import { OvermapRootState } from '../../store';
-import { AssetProcedure, AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
+import { AssetProcedureStep, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    bulkAdd(stepsToSubmit: Omit<Payload<AssetProcedureStep>, "asset_procedure">[], assetProcedureUuid: string): OptimisticMultipleModelResult<AssetProcedureStep>;
-    bulkUpdate(stepsToUpdate: AssetProcedureStep[], assetProcedureUuid: AssetProcedure["uuid"]): Promise<AssetProcedureStep[]>;
-    bulkDelete(uuids: AssetProcedureStep["uuid"][]): Promise<undefined>;
+    add(payload: Payload<AssetProcedureStep>): OptimisticModelResult<AssetProcedureStep>;
     update(payload: UUID<Partial<Payload<AssetProcedureStep>>>): OptimisticModelResult<AssetProcedureStep>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+    delete(uuid: AssetProcedureStep["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetProcedureStep[]>;
 }

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

@@ -8,6 +8,6 @@ export declare abstract class AssetService<TState extends OvermapRootState, TSDK
     update(payload: UUID<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
     delete(uuid: Asset["uuid"]): Promise<undefined>;
     bulkAdd(payloads: Omit<Payload<Asset>, "asset_type" | "project">[], assetTypeUuid: AssetType["uuid"], projectUuid: Project["uuid"], batchSize: number): Promise<Created<Asset>[]>[];
-    bulkDelete(assetUuids: Asset["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    bulkDelete(uuids: Asset["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<Asset[]>;
 }

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

@@ -8,5 +8,5 @@ export declare abstract class AssetStageCompletionService<TState extends Overmap
     delete(uuid: AssetStageCompletion["uuid"]): Promise<undefined>;
     bulkAdd(payloads: Payload<AssetStageCompletion>[]): OptimisticMultipleModelResult<AssetStageCompletion>;
     bulkDelete(uuids: AssetStageCompletion["uuid"][]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetStageCompletion[]>;
 }

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

@@ -1,12 +1,11 @@
 import { OvermapRootState } from '../../store';
-import { AssetProcedure, AssetStage, Organization, Payload, UUID } from '../../typings';
+import { AssetStage, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    bulkAdd(stagesToSubmit: Omit<Payload<AssetStage>, "asset_procedure">[], assetProcedureUuid: string): OptimisticMultipleModelResult<AssetStage>;
-    bulkUpdate(stagesToUpdate: AssetStage[], assetProcedureUuid: AssetProcedure["uuid"]): Promise<AssetStage[]>;
-    bulkDelete(uuids: AssetStage["uuid"][]): Promise<undefined>;
+    add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;
     update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<undefined>;
+    delete(uuid: AssetStage["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetStage[]>;
 }

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

@@ -36,5 +36,5 @@ export declare abstract class AssetTypeAttachmentService<TState extends OvermapR
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
     delete(uuid: AssetTypeAttachment["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetTypeAttachment[]>;
 }

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

@@ -9,5 +9,5 @@ export declare abstract class AssetTypeFieldValuesAttachmentService<TState exten
         file: File;
     }[], batchSize?: number): Promise<[Stored<AssetTypeFieldValuesAttachment>[], Promise<Created<AssetTypeFieldValuesAttachment>[]>[]]>;
     bulkDelete(uuids: AssetTypeFieldValuesAttachment["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetTypeFieldValuesAttachment[]>;
 }

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

@@ -17,5 +17,5 @@ export declare abstract class AssetTypeFieldValuesService<TState extends Overmap
     }, batchSize?: number): [Stored<AssetTypeFieldValues>[], Promise<Created<AssetTypeFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetTypeFieldValues>>>): OptimisticModelResult<AssetTypeFieldValues>;
     delete(uuid: AssetTypeFieldValues["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<AssetTypeFieldValues[]>;
 }

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

@@ -9,5 +9,5 @@ export declare abstract class AssetTypeFieldsAttachmentService<TState extends Ov
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<AssetTypeFieldsAttachment>>;
-    refreshStore(organization: Organization["uuid"]): Promise<void>;
+    refreshStore(organization: Organization["uuid"]): Promise<AssetTypeFieldsAttachment[]>;
 }

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

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

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

@@ -7,5 +7,5 @@ export declare abstract class AssetTypeService<TState extends OvermapRootState,
     add(payload: Payload<AssetType>): OptimisticModelResult<AssetType>;
     update(payload: UUID<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;
     delete(uuid: AssetType["uuid"]): Promise<undefined>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetType[]>;
 }

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

@@ -4,7 +4,7 @@ import { BaseSDK } from '../base';
 import { BaseService } from './BaseService';
 export declare abstract class BaseAuthService<TStore extends BaseState, TSDK extends BaseSDK<TStore>> extends BaseService<TStore, TSDK> {
     clearAuth(): void;
-    protected initAuth(payload: object): Promise<void>;
+    initAuth(payload: object): Promise<void>;
     prepareAuth(): Promise<void>;
     abstract prepareRequest(request: SuperAgentRequest): SuperAgentRequest;
     abstract handleUnauthorized(request: SuperAgentRequest, response: Response): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { OvermapRootState } from '../../store';
-import { Category, Payload, Project, UUID } from '../../typings';
+import { Category, Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
@@ -7,5 +7,5 @@ export declare abstract class CategoryService<TState extends OvermapRootState, T
     add(payload: Payload<Category>): OptimisticModelResult<Category>;
     update(payload: UUID<Partial<Payload<Category>>>): OptimisticModelResult<Category>;
     remove(uuid: Category["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<Category[]>;
 }

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

@@ -37,5 +37,5 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
     }[]): Promise<OptimisticMultipleModelResult<DocumentAttachment>>;
     delete(uuid: DocumentAttachment["uuid"]): Promise<void>;
     private makeReadable;
-    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<DocumentAttachment[]>;
 }

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

@@ -8,5 +8,5 @@ export declare abstract class DocumentService<TState extends OvermapRootState, T
     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<void>;
+    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<Document[]>;
 }

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

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

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

@@ -9,5 +9,5 @@ export declare abstract class FormRevisionAttachmentService<TState extends Overm
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<FormRevisionAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<FormRevisionAttachment[]>;
 }

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

@@ -5,5 +5,5 @@ import { OptimisticModelResult } from '../typings';
 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<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<FormRevision[]>;
 }

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

@@ -5,5 +5,5 @@ 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<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<Form[]>;
 }

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

@@ -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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<FormSubmissionAttachment[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class FormSubmissionService<TState extends OvermapRootSt
     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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<FormSubmission[]>;
 }

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

@@ -8,5 +8,5 @@ export declare abstract class GeoImageService<TState extends OvermapRootState, T
     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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<GeoImage[]>;
 }

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

@@ -6,5 +6,5 @@ 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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueAssociation[]>;
 }

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

@@ -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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueAttachment[]>;
 }

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

@@ -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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueCommentAttachment[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class IssueCommentService<TState extends OvermapRootStat
     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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueComment[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class IssueService<TState extends OvermapRootState, 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<undefined>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<Issue[]>;
 }

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

@@ -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<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueTypeAttachment[]>;
 }

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

@@ -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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueTypeFieldValuesAttachment[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class IssueTypeFieldValuesService<TState extends Overmap
     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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueTypeFieldValues[]>;
 }

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

@@ -9,5 +9,5 @@ export declare abstract class IssueTypeFieldsAttachmentService<TState extends Ov
         fieldIdentifier: string;
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldsAttachment>>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueTypeFieldsAttachment[]>;
 }

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

@@ -5,5 +5,5 @@ 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(organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueTypeFields[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class IssueTypeService<TState extends OvermapRootState,
     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<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<IssueType[]>;
 }

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

@@ -1,7 +1,7 @@
 import { OvermapRootState } from '../../store';
-import { Project } from '../../typings';
+import { IssueUpdate, 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(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<IssueUpdate[]>;
 }

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

@@ -33,5 +33,5 @@ export declare abstract class JWTAuthService<TState extends BaseState, TSDK exte
     private getAuthHeader;
     prepareRequest(request: SuperAgentRequest): SuperAgentRequest;
     handleUnauthorized(request: request.SuperAgentRequest, response: request.Response): Promise<void>;
-    protected initAuth(payload: object): Promise<void>;
+    initAuth(payload: object): Promise<void>;
 }

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

@@ -1,9 +1,10 @@
 import { OvermapRootState } from '../../store';
-import { Organization, OrganizationAccess } from '../../typings';
+import { Organization, OrganizationAccess, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
 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(organizationUuid: Organization["uuid"]): Promise<void>;
+    update(payload: UUID<Payload<OrganizationAccess>>): OptimisticModelResult<OrganizationAccess>;
+    remove(uuid: OrganizationAccess["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<OrganizationAccess[]>;
 }

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

@@ -1,10 +1,10 @@
 import { OvermapRootState } from '../../store';
-import { Organization, Project } from '../../typings';
+import { Organization, Payload, UUID } 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>;
+    add(payload: Payload<Organization>): Promise<Organization>;
+    update(payload: UUID<Partial<Payload<Organization>>>): Promise<Organization>;
     invite(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(): Promise<Organization[]>;
 }

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

@@ -1,9 +1,11 @@
 import { OvermapRootState } from '../../store';
-import { Project, ProjectAccess } from '../../typings';
+import { Organization, Payload, ProjectAccess, UUID } from '../../typings';
 import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
 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>;
+    add(payload: Payload<ProjectAccess>): OptimisticModelResult<ProjectAccess>;
+    update(payload: UUID<Payload<ProjectAccess>>): OptimisticModelResult<ProjectAccess>;
     remove(uuid: ProjectAccess["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<ProjectAccess[]>;
 }

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

@@ -1,5 +1,5 @@
 import { OvermapRootState } from '../../store';
-import { Project, ProjectAttachment, Stored } from '../../typings';
+import { Organization, Project, ProjectAttachment, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
 import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
@@ -36,5 +36,5 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
         file: File;
     }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
     delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<ProjectAttachment[]>;
 }

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

@@ -3,12 +3,9 @@ import { Project, ProjectFile } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticGenericResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
-/**
- * Handles creation and caching of ProjectFiles
- */
 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<void>;
+    refreshStore(projectUuid: Project["uuid"]): Promise<ProjectFile[]>;
 }

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

@@ -1,16 +1,10 @@
 import { OvermapRootState } from '../../store';
-import { Payload, Project, User } from '../../typings';
+import { Organization, Payload, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { BaseApiService } from './BaseApiService';
-interface JoinProjectResponse {
-    username: string;
-}
 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>;
-    invite(projectUuid: Project["uuid"], email: string): Promise<undefined>;
-    joinProject(projectUuid: Project["uuid"], userUuid: User["id"], inviteCode: string): Promise<JoinProjectResponse>;
-    acceptInvite(projectUuid: Project["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<Project[]>;
 }
-export {};

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

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

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

@@ -1,5 +1,5 @@
 import { OvermapRootState } from '../../store';
-import { Organization, Payload, Team, User, UUID } from '../../typings';
+import { Organization, Payload, Team, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { BaseApiService } from './BaseApiService';
@@ -7,8 +7,5 @@ export declare abstract class TeamService<TState extends OvermapRootState, TSDK
     add(payload: Payload<Team>): OptimisticModelResult<Team>;
     update(payload: UUID<Partial<Payload<Team>>>): OptimisticModelResult<Team>;
     delete(uuid: Team["uuid"]): Promise<undefined>;
-    setMembers(teamUuid: Team["uuid"], members: User["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>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<Team[]>;
 }

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

@@ -1,7 +1,7 @@
 import { OvermapRootState } from '../../store';
-import { Organization, Project } from '../../typings';
+import { Organization, User } 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(projectUuid: Project["uuid"], organizationUuid: Organization["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"]): Promise<User[]>;
 }

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

@@ -47,7 +47,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';
@@ -55,5 +54,6 @@ export * from './ProjectAttachmentService';
 export * from './ProjectFileService';
 export * from './ProjectService';
 export * from './SessionAuthService';
+export * from './TeamMembershipService';
 export * from './TeamService';
 export * from './UserService';