@overmap-ai/core 1.0.78-improvements.1 → 1.0.78-issue-update-typing-fix.1

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

@@ -0,0 +1,27 @@
+import { Organization, Payload, ProcedureStepDefaultAssignee } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepDefaultAssigneeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepDefaultAssignee["uuid"], ProcedureStepDefaultAssignee, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>, "procedureStepDefaultAssignees/addProcedureStepDefaultAssignee">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>[], "procedureStepDefaultAssignees/addProcedureStepDefaultAssignees">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>, "procedureStepDefaultAssignees/setProcedureStepDefaultAssignee">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>[], "procedureStepDefaultAssignees/setProcedureStepDefaultAssignees">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>, "procedureStepDefaultAssignees/updateProcedureStepDefaultAssignee">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>[], "procedureStepDefaultAssignees/updateProcedureStepDefaultAssignees">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepDefaultAssignees/deleteProcedureStepDefaultAssignee">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepDefaultAssignees/deleteProcedureStepDefaultAssignees">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultAssignee>[], "procedureStepDefaultAssignees/initializeProcedureStepDefaultAssignees">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProcedureStepDefaultAssignee> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProcedureStepDefaultAssignee>[];
+    };
+    add(payload: Payload<ProcedureStepDefaultAssignee>): OptimisticModelResult<ProcedureStepDefaultAssignee>;
+    delete(uuid: ProcedureStepDefaultAssignee["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureStepDefaultAssignee[]>;
+}

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

@@ -0,0 +1,27 @@
+import { Organization, Payload, ProcedureStepDefaultReviewer } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepDefaultReviewerService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepDefaultReviewer["uuid"], ProcedureStepDefaultReviewer, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>, "procedureStepDefaultReviewers/addProcedureStepDefaultReviewer">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>[], "procedureStepDefaultReviewers/addProcedureStepDefaultReviewers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>, "procedureStepDefaultReviewers/setProcedureStepDefaultReviewer">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>[], "procedureStepDefaultReviewers/setProcedureStepDefaultReviewers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>, "procedureStepDefaultReviewers/updateProcedureStepDefaultReviewer">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>[], "procedureStepDefaultReviewers/updateProcedureStepDefaultReviewers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepDefaultReviewers/deleteProcedureStepDefaultReviewer">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepDefaultReviewers/deleteProcedureStepDefaultReviewers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepDefaultReviewer>[], "procedureStepDefaultReviewers/initializeProcedureStepDefaultReviewers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProcedureStepDefaultReviewer> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProcedureStepDefaultReviewer>[];
+    };
+    add(payload: Payload<ProcedureStepDefaultReviewer>): OptimisticModelResult<ProcedureStepDefaultReviewer>;
+    delete(uuid: ProcedureStepDefaultReviewer["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureStepDefaultReviewer[]>;
+}

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

@@ -0,0 +1,24 @@
+import { Project, ProcedureStepEvent } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseModelApiService } from './BaseModelApiService';
+export declare abstract class ProcedureStepEventService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseModelApiService<ProcedureStepEvent["uuid"], ProcedureStepEvent, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent, "procedureStepEvents/addProcedureStepEvent">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent[], "procedureStepEvents/addProcedureStepEvents">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent, "procedureStepEvents/setProcedureStepEvent">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent[], "procedureStepEvents/setProcedureStepEvents">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent, "procedureStepEvents/updateProcedureStepEvent">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent[], "procedureStepEvents/updateProcedureStepEvents">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepEvents/deleteProcedureStepEvent">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepEvents/deleteProcedureStepEvents">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<ProcedureStepEvent[], "procedureStepEvents/initializeProcedureStepEvents">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, ProcedureStepEvent | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => ProcedureStepEvent[];
+    };
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepEvent[]>;
+}

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

@@ -0,0 +1,31 @@
+import { Payload, Project, Stored, Submitted, ProcedureStepFieldValuesAttachment } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProcedureStepFieldValuesAttachment["uuid"], ProcedureStepFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>, "procedureStepFieldValuesAttachments/addProcedureStepFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>[], "procedureStepFieldValuesAttachments/addProcedureStepFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>, "procedureStepFieldValuesAttachments/setProcedureStepFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>[], "procedureStepFieldValuesAttachments/setProcedureStepFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>, "procedureStepFieldValuesAttachments/updateProcedureStepFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>[], "procedureStepFieldValuesAttachments/updateProcedureStepFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepFieldValuesAttachments/deleteProcedureStepFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepFieldValuesAttachments/deleteProcedureStepFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesAttachment>[], "procedureStepFieldValuesAttachments/initializeProcedureStepFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureStepFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureStepFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<ProcedureStepFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<ProcedureStepFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<ProcedureStepFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<ProcedureStepFieldValuesAttachment>): Submitted<ProcedureStepFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<ProcedureStepFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProcedureStepFieldValuesAttachment>): object;
+    bulkDelete(uuids: ProcedureStepFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepFieldValuesAttachment[]>;
+}

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

@@ -0,0 +1,28 @@
+import { Payload, Project, Stored, UUID, ProcedureStepFieldValuesReview } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepFieldValuesReviewService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepFieldValuesReview["uuid"], ProcedureStepFieldValuesReview, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>, "procedureStepFieldValuesReviews/addProcedureStepFieldValuesReview">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>[], "procedureStepFieldValuesReviews/addProcedureStepFieldValuesReviews">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>, "procedureStepFieldValuesReviews/setProcedureStepFieldValuesReview">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>[], "procedureStepFieldValuesReviews/setProcedureStepFieldValuesReviews">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>, "procedureStepFieldValuesReviews/updateProcedureStepFieldValuesReview">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>[], "procedureStepFieldValuesReviews/updateProcedureStepFieldValuesReviews">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepFieldValuesReviews/deleteProcedureStepFieldValuesReview">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepFieldValuesReviews/deleteProcedureStepFieldValuesReviews">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValuesReview>[], "procedureStepFieldValuesReviews/initializeProcedureStepFieldValuesReviews">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureStepFieldValuesReview> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureStepFieldValuesReview>[];
+    };
+    add(payload: Payload<ProcedureStepFieldValuesReview>): OptimisticModelResult<ProcedureStepFieldValuesReview>;
+    update(payload: UUID<Partial<Payload<ProcedureStepFieldValuesReview>>>): OptimisticModelResult<ProcedureStepFieldValuesReview>;
+    delete(uuid: ProcedureStepFieldValuesReview["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepFieldValuesReview[]>;
+}

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

@@ -0,0 +1,29 @@
+import { Payload, ProcedureStepFieldValues, Project, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepFieldValues["uuid"], ProcedureStepFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>, "procedureStepFieldValues/addProcedureStepFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>[], "procedureStepFieldValues/addProcedureStepFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>, "procedureStepFieldValues/setProcedureStepFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>[], "procedureStepFieldValues/setProcedureStepFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>, "procedureStepFieldValues/updateProcedureStepFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>[], "procedureStepFieldValues/updateProcedureStepFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepFieldValues/deleteProcedureStepFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepFieldValues/deleteProcedureStepFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldValues>[], "procedureStepFieldValues/initializeProcedureStepFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureStepFieldValues> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureStepFieldValues>[];
+    };
+    add(payload: Payload<ProcedureStepFieldValues>): OptimisticModelResult<ProcedureStepFieldValues>;
+    bulkAdd(payloads: Payload<ProcedureStepFieldValues>[], batchSize?: number): OptimisticMultipleModelResult<ProcedureStepFieldValues>;
+    update(payload: UUID<Partial<Payload<ProcedureStepFieldValues>>>): OptimisticModelResult<ProcedureStepFieldValues>;
+    delete(uuid: ProcedureStepFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepFieldValues[]>;
+}

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

@@ -0,0 +1,30 @@
+import { Organization, Payload, Stored, Submitted, ProcedureStepFieldsAttachment } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProcedureStepFieldsAttachment["uuid"], ProcedureStepFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>, "procedureStepFieldsAttachments/addProcedureStepFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>[], "procedureStepFieldsAttachments/addProcedureStepFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>, "procedureStepFieldsAttachments/setProcedureStepFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>[], "procedureStepFieldsAttachments/setProcedureStepFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>, "procedureStepFieldsAttachments/updateProcedureStepFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>[], "procedureStepFieldsAttachments/updateProcedureStepFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepFieldsAttachments/deleteProcedureStepFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepFieldsAttachments/deleteProcedureStepFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepFieldsAttachment>[], "procedureStepFieldsAttachments/initializeProcedureStepFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureStepFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureStepFieldsAttachment>[];
+    };
+    protected getId(model: Stored<ProcedureStepFieldsAttachment>): string;
+    protected getBlockers(model: Stored<ProcedureStepFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<ProcedureStepFieldsAttachment>): string[];
+    protected buildModel(data: Payload<ProcedureStepFieldsAttachment>): Submitted<ProcedureStepFieldsAttachment>;
+    protected buildPayload(model: Submitted<ProcedureStepFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProcedureStepFieldsAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureStepFieldsAttachment[]>;
+}

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

@@ -0,0 +1,27 @@
+import { Organization, Payload, ProcedureStepFields } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepFields["uuid"], ProcedureStepFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>, "procedureStepFields/addProcedureStepFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>[], "procedureStepFields/addProcedureStepFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>, "procedureStepFields/setProcedureStepFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>[], "procedureStepFields/setProcedureStepFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>, "procedureStepFields/updateProcedureStepFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>[], "procedureStepFields/updateProcedureStepFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepFields/deleteProcedureStepFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepFields/deleteProcedureStepFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepFields>[], "procedureStepFields/initializeProcedureStepFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProcedureStepFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProcedureStepFields>[];
+    };
+    add(payload: Payload<ProcedureStepFields>): OptimisticModelResult<ProcedureStepFields>;
+    delete(uuid: ProcedureStepFields["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureStepFields[]>;
+}

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

@@ -0,0 +1,29 @@
+import { Payload, Project, ProcedureStepReviewer } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepReviewerService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepReviewer["uuid"], ProcedureStepReviewer, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>, "procedureStepReviewers/addProcedureStepReviewer">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>[], "procedureStepReviewers/addProcedureStepReviewers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>, "procedureStepReviewers/setProcedureStepReviewer">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>[], "procedureStepReviewers/setProcedureStepReviewers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>, "procedureStepReviewers/updateProcedureStepReviewer">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>[], "procedureStepReviewers/updateProcedureStepReviewers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepReviewers/deleteProcedureStepReviewer">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepReviewers/deleteProcedureStepReviewers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepReviewer>[], "procedureStepReviewers/initializeProcedureStepReviewers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProcedureStepReviewer> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProcedureStepReviewer>[];
+    };
+    add(payload: Payload<ProcedureStepReviewer>): OptimisticModelResult<ProcedureStepReviewer>;
+    bulkAdd(payloads: Payload<ProcedureStepReviewer>[]): OptimisticMultipleModelResult<ProcedureStepReviewer>;
+    delete(uuid: ProcedureStepReviewer["uuid"]): Promise<void>;
+    bulkDelete(uuids: ProcedureStepReviewer["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepReviewer[]>;
+}

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

@@ -0,0 +1,28 @@
+import { Organization, Payload, ProcedureStep, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStep["uuid"], ProcedureStep, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>, "procedureSteps/addProcedureStep">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>[], "procedureSteps/addProcedureSteps">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>, "procedureSteps/setProcedureStep">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>[], "procedureSteps/setProcedureSteps">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>, "procedureSteps/updateProcedureStep">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>[], "procedureSteps/updateProcedureSteps">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureSteps/deleteProcedureStep">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureSteps/deleteProcedureSteps">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStep>[], "procedureSteps/initializeProcedureSteps">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureStep> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureStep>[];
+    };
+    add(payload: Payload<ProcedureStep>): OptimisticModelResult<ProcedureStep>;
+    update(payload: UUID<Partial<Payload<ProcedureStep>>>): OptimisticModelResult<ProcedureStep>;
+    delete(uuid: ProcedureStep["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureStep[]>;
+}

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

@@ -0,0 +1,30 @@
+import { Organization, Payload, Stored, Submitted, ProcedureTypeAttachment } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProcedureTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProcedureTypeAttachment["uuid"], ProcedureTypeAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>, "procedureTypeAttachments/addProcedureTypeAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>[], "procedureTypeAttachments/addProcedureTypeAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>, "procedureTypeAttachments/setProcedureTypeAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>[], "procedureTypeAttachments/setProcedureTypeAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>, "procedureTypeAttachments/updateProcedureTypeAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>[], "procedureTypeAttachments/updateProcedureTypeAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureTypeAttachments/deleteProcedureTypeAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureTypeAttachments/deleteProcedureTypeAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeAttachment>[], "procedureTypeAttachments/initializeProcedureTypeAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureTypeAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureTypeAttachment>[];
+    };
+    protected getId(model: Stored<ProcedureTypeAttachment>): ProcedureTypeAttachment["uuid"];
+    protected getBlockers(model: Stored<ProcedureTypeAttachment>): string[];
+    protected getBlocks(model: Stored<ProcedureTypeAttachment>): string[];
+    protected buildModel(data: Payload<ProcedureTypeAttachment>): Submitted<ProcedureTypeAttachment>;
+    protected buildPayload(model: Submitted<ProcedureTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProcedureTypeAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureTypeAttachment[]>;
+}

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

@@ -0,0 +1,30 @@
+import { Organization, Payload, Stored, Submitted, ProcedureTypeFieldsAttachment } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProcedureTypeFieldsAttachment["uuid"], ProcedureTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>, "procedureTypeFieldsAttachments/addProcedureTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>[], "procedureTypeFieldsAttachments/addProcedureTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>, "procedureTypeFieldsAttachments/setProcedureTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>[], "procedureTypeFieldsAttachments/setProcedureTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>, "procedureTypeFieldsAttachments/updateProcedureTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>[], "procedureTypeFieldsAttachments/updateProcedureTypeFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureTypeFieldsAttachments/deleteProcedureTypeFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureTypeFieldsAttachments/deleteProcedureTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureTypeFieldsAttachment>[], "procedureTypeFieldsAttachments/initializeProcedureTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureTypeFieldsAttachment>[];
+    };
+    protected getId(model: Stored<ProcedureTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<ProcedureTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<ProcedureTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<ProcedureTypeFieldsAttachment>): Submitted<ProcedureTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<ProcedureTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProcedureTypeFieldsAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureTypeFieldsAttachment[]>;
+}

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

@@ -0,0 +1,26 @@
+import { Organization, Payload, ProcedureTypeFields } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureTypeFields["uuid"], ProcedureTypeFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>, "procedureTypeFields/addProcedureTypeFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>[], "procedureTypeFields/addProcedureTypeFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>, "procedureTypeFields/setProcedureTypeFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>[], "procedureTypeFields/setProcedureTypeFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>, "procedureTypeFields/updateProcedureTypeFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>[], "procedureTypeFields/updateProcedureTypeFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureTypeFields/deleteProcedureTypeFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureTypeFields/deleteProcedureTypeFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureTypeFields>[], "procedureTypeFields/initializeProcedureTypeFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProcedureTypeFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProcedureTypeFields>[];
+    };
+    add(payload: Payload<ProcedureTypeFields>): OptimisticModelResult<ProcedureTypeFields>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureTypeFields[]>;
+}

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

@@ -0,0 +1,28 @@
+import { Organization, Payload, Stored, UUID, ProcedureType } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureType["uuid"], ProcedureType, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>, "procedureTypes/addProcedureType">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>[], "procedureTypes/addProcedureTypes">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>, "procedureTypes/setProcedureType">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>[], "procedureTypes/setProcedureTypes">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>, "procedureTypes/updateProcedureType">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>[], "procedureTypes/updateProcedureTypes">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureTypes/deleteProcedureType">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureTypes/deleteProcedureTypes">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureType>[], "procedureTypes/initializeProcedureTypes">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureType> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureType>[];
+    };
+    add(payload: Payload<ProcedureType>): OptimisticModelResult<ProcedureType>;
+    update(payload: UUID<Partial<Payload<ProcedureType>>>): OptimisticModelResult<ProcedureType>;
+    delete(uuid: ProcedureType["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProcedureType[]>;
+}

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

@@ -1,9 +1,29 @@
-import { OvermapRootState } from '../../store';
-import { Project, ProjectAccess } from '../../typings';
+import { Organization, Payload, ProjectAccess, Stored, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class ProjectAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
-    update(projectAccess: ProjectAccess): Promise<ProjectAccess>;
-    remove(uuid: ProjectAccess["uuid"]): Promise<undefined>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<undefined>;
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProjectAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProjectAccess["uuid"], ProjectAccess, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>, "projectAccess/addProjectAccess">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>[], "projectAccess/addProjectAccesses">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>, "projectAccess/setProjectAccess">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>[], "projectAccess/setProjectAccesses">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>, "projectAccess/updateProjectAccess">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>[], "projectAccess/updateProjectAccesses">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAccess/deleteProjectAccess">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAccess/deleteProjectAccesses">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAccess>[], "projectAccess/initializeProjectAccesses">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAccess> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectAccess>[];
+    };
+    add(payload: Payload<ProjectAccess>): OptimisticModelResult<ProjectAccess>;
+    bulkAdd(payloads: Payload<ProjectAccess>[]): (Submitted<ProjectAccess>[] | Promise<ProjectAccess[]>)[];
+    update(payload: UUID<Partial<Payload<ProjectAccess>>>): OptimisticModelResult<ProjectAccess>;
+    delete(uuid: ProjectAccess["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProjectAccess[]>;
 }

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

@@ -1,40 +1,30 @@
-import { OvermapRootState } from '../../store';
-import { Project, ProjectAttachment, Stored } from '../../typings';
+import { Organization, Payload, ProjectAttachment, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, Stored<ProjectAttachment>> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProjectAttachment["uuid"], ProjectAttachment, TState, TSDK> {
     name: string;
     url: string;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, ProjectAttachment | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
-        file_name: string;
-        file_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        project: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        project: string;
-        modelUuid: import('../..').UUIDModel["uuid"];
-        uuid: import('../..').UUIDModel["uuid"];
-        description: import('../..').Attachment["description"];
-        file_sha1: import('../..').FileWithNameModel["file_sha1"];
-        file_name: import('../..').FileWithNameModel["file_name"];
-        file_extension: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/addProjectAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/setProjectAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/updateProjectAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectAttachment>[];
     };
-    bulkAdd(payloads: {
-        projectUuid: Project["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
-    refreshStore(projectUuid: Project["uuid"]): Promise<void>;
+    protected getId(model: Stored<ProjectAttachment>): ProjectAttachment["uuid"];
+    protected getBlockers(model: Stored<ProjectAttachment>): string[];
+    protected getBlocks(model: Stored<ProjectAttachment>): string[];
+    protected buildModel(data: Payload<ProjectAttachment>): Submitted<ProjectAttachment>;
+    protected buildPayload(model: Submitted<ProjectAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProjectAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProjectAttachment[]>;
 }

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

@@ -1,14 +1,32 @@
-import { OvermapRootState } from '../../store';
-import { Project, ProjectFile } from '../../typings';
+import { Payload, Project, ProjectFile, Stored, Submitted, UUID } 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>;
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProjectFile["uuid"], ProjectFile, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/addProjectFile">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/addProjectFiles">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/setProjectFile">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/setProjectFiles">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>, "projectFiles/updateProjectFile">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/updateProjectFiles">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectFiles/deleteProjectFile">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectFiles/deleteProjectFiles">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectFile> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectFile>[];
+    };
+    protected getId(model: Stored<ProjectFile>): ProjectFile["uuid"];
+    protected getBlockers(model: Stored<ProjectFile>): string[];
+    protected getBlocks(model: Stored<ProjectFile>): string[];
+    protected buildModel(data: Payload<ProjectFile>): Submitted<ProjectFile>;
+    protected buildPayload(model: Submitted<ProjectFile>): object;
+    protected buildBulkPayload(model: Submitted<ProjectFile>): object;
+    update(payload: UUID<Partial<Pick<ProjectFile, "bounds" | "canvas_bounds" | "z_index">>>): OptimisticModelResult<ProjectFile>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProjectFile[]>;
 }