@overmap-ai/core 1.0.78-issue-bulk-delete.0 → 1.0.78-issue-update-typing-fix.1

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/ProjectAttachmentService.d.ts

@@ -1,9 +1,8 @@
-import { FilePayload, Organization, Project, ProjectAttachment, Stored, Submitted } from '../../typings';
+import { Organization, Payload, ProjectAttachment, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, ProjectAttachment["uuid"], ProjectAttachment> {
+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;
     actions: {
@@ -22,18 +21,10 @@ export declare abstract class ProjectAttachmentService<TState extends OvermapRoo
         selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectAttachment>[];
     };
     protected getId(model: Stored<ProjectAttachment>): ProjectAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<ProjectAttachment>;
-    protected buildPayload(model: Submitted<ProjectAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        project: string;
-    };
-    bulkAdd(payloads: {
-        projectUuid: Project["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
+    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,28 +1,32 @@
-import { Project, ProjectFile } from '../../typings';
+import { Payload, Project, ProjectFile, Stored, Submitted, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticGenericResult } from '../typings';
+import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
-export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProjectFile["uuid"], ProjectFile, TState, TSDK> {
+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<import('../..').Stored<ProjectFile>, "projectFiles/addProjectFile">;
-        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/addProjectFiles">;
-        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/setProjectFile">;
-        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/setProjectFiles">;
-        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/updateProjectFile">;
-        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/updateProjectFiles">;
+        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<import('../..').Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProjectFile> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProjectFile>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectFile> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectFile>[];
     };
-    saveExisting(file: ProjectFile): Promise<ProjectFile>;
-    saveActive(): OptimisticGenericResult<ProjectFile>;
-    delete(uuid: ProjectFile["uuid"]): Promise<undefined>;
+    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[]>;
 }

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

@@ -1,20 +1,7 @@
 export * from './AgentService';
 export * from './AssetAttachmentService';
-export * from './AssetProcedureTypeAttachmentService';
-export * from './AssetProcedureTypeFieldsAttachmentService';
-export * from './AssetProcedureTypeFieldsService';
-export * from './AssetProcedureTypeFieldValuesAttachmentService';
-export * from './AssetProcedureTypeFieldValuesService';
-export * from './AssetProcedureService';
-export * from './AssetProcedureTypeService';
-export * from './AssetProcedureStepFieldsAttachmentService';
-export * from './AssetProcedureStepFieldsService';
-export * from './AssetProcedureStepFieldValuesAttachmentService';
-export * from './AssetProcedureStepFieldValuesService';
-export * from './AssetProcedureStepService';
+export * from './AssetCommentService';
 export * from './AssetService';
-export * from './AssetStageCompletionService';
-export * from './AssetStageService';
 export * from './AssetTypeAttachmentService';
 export * from './AssetTypeFieldsAttachmentService';
 export * from './AssetTypeFieldsService';
@@ -60,9 +47,29 @@ export * from './ProjectAccessService';
 export * from './ProjectAttachmentService';
 export * from './ProjectFileService';
 export * from './ProjectService';
+export * from './ProcedureService';
+export * from './ProcedureStepAssigneeService';
+export * from './ProcedureStepCommentService';
+export * from './ProcedureStepDefaultAssigneeService';
+export * from './ProcedureStepDefaultReviewerService';
+export * from './ProcedureStepEventService';
+export * from './ProcedureStepFieldsAttachmentService';
+export * from './ProcedureStepFieldsService';
+export * from './ProcedureStepFieldValuesAttachmentService';
+export * from './ProcedureStepFieldValuesReviewService';
+export * from './ProcedureStepFieldValuesService';
+export * from './ProcedureStepReviewerService';
+export * from './ProcdureInitiativeService';
+export * from './ProcedureStepService';
+export * from './ProcedureTypeAttachmentService';
+export * from './ProcedureTypeFieldsAttachmentService';
+export * from './ProcedureTypeFieldsService';
+export * from './ProcedureFieldValuesAttachmentService';
+export * from './ProcedureFieldValuesService';
+export * from './ProcedureTypeService';
 export * from './TeamMembershipService';
 export * from './TeamService';
 export * from './UserService';
 export * from './BaseModelApiService';
 export * from './BaseOfflineModelApiService';
-export * from './BaseOfflineAttachmentModelService';
+export * from './BaseOfflineFileModelApiService';

package/dist/sdk/typings.d.ts

@@ -1,10 +1,9 @@
 import { Store } from '@reduxjs/toolkit';
 import { BaseState } from '../store';
-import { Created, Model, Stored, Submitted } from '../typings';
+import { Created, GetS3UrlResponse, Model, RequiredFileModel, Stored } from '../typings';
 import { HttpMethod } from '../enums';
 import { DeferredPromise } from '../utils';
 import { BaseSDK } from './base';
-import { GetS3UrlResponse, GetS3UrlSuccessResponse } from './services';
 export type OvermapSDKConstructor<TState extends BaseState, TSDK extends BaseSDK<TState>> = new (store: Store<TState>) => TSDK;
 export interface TokenPair {
     accessToken: string;
@@ -65,7 +64,17 @@ export type OptimisticModelResult<TModel extends Model> = [Stored<TModel>, Promi
 /**
  * Analogous to `OptimisticModelResult<TModel>`, but for multiple model instances.
  */
-export type OptimisticMultipleModelResult<TModel extends Model> = [Submitted<TModel>[], Promise<Created<TModel>[]>];
+export type OptimisticMultipleModelResult<TModel extends Model> = [Stored<TModel>[], Promise<Created<TModel>[]>];
+export type OptimisticFileModelResult<TModel extends RequiredFileModel> = [
+    Stored<TModel>,
+    Promise<Created<TModel>>,
+    Promise<string>
+];
+export type OptimisticMultipleFileModelResult<TModel extends RequiredFileModel> = [
+    Stored<TModel>[],
+    Promise<Created<TModel>[]>,
+    Promise<string[]>
+];
 /**
  * Used in situations such as deleting a model, where nothing is expected in return.
  * @deprecated Use `Promise<undefined>` directly instead.
@@ -80,4 +89,3 @@ export type PaginatedResult<T> = {
     previous: string | null;
     results: T;
 };
-export type PresignedUrlsResponse = Record<string, GetS3UrlSuccessResponse>;

package/dist/store/adapters/selectionAdapter.d.ts

@@ -1,13 +1,12 @@
 import { PayloadAction } from '@reduxjs/toolkit';
 import { SelectionState } from './typings';
-export interface SelectionAdapter<TSelection> {
-    selectOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
-    selectMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    unselectOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
-    unselectMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    toggleOne: (state: SelectionState<TSelection>, action: PayloadAction<TSelection>) => void;
-    toggleMany: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    initializeSelection: (state: SelectionState<TSelection>, action: PayloadAction<TSelection[]>) => void;
-    getInitialState: <TState extends object>(state: TState) => TState & SelectionState<TSelection>;
+export interface SelectionAdapter<TKey extends PropertyKey, TSelection> {
+    selectOne: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection>) => void;
+    selectMany: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
+    unselectOne: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection>) => void;
+    unselectMany: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
+    toggleOne: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection>) => void;
+    toggleMany: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
+    initializeSelection: (state: SelectionState<TKey, TSelection>, action: PayloadAction<TSelection[]>) => void;
 }
-export declare function createSelectionAdapter<TSelection>(): SelectionAdapter<TSelection>;
+export declare function createSelectionAdapter<TKey extends PropertyKey, TSelection>(key: TKey): SelectionAdapter<TKey, TSelection>;

package/dist/store/adapters/typings.d.ts

@@ -2,9 +2,7 @@ import { PayloadAction, ActionCreatorWithPayload } from '@reduxjs/toolkit';
 export interface ModelState<TId extends number | string | symbol, TModel> {
     instances: Record<TId, TModel>;
 }
-export interface SelectionState<TSelection> {
-    selection: TSelection[];
-}
+export type SelectionState<TKey extends PropertyKey, TSelection> = Record<TKey, TSelection[]>;
 export type InitializePayloadAction<TModel> = PayloadAction<TModel[]>;
 export type AddOnePayloadAction<TModel> = PayloadAction<TModel>;
 export type AddManyPayloadAction<TModel> = PayloadAction<TModel[]>;