@overmap-ai/core 1.0.78-project-polygon-field.0 → 1.0.78-project-status-and-fields.0

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

@@ -0,0 +1,29 @@
+import { Payload, ProcedureStepAssignee, Project } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepAssigneeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepAssignee["uuid"], ProcedureStepAssignee, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>, "procedureStepAssignees/addProcedureStepAssignee">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>[], "procedureStepAssignees/addProcedureStepAssignees">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>, "procedureStepAssignees/setProcedureStepAssignee">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>[], "procedureStepAssignees/setProcedureStepAssignees">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>, "procedureStepAssignees/updateProcedureStepAssignee">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>[], "procedureStepAssignees/updateProcedureStepAssignees">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepAssignees/deleteProcedureStepAssignee">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepAssignees/deleteProcedureStepAssignees">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProcedureStepAssignee>[], "procedureStepAssignees/initializeProcedureStepAssignees">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProcedureStepAssignee> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<ProcedureStepAssignee>[];
+    };
+    add(payload: Payload<ProcedureStepAssignee>): OptimisticModelResult<ProcedureStepAssignee>;
+    bulkAdd(payloads: Payload<ProcedureStepAssignee>[]): OptimisticMultipleModelResult<ProcedureStepAssignee>;
+    delete(uuid: ProcedureStepAssignee["uuid"]): Promise<void>;
+    bulkDelete(uuids: ProcedureStepAssignee["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepAssignee[]>;
+}

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

@@ -0,0 +1,28 @@
+import { Payload, Project, Stored, UUID, ProcedureStepComment } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProcedureStepCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProcedureStepComment["uuid"], ProcedureStepComment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>, "procedureStepComments/addProcedureStepComment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>[], "procedureStepComments/addProcedureStepComments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>, "procedureStepComments/setProcedureStepComment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>[], "procedureStepComments/setProcedureStepComments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>, "procedureStepComments/updateProcedureStepComment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>[], "procedureStepComments/updateProcedureStepComments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "procedureStepComments/deleteProcedureStepComment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "procedureStepComments/deleteProcedureStepComments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProcedureStepComment>[], "procedureStepComments/initializeProcedureStepComments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProcedureStepComment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProcedureStepComment>[];
+    };
+    add(payload: Payload<ProcedureStepComment>): OptimisticModelResult<ProcedureStepComment>;
+    update(payload: UUID<Partial<Payload<ProcedureStepComment>>>): OptimisticModelResult<ProcedureStepComment>;
+    delete(uuid: ProcedureStepComment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProcedureStepComment[]>;
+}

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,28 @@
+import { Payload, ProcedureStepFieldValues, Project, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } 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>;
+    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/ProjectFieldValuesAttachmentService.d.ts

@@ -0,0 +1,31 @@
+import { Payload, Project, ProjectFieldValuesAttachment, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class ProjectFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<ProjectFieldValuesAttachment["uuid"], ProjectFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>, "projectFieldValuesAttachments/addProjectFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>[], "projectFieldValuesAttachments/addProjectFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>, "projectFieldValuesAttachments/setProjectFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>[], "projectFieldValuesAttachments/setProjectFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>, "projectFieldValuesAttachments/updateProjectFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>[], "projectFieldValuesAttachments/updateProjectFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectFieldValuesAttachments/deleteProjectFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectFieldValuesAttachments/deleteProjectFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectFieldValuesAttachment>[], "projectFieldValuesAttachments/initializeProjectFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<ProjectFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<ProjectFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<ProjectFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<ProjectFieldValuesAttachment>): Submitted<ProjectFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<ProjectFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProjectFieldValuesAttachment>): object;
+    bulkDelete(uuids: ProjectFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProjectFieldValuesAttachment[]>;
+}