@overmap-ai/core 1.0.78-organization-owner-rename.0 → 1.0.78-organization-owner-rename.1

package/dist/sdk/base.d.ts

@@ -7,6 +7,6 @@ export declare abstract class BaseSDK<TState extends BaseState> {
     readonly store: Store<TState, UnknownAction | ResultAction | ActionCreatorWithPayload<any, any>>;
     abstract readonly files: FileService<TState, BaseSDK<TState>>;
     protected constructor(store: Store<TState>);
-    enqueueRequest<TResult>(requestDetails: SDKRequest, host: string, serviceName: string): Promise<TResult>;
+    enqueueRequest<TResult>(requestDetails: SDKRequest, host: string, serviceName: string, signal?: AbortSignal): Promise<TResult>;
     private _enqueueRequest;
 }

package/dist/sdk/constants.d.ts

@@ -0,0 +1,5 @@
+/** Default pagination max page size as defined on the BaseOvermapCursorPagination class in /api */
+export declare const PAGINATION_MAX_PAGE_SIZE = 50000;
+/** Default pagination page size as */
+export declare const DEFAULT_PAGINATION_PAGE_SIZE = 1000;
+export declare const PAGINATION_PAGE_SIZE_QUERY_PARAM = "limit";

package/dist/sdk/index.d.ts

@@ -1,5 +1,6 @@
 export * from './base';
 export * from './classes';
+export * from './constants';
 export * from './errors';
 export * from './sdk';
 export * from './services';

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<AgentUserConversation[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetProcedureAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetProcedureFieldValuesAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetProcedureFieldValues[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetProcedureFieldsAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetProcedureFields[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetProcedureInstance[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetProcedure[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetProcedureStepFieldValuesAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetProcedureStepFieldValues[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetProcedureStepFieldsAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetProcedureStepFields[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFields[]>;
 }

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

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

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

@@ -9,5 +9,5 @@ export declare abstract class AssetService<TState extends OvermapRootState, TSDK
     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(uuids: Asset["uuid"][]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<Asset[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetStageCompletion[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetStageCompletion[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class AssetStageService<TState extends OvermapRootState,
     add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;
     update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
     delete(uuid: AssetStage["uuid"]): Promise<void>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<AssetStage[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetTypeAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetTypeFieldValuesAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetTypeFieldValues[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<AssetTypeFieldsAttachment[]>;
+    refreshStore(organization: Organization["uuid"], signal?: AbortSignal): 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<AssetTypeFields[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<AssetType[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetType[]>;
 }

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

@@ -2,7 +2,7 @@ import { ResultAction } from '@redux-offline/redux-offline/lib/types';
 import { ActionCreatorWithPayload, UnknownAction } from '@reduxjs/toolkit';
 import { BaseState } from '../../store';
 import { BaseSDK } from '../base';
-import { SDKRequest } from '../typings';
+import { PaginatedResult, SDKRequest } from '../typings';
 export declare const CLASS_NAME_TO_SERVICE: Record<string, BaseService<BaseState, BaseSDK<BaseState>>>;
 /**
  * Abstract base class for building a service that can enqueue API requests
@@ -11,6 +11,7 @@ export declare abstract class BaseService<TStore extends BaseState, TSDK extends
     protected readonly client: TSDK;
     abstract readonly host: string;
     protected constructor(sdk: TSDK);
-    protected enqueueRequest<TResult>(requestDetails: SDKRequest): Promise<TResult>;
+    protected enqueueRequest<TResult>(requestDetails: SDKRequest, signal?: AbortSignal): Promise<TResult>;
+    protected performPagination<TResult>(initialRequest: SDKRequest, nextRequest: (next: NonNullable<PaginatedResult<TResult>["next"]>) => SDKRequest, signal?: AbortSignal): Promise<TResult[]>;
     protected dispatch(action: UnknownAction | ResultAction | ActionCreatorWithPayload<any, any>): void;
 }

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

@@ -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(organizationUuid: Organization["uuid"]): Promise<Category[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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(organizationUuid: Organization["uuid"]): Promise<DocumentAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<DocumentAttachment[]>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class DocumentService<TState extends OvermapRootState, T
     add(payload: Payload<Document>): OptimisticModelResult<Document>;
     update(payload: UUID<Partial<Payload<Document>>>): OptimisticModelResult<Document>;
     delete(uuid: Document["uuid"]): Promise<Document[]>;
-    refreshStore(organizationUuid: Organization["uuid"]): Promise<Document[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<EmailDomain[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<FormRevisionAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<FormRevision[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<Form[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<FormSubmissionAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<FormSubmission[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<GeoImage[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueAssociation[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueCommentAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueComment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<Issue[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueTypeAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<IssueTypeFieldValuesAttachment[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueTypeFieldValues[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): 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<IssueTypeFieldsAttachment[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<IssueTypeFields[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): 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<IssueType[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueType[]>;
 }

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

@@ -3,5 +3,5 @@ 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<IssueUpdate[]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueUpdate[]>;
 }

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

@@ -6,5 +6,5 @@ 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

@@ -6,5 +6,5 @@ export declare abstract class OrganizationService<TState extends OvermapRootStat
     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

@@ -7,5 +7,5 @@ export declare abstract class ProjectAccessService<TState extends OvermapRootSta
     add(payload: Payload<ProjectAccess>): OptimisticModelResult<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

@@ -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

@@ -7,5 +7,5 @@ export declare abstract class ProjectFileService<TState extends OvermapRootState
     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

@@ -6,5 +6,5 @@ export declare abstract class ProjectService<TState extends OvermapRootState, TS
     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

@@ -6,5 +6,5 @@ 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[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<TeamMembership[]>;
 }

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

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

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

@@ -3,5 +3,5 @@ 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(organizationUuid: Organization["uuid"]): Promise<User[]>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<User[]>;
 }

package/dist/sdk/typings.d.ts

@@ -27,7 +27,7 @@ export interface RequestDetails {
     immediate?: boolean;
     isExternalUrl?: boolean;
     isResponseBlob?: boolean;
-    queryParams?: Record<string, string | undefined>;
+    queryParams?: Record<string, string | boolean | number | undefined>;
     isAuthNeeded?: boolean;
     /** The hash of any included attachments being uploaded to S3, retrieved from cache before the request is fired */
     attachmentHash?: string;
@@ -50,6 +50,10 @@ export interface RequestDetails {
 export type SDKRequest = Omit<RequestDetails, "uuid"> & {
     uuid?: string;
 };
+export type PaginatedSDKRequest = SDKRequest & {
+    limit: number;
+    paginate: true;
+};
 /**
  * Represents the result of a successful API request.
  * @deprecated Use `T` directly instead.
@@ -107,6 +111,11 @@ export type OptimisticEmptyResult = Promise<undefined>;
  * Used where the result of an API request is not one or more model instances, but some arbitrary data.
  */
 export type OptimisticGenericResult<T> = [T, DeferredPromise<T> | Promise<T>];
+export type PaginatedResult<T> = {
+    next: string | null;
+    previous: string | null;
+    results: T;
+};
 export interface OfflineMetaEffect {
     request: RequestDetails;
     /** An ISO timestamp of when the request was created. */

package/dist/store/index.d.ts

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

package/dist/store/selectors/SelectorBuilder.d.ts

@@ -0,0 +1,24 @@
+import { Selector } from '../typings';
+/**
+ * A fluent builder for creating memoized Redux selectors.
+ *
+ * Use with `useSelectorBuilder` hook for proper memoization in React components:
+ * @example
+ */
+export declare class SelectorBuilder<TState, TData> {
+    constructor(getData: (state: TState) => TData[]);
+    private operations;
+    readonly getData: (state: TState) => TData[];
+    private performOperations;
+    filter<TKey extends keyof TData>(key: TKey, value: TData[TKey]): this;
+    exclude<TKey extends keyof TData>(key: TKey, value: TData[TKey]): this;
+    orderBy<TKey extends keyof TData>(key: TKey): this;
+    reverse(): this;
+    all(): this;
+    get<TKey extends keyof TData>(key: TKey, value: TData[TKey]): Selector<TState, TData | undefined>;
+    count(): Selector<TState, number>;
+    first(): Selector<TState, TData | undefined>;
+    last(): Selector<TState, TData | undefined>;
+    exists(): Selector<TState, boolean>;
+    toSelector(): Selector<TState, TData[]>;
+}

package/dist/store/selectors/hooks.d.ts

@@ -0,0 +1,13 @@
+import { DependencyList } from 'react';
+import { Selector } from '../typings';
+/**
+ * A hook that memoizes a selector built with SelectorBuilder.
+ *
+ * The selector is rebuilt only when the dependencies change, ensuring stable
+ * selector identity for React-Redux's `useSelector`.
+ *
+ * @param builderFn A function that returns a selector (typically from SelectorBuilder's terminal methods)
+ * @param deps Dependency array - selector is rebuilt when these values change
+ * @returns The memoized selector function
+ */
+export declare function useSelectorBuilder<TState, TResult>(builderFn: () => Selector<TState, TResult>, deps: DependencyList): Selector<TState, TResult>;

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

@@ -0,0 +1,2 @@
+export * from './hooks';
+export * from './SelectorBuilder';