@overmap-ai/core 1.0.78-document-service-fix.0 → 1.0.78-gcs.0

package/dist/sdk/constants.d.ts

@@ -1,5 +1,4 @@
-/** Default pagination page size  */
 export declare const DEFAULT_PAGE_SIZE = 10000;
-/** Attachment model pagination page size */
 export declare const ATTACHMENT_MODEL_DEFAULT_PAGE_SIZE = 200;
 export declare const DISCARD_HTTP_STATUSES: number[];
+export declare const MAX_SERVICE_BATCH_SIZE = 10000;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetAttachmentService<TState extends OvermapRootS
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetAttachment>[];
     };
     protected getId(model: Stored<AssetAttachment>): AssetAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<AssetAttachment>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureService<TState extends OvermapRootSt
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedure> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedure>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedure>[];
     };
     add(payload: Payload<AssetProcedure>): OptimisticModelResult<AssetProcedure>;
     update(payload: UUID<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;

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

@@ -18,7 +18,7 @@ export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TSt
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValuesAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStepFieldValuesAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValuesAttachment>[];
     };
     bulkAdd(payloads: {
         fieldValuesUuid: AssetProcedureStepFieldValues["uuid"];

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

@@ -1,5 +1,5 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { Asset, AssetProcedure, AssetProcedureStep, AssetProcedureStepFields, AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
+import { AssetProcedureStepFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
@@ -20,19 +20,12 @@ export declare abstract class AssetProcedureStepFieldValuesService<TState extend
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValues> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStepFieldValues>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValues>[];
     };
     add(payload: Payload<AssetProcedureStepFieldValues>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;
-        payloads: {
-            values: SerializedFieldValues;
-            asset: Asset["uuid"];
-            fields_revision: AssetProcedureStepFields["uuid"];
-            asset_procedure: AssetProcedure["uuid"];
-            asset_procedure_step: AssetProcedureStep["uuid"];
-            published_at: string;
-        }[];
+        payloads: Payload<AssetProcedureStepFieldValues>[];
     }, batchSize?: number): [Stored<AssetProcedureStepFieldValues>[], Promise<Created<AssetProcedureStepFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetProcedureStepFieldValues>>>): OptimisticModelResult<AssetProcedureStepFieldValues>;
     delete(uuid: AssetProcedureStepFieldValues["uuid"]): Promise<void>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureStepFieldsAttachmentService<TState e
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetProcedureStepFieldsAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<AssetProcedureStepFieldsAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<AssetProcedureStepFieldsAttachment>[];
     };
     bulkAdd(payloads: {
         fieldsRevisionUuid: AssetProcedureStepFields["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureStepFieldsService<TState extends Ove
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFields> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStepFields>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFields>[];
     };
     add(payload: Payload<AssetProcedureStepFields>): OptimisticModelResult<AssetProcedureStepFields>;
     update(payload: UUID<Partial<Payload<AssetProcedureStepFields>>>): OptimisticModelResult<AssetProcedureStepFields>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureStepService<TState extends OvermapRo
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStep> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureStep>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStep>[];
     };
     add(payload: Payload<AssetProcedureStep>): OptimisticModelResult<AssetProcedureStep>;
     update(payload: UUID<Partial<Payload<AssetProcedureStep>>>): OptimisticModelResult<AssetProcedureStep>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureTypeAttachmentService<TState extends
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeAttachment>[];
     };
     protected getId(model: Stored<AssetProcedureTypeAttachment>): AssetProcedureTypeAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<AssetProcedureTypeAttachment>;

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

@@ -18,7 +18,7 @@ export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TSt
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValuesAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeFieldValuesAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValuesAttachment>[];
     };
     bulkAdd(payloads: {
         fieldValuesUuid: AssetProcedureTypeFieldValues["uuid"];

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

@@ -1,5 +1,5 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { Asset, AssetProcedure, AssetProcedureTypeFields, AssetProcedureTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
+import { AssetProcedureTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
@@ -20,18 +20,12 @@ export declare abstract class AssetProcedureTypeFieldValuesService<TState extend
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValues> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeFieldValues>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValues>[];
     };
     add(payload: Payload<AssetProcedureTypeFieldValues>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;
-        payloads: {
-            values: SerializedFieldValues;
-            asset: Asset["uuid"];
-            fields_revision: AssetProcedureTypeFields["uuid"];
-            asset_procedure: AssetProcedure["uuid"];
-            published_at: string;
-        }[];
+        payloads: Payload<AssetProcedureTypeFieldValues>[];
     }, batchSize?: number): [Stored<AssetProcedureTypeFieldValues>[], Promise<Created<AssetProcedureTypeFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetProcedureTypeFieldValues>>>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
     delete(uuid: AssetProcedureTypeFieldValues["uuid"]): Promise<void>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureTypeFieldsAttachmentService<TState e
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetProcedureTypeFieldsAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<AssetProcedureTypeFieldsAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<AssetProcedureTypeFieldsAttachment>[];
     };
     bulkAdd(payloads: {
         fieldsRevisionUuid: AssetProcedureTypeFields["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureTypeFieldsService<TState extends Ove
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFields> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureTypeFields>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFields>[];
     };
     add(payload: Payload<AssetProcedureTypeFields>): OptimisticModelResult<AssetProcedureTypeFields>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFields[]>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetProcedureTypeService<TState extends OvermapRo
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureType> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetProcedureType>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureType>[];
     };
     add(payload: Payload<AssetProcedureType>): OptimisticModelResult<AssetProcedureType>;
     update(payload: UUID<Partial<Payload<AssetProcedureType>>>): OptimisticModelResult<AssetProcedureType>;

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

@@ -19,12 +19,12 @@ export declare abstract class AssetService<TState extends OvermapRootState, TSDK
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Asset> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<Asset>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Asset>[];
     };
     add(payload: Payload<Asset>): OptimisticModelResult<Asset>;
     update(payload: UUID<Partial<Payload<Asset>>>): OptimisticModelResult<Asset>;
     delete(uuid: Asset["uuid"]): Promise<undefined>;
-    bulkAdd(payloads: Payload<Asset>[], batchSize: number): Promise<Created<Asset>[]>[];
+    bulkAdd(payloads: Payload<Asset>[], batchSize?: number): Promise<Created<Asset>[]>[];
     bulkDelete(uuids: Asset["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Asset[]>;
 }

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

@@ -19,7 +19,7 @@ export declare abstract class AssetStageCompletionService<TState extends Overmap
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetStageCompletion>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetStageCompletion>[];
     };
     add(payload: Payload<AssetStageCompletion>): OptimisticModelResult<AssetStageCompletion>;
     delete(uuid: AssetStageCompletion["uuid"]): Promise<undefined>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetStageService<TState extends OvermapRootState,
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetStage> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetStage>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetStage>[];
     };
     add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;
     update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetTypeAttachmentService<TState extends OvermapR
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeAttachment>[];
     };
     protected getId(model: Stored<AssetTypeAttachment>): AssetTypeAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<AssetTypeAttachment>;

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

@@ -18,7 +18,7 @@ export declare abstract class AssetTypeFieldValuesAttachmentService<TState exten
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValuesAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValuesAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldValuesAttachment>[];
     };
     bulkAdd(payloads: {
         fieldValuesUuid: AssetTypeFieldValues["uuid"];

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

@@ -1,5 +1,5 @@
 import { SerializedFieldValues } from '@overmap-ai/forms';
-import { Asset, AssetTypeFields, AssetTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
+import { AssetTypeFieldValues, Created, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
@@ -20,17 +20,12 @@ export declare abstract class AssetTypeFieldValuesService<TState extends Overmap
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldValues> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldValues>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldValues>[];
     };
     add(payload: Payload<AssetTypeFieldValues>): OptimisticModelResult<AssetTypeFieldValues>;
     bulkAdd(payload: {
         values: SerializedFieldValues;
-        payloads: {
-            values: SerializedFieldValues;
-            asset: Asset["uuid"];
-            fields_revision: AssetTypeFields["uuid"];
-            published_at: string;
-        }[];
+        payloads: Payload<AssetTypeFieldValues>[];
     }, batchSize?: number): [Stored<AssetTypeFieldValues>[], Promise<Created<AssetTypeFieldValues>[]>[]];
     update(payload: UUID<Partial<Payload<AssetTypeFieldValues>>>): OptimisticModelResult<AssetTypeFieldValues>;
     delete(uuid: AssetTypeFieldValues["uuid"]): Promise<void>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetTypeFieldsAttachmentService<TState extends Ov
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeFieldsAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeFieldsAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeFieldsAttachment>[];
     };
     bulkAdd(payloads: {
         fieldsRevisionUuid: AssetTypeFields["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class AssetTypeFieldsService<TState extends OvermapRootS
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<AssetTypeFields> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<AssetTypeFields>[];
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<AssetTypeFields>[];
     };
     add(payload: Payload<AssetTypeFields>): OptimisticModelResult<AssetTypeFields>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetTypeFields[]>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetTypeIdentifierService<TState extends OvermapR
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeIdentifier> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeIdentifier>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeIdentifier>[];
     };
     add(payload: Payload<AssetTypeIdentifier>): OptimisticModelResult<AssetTypeIdentifier>;
     update(payload: UUID<Partial<Payload<AssetTypeIdentifier>>>): OptimisticModelResult<AssetTypeIdentifier>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetTypeIdentifierValueService<TState extends Ove
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetTypeIdentifierValue> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetTypeIdentifierValue>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetTypeIdentifierValue>[];
     };
     add(payload: Payload<AssetTypeIdentifierValue>): OptimisticModelResult<AssetTypeIdentifierValue>;
     update(payload: UUID<Partial<Payload<AssetTypeIdentifierValue>>>): OptimisticModelResult<AssetTypeIdentifierValue>;

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

@@ -19,7 +19,7 @@ export declare abstract class AssetTypeService<TState extends OvermapRootState,
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetType> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<AssetType>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetType>[];
     };
     add(payload: Payload<AssetType>): OptimisticModelResult<AssetType>;
     update(payload: UUID<Partial<Payload<AssetType>>>): OptimisticModelResult<AssetType>;

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

@@ -7,7 +7,7 @@ export interface BuildModelData {
     file: File;
     file_sha1: string;
     submitted_at: string;
-    created_by: User["id"] | null;
+    created_by: User["uuid"] | null;
     modelUuid: UUIDModel["uuid"];
 }
 export declare abstract class BaseOfflineAttachmentModelService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>, TModelId extends string, TModel extends RequiredFileWithNameModel> extends BaseOfflineModelApiService<TModelId, TModel, TState, TSDK> {

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

@@ -19,7 +19,7 @@ export declare abstract class CategoryService<TState extends OvermapRootState, T
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Category> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<Category>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Category>[];
     };
     add(payload: Payload<Category>): OptimisticModelResult<Category>;
     update(payload: UUID<Partial<Payload<Category>>>): OptimisticModelResult<Category>;

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

@@ -19,7 +19,7 @@ export declare abstract class DocumentAttachmentService<TState extends OvermapRo
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<DocumentAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<DocumentAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<DocumentAttachment>[];
     };
     protected getId(model: Stored<DocumentAttachment>): DocumentAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<DocumentAttachment>;

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

@@ -19,7 +19,7 @@ export declare abstract class DocumentService<TState extends OvermapRootState, T
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Document> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<Document>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Document>[];
     };
     add(payload: Payload<Document>): OptimisticModelResult<Document>;
     update(payload: UUID<Partial<Payload<Document>>>): OptimisticModelResult<Document>;

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

@@ -19,7 +19,7 @@ export declare abstract class FormIdentifierService<TState extends OvermapRootSt
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<FormIdentifier> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<FormIdentifier>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormIdentifier>[];
     };
     add(payload: Payload<FormIdentifier>): OptimisticModelResult<FormIdentifier>;
     update(payload: UUID<Partial<Payload<FormIdentifier>>>): OptimisticModelResult<FormIdentifier>;

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

@@ -19,7 +19,7 @@ export declare abstract class FormIdentifierValueService<TState extends OvermapR
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<FormIdentifierValue> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<FormIdentifierValue>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormIdentifierValue>[];
     };
     add(payload: Payload<FormIdentifierValue>): OptimisticModelResult<FormIdentifierValue>;
     update(payload: UUID<Partial<Payload<FormIdentifierValue>>>): OptimisticModelResult<FormIdentifierValue>;

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

@@ -18,8 +18,8 @@ export declare abstract class FormRevisionAttachmentService<TState extends Overm
         initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormRevisionAttachment>[], "formRevisionAttachments/initializeFormRevisionAttachments">;
     };
     selectors: {
-        selectById: (args: string) => (state: OvermapRootState) => import('../..').Stored<FormRevisionAttachment> | undefined;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<FormRevisionAttachment>[];
+        selectById: (uuid: string) => (state: any) => import('../..').Stored<FormRevisionAttachment> | undefined;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormRevisionAttachment>[];
     };
     bulkAdd(payloads: {
         revisionUuid: FormRevision["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class FormRevisionService<TState extends OvermapRootStat
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<FormRevision> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<FormRevision>[];
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormRevision>[];
     };
     add(payload: FormRevisionPayload): OptimisticModelResult<FormRevision>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<FormRevision[]>;

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

@@ -18,7 +18,7 @@ export declare abstract class FormService<TState extends OvermapRootState, TSDK
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Form> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<Form>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Form>[];
     };
     add(payload: Payload<Form>, initialRevision: Pick<FormRevision, "title" | "description" | "fields">): [Stored<Form>, Stored<FormRevision>, Promise<Created<FormRevision>>];
     delete(uuid: Form["uuid"]): Promise<undefined>;

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

@@ -18,8 +18,8 @@ export declare abstract class FormSubmissionAttachmentService<TState extends Ove
         initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<FormSubmissionAttachment>[], "formSubmissionAttachments/initializeFormSubmissionAttachments">;
     };
     selectors: {
-        selectById: (args: string) => (state: OvermapRootState) => import('../..').Stored<FormSubmissionAttachment> | undefined;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<FormSubmissionAttachment>[];
+        selectById: (uuid: string) => (state: any) => import('../..').Stored<FormSubmissionAttachment> | undefined;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<FormSubmissionAttachment>[];
     };
     bulkAdd(payloads: {
         submissionUuid: FormSubmission["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class FormSubmissionService<TState extends OvermapRootSt
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<FormSubmission> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<FormSubmission>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<FormSubmission>[];
     };
     add(payload: Payload<FormSubmission>): OptimisticModelResult<FormSubmission>;
     update(payload: UUID<Partial<Payload<FormSubmission>>>): OptimisticModelResult<FormSubmission>;

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

@@ -19,11 +19,11 @@ export declare abstract class GeoImageService<TState extends OvermapRootState, T
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<GeoImage> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<GeoImage>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<GeoImage>[];
     };
     add(payload: GeoImagePayload): Promise<OptimisticModelResult<GeoImage>>;
     bulkAdd(payloads: BulkGeoImagePayload[], projectUuid: Project["uuid"]): Promise<OptimisticMultipleModelResult<GeoImage>>;
     update(payload: UUID<Partial<Pick<GeoImagePayload, "title" | "description">>>): OptimisticModelResult<GeoImage>;
     delete(uuid: GeoImage["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<GeoImage[][]>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<GeoImage[]>;
 }

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

@@ -19,7 +19,7 @@ export declare abstract class IssueAssociationService<TState extends OvermapRoot
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAssociation> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueAssociation>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueAssociation>[];
     };
     add(payload: Payload<IssueAssociation>): OptimisticModelResult<IssueAssociation>;
     delete(uuid: IssueAssociation["uuid"]): Promise<void>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueAttachmentService<TState extends OvermapRootS
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueAttachment>[];
     };
     protected getId(model: Stored<IssueAttachment>): IssueAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<IssueAttachment>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueCommentAttachmentService<TState extends Overm
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueCommentAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueCommentAttachment>[];
     };
     protected getId(model: Stored<IssueCommentAttachment>): IssueCommentAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<IssueCommentAttachment>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueCommentService<TState extends OvermapRootStat
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueComment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueComment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueComment>[];
     };
     add(payload: Omit<Payload<IssueComment>, "author">): OptimisticModelResult<IssueComment>;
     update(payload: UUID<Partial<Payload<IssueComment>>>): OptimisticModelResult<IssueComment>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueService<TState extends OvermapRootState, TSDK
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Issue> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<Issue>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Issue>[];
     };
     add(payload: Payload<Issue>): OptimisticModelResult<Issue>;
     update(payload: UUID<Partial<Payload<Issue>>>): OptimisticModelResult<Issue>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeAttachmentService<TState extends OvermapR
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeAttachment>[];
     };
     protected getId(model: Stored<IssueTypeAttachment>): IssueTypeAttachment["uuid"];
     protected buildModel(data: BuildModelData): Submitted<IssueTypeAttachment>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeFieldValuesAttachmentService<TState exten
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<IssueTypeFieldValuesAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<IssueTypeFieldValuesAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<IssueTypeFieldValuesAttachment>[];
     };
     bulkAdd(payloads: {
         fieldValuesUuid: IssueTypeFieldValues["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeFieldValuesService<TState extends Overmap
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeFieldValues>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldValues>[];
     };
     add(payload: Payload<IssueTypeFieldValues>): OptimisticModelResult<IssueTypeFieldValues>;
     update(payload: UUID<Partial<Payload<IssueTypeFieldValues>>>): OptimisticModelResult<IssueTypeFieldValues>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeFieldsAttachmentService<TState extends Ov
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<IssueTypeFieldsAttachment> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<IssueTypeFieldsAttachment>[];
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<IssueTypeFieldsAttachment>[];
     };
     bulkAdd(payloads: {
         fieldsRevisionUuid: IssueTypeFields["uuid"];

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeFieldsService<TState extends OvermapRootS
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeFields>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFields>[];
     };
     add(payload: Payload<IssueTypeFields>): OptimisticModelResult<IssueTypeFields>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeFields[]>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeIdentifierService<TState extends OvermapR
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeIdentifier> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeIdentifier>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeIdentifier>[];
     };
     add(payload: Payload<IssueTypeIdentifier>): OptimisticModelResult<IssueTypeIdentifier>;
     update(payload: UUID<Partial<Payload<IssueTypeIdentifier>>>): OptimisticModelResult<IssueTypeIdentifier>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeIdentifierValueService<TState extends Ove
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeIdentifierValue> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeIdentifierValue>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeIdentifierValue>[];
     };
     add(payload: Payload<IssueTypeIdentifierValue>): OptimisticModelResult<IssueTypeIdentifierValue>;
     update(payload: UUID<Partial<Payload<IssueTypeIdentifierValue>>>): OptimisticModelResult<IssueTypeIdentifierValue>;

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

@@ -19,7 +19,7 @@ export declare abstract class IssueTypeService<TState extends OvermapRootState,
     };
     selectors: {
         selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueType> | undefined>;
-        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<IssueType>[];
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueType>[];
     };
     add(payload: Payload<IssueType>): OptimisticModelResult<IssueType>;
     update(payload: UUID<Partial<Payload<IssueType>>>): OptimisticModelResult<IssueType>;