@overmap-ai/core 1.0.79-project-folder.1 → 1.0.79

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,31 +1,30 @@
-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 { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<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;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAttachment> | undefined>;
-    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;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/addProjectAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/setProjectAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/updateProjectAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectAttachment>[];
     };
-    bulkAdd(payloads: {
-        projectUuid: Project["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<ProjectAttachment>>;
-    delete(uuid: ProjectAttachment["uuid"]): Promise<void>;
+    protected getId(model: Stored<ProjectAttachment>): ProjectAttachment["uuid"];
+    protected getBlockers(model: Stored<ProjectAttachment>): string[];
+    protected getBlocks(model: Stored<ProjectAttachment>): string[];
+    protected buildModel(data: Payload<ProjectAttachment>): Submitted<ProjectAttachment>;
+    protected buildPayload(model: Submitted<ProjectAttachment>): object;
+    protected buildBulkPayload(model: Submitted<ProjectAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<ProjectAttachment[]>;
 }

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

@@ -0,0 +1,28 @@
+import { Payload, Project, ProjectComment, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProjectCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProjectComment["uuid"], ProjectComment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>, "projectComments/addProjectComment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>[], "projectComments/addProjectComments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>, "projectComments/setProjectComment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>[], "projectComments/setProjectComments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>, "projectComments/updateProjectComment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>[], "projectComments/updateProjectComments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectComments/deleteProjectComment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectComments/deleteProjectComments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectComment>[], "projectComments/initializeProjectComments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectComment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectComment>[];
+    };
+    add(payload: Payload<ProjectComment>): OptimisticModelResult<ProjectComment>;
+    update(payload: UUID<Partial<Payload<ProjectComment>>>): OptimisticModelResult<ProjectComment>;
+    delete(uuid: ProjectComment["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<ProjectComment[]>;
+}

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

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

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

@@ -1,10 +1,27 @@
-import { Organization, Payload, Project } from '../../typings';
+import { Organization, Payload, Project, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class ProjectService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseModelApiService } from './BaseModelApiService';
+export declare abstract class ProjectService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseModelApiService<Project["uuid"], Project, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/addProject">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/addProjects">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/setProject">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/setProjects">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project, "projects/updateProject">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/updateProjects">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projects/deleteProject">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projects/deleteProjects">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Project[], "projects/initializeProjects">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Project | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Project[];
+    };
     add(payload: Payload<Project>): Promise<Project>;
-    update(project: Project): Promise<Project>;
+    update(payload: UUID<Partial<Project>>): Promise<Project>;
     delete(uuid: Project["uuid"]): Promise<void>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<Project[]>;
 }

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

@@ -2,8 +2,25 @@ import { Organization, Payload, Submitted, TeamMembership } from '../../typings'
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class TeamMembershipService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class TeamMembershipService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<TeamMembership["uuid"], TeamMembership, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>, "teamMemberships/addTeamMembership">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>[], "teamMemberships/addTeamMemberships">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>, "teamMemberships/setTeamMembership">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>[], "teamMemberships/setTeamMemberships">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>, "teamMemberships/updateTeamMembership">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>[], "teamMemberships/updateTeamMemberships">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "teamMemberships/deleteTeamMembership">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "teamMemberships/deleteTeamMemberships">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<TeamMembership>[], "teamMemberships/initializeTeamMemberships">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<TeamMembership> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => import('../..').Stored<TeamMembership>[];
+    };
     add(payload: Payload<TeamMembership>): OptimisticModelResult<TeamMembership>;
     bulkAdd(payloads: Payload<TeamMembership>[]): (Submitted<TeamMembership>[] | Promise<TeamMembership[]>)[];
     delete(uuid: TeamMembership["uuid"]): Promise<undefined>;

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

@@ -1,9 +1,26 @@
-import { Organization, Payload, Team, UUID } from '../../typings';
+import { Organization, Payload, Stored, Team, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class TeamService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class TeamService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Team["uuid"], Team, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>, "teams/addTeam">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>[], "teams/addTeams">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>, "teams/setTeam">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>[], "teams/setTeams">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>, "teams/updateTeam">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>[], "teams/updateTeams">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "teams/deleteTeam">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "teams/deleteTeams">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Team>[], "teams/initializeTeams">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Team> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Team>[];
+    };
     add(payload: Payload<Team>): OptimisticModelResult<Team>;
     update(payload: UUID<Partial<Payload<Team>>>): OptimisticModelResult<Team>;
     delete(uuid: Team["uuid"]): Promise<undefined>;

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

@@ -1,7 +1,28 @@
 import { Organization, User } from '../../typings';
 import { BaseSDK } from '../base';
+import { ModelSDKRequest } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class UserService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseModelApiService } from './BaseModelApiService';
+export declare abstract class UserService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseModelApiService<User["id"], User, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<User, "users/addUser">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/addUsers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<User, "users/setUser">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/setUsers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<User, "users/updateUser">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/updateUsers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "users/deleteUser">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<number[], "users/deleteUsers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<User[], "users/initializeUsers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<number, User | undefined>;
+        selectByIds: (uuids: number[]) => (state: any) => User[];
+    };
+    list(requestDetails: Omit<ModelSDKRequest, "method"> & {
+        organizationUuid?: Organization["uuid"];
+    }, signal?: AbortSignal): Promise<User[]>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<User[]>;
 }