@overmap-ai/core 1.0.81-project-captures.2 → 1.1.0-gcs.0

package/dist/sdk/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const DEFAULT_PAGE_SIZE = 10000;
+export declare const FILE_MODEL_DEFAULT_PAGE_SIZE = 200;
 export declare const DISCARD_HTTP_STATUSES: number[];
 export declare const MAX_SERVICE_BATCH_SIZE = 10000;

package/dist/sdk/errors.d.ts

@@ -3,6 +3,12 @@ export interface APIErrorOptions {
     response?: request.Response;
     innerError?: unknown;
     message?: string;
+    /**
+     * Whether to drop the request rather than retry it. Three valued on purpose:
+     * `true` discards, `false` insists on a retry even when the status code says otherwise, and leaving it unset lets
+     * `discard()` in `store.ts` decide from the status code. D onot default it as collapsing `undefined` into `false`
+     * is what makes "the auth service says retry this" indistinguishable from "nobody expressed an opinion".j
+     */
     discard?: boolean;
 }
 export declare const UNKNOWN_ERROR_MESSAGE = "An unknown error occurred";

package/dist/sdk/services/{ProjectCommentService.d.ts → AssetProcedureService.d.ts}

@@ -1,28 +1,28 @@
-import { Payload, Project, ProjectComment, Stored, UUID } from '../../typings';
+import { AssetProcedure, Payload, 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 ProjectCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProjectComment["uuid"], ProjectComment, TState, TSDK> {
+export declare abstract class AssetProcedureService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedure["uuid"], AssetProcedure, 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">;
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/addAssetProcedure">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/addAssetProcedures">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/setAssetProcedure">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/setAssetProcedures">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>, "assetProcedures/updateAssetProcedure">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/updateAssetProcedures">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedures/deleteAssetProcedure">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedures/deleteAssetProcedures">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedure>[], "assetProcedures/initializeAssetProcedures">;
     };
     selectors: {
-        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectComment> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => Stored<ProjectComment>[];
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedure> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedure>[];
     };
-    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[]>;
+    add(payload: Payload<AssetProcedure>): OptimisticModelResult<AssetProcedure>;
+    update(payload: UUID<Partial<Payload<AssetProcedure>>>): OptimisticModelResult<AssetProcedure>;
+    delete(uuid: AssetProcedure["uuid"]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedure[]>;
 }

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

@@ -0,0 +1,31 @@
+import { AssetProcedureStepFieldValuesAttachment, Payload, Project, Stored, Submitted, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureStepFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureStepFieldValuesAttachment["uuid"], AssetProcedureStepFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>, "assetProcedureStepFieldValuesAttachments/addAssetProcedureStepFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/addAssetProcedureStepFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>, "assetProcedureStepFieldValuesAttachments/setAssetProcedureStepFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/setAssetProcedureStepFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>, "assetProcedureStepFieldValuesAttachments/updateAssetProcedureStepFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/updateAssetProcedureStepFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldValuesAttachments/deleteAssetProcedureStepFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldValuesAttachments/deleteAssetProcedureStepFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValuesAttachment>[], "assetProcedureStepFieldValuesAttachments/initializeAssetProcedureStepFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureStepFieldValuesAttachment>): string;
+    protected getBlockers(payload: UUID<Omit<Payload<AssetProcedureStepFieldValuesAttachment>, "file_type" | "file_url">>): string[];
+    protected getBlocks(model: Stored<AssetProcedureStepFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureStepFieldValuesAttachment>): Submitted<AssetProcedureStepFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureStepFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureStepFieldValuesAttachment>): object;
+    bulkDelete(uuids: AssetProcedureStepFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldValuesAttachment[]>;
+}

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

@@ -0,0 +1,33 @@
+import { SerializedFieldValues } from '@overmap-ai/forms';
+import { AssetProcedureStepFieldValues, Created, Payload, 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 AssetProcedureStepFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFieldValues["uuid"], AssetProcedureStepFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>, "assetProcedureStepFieldValues/addAssetProcedureStepFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/addAssetProcedureStepFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>, "assetProcedureStepFieldValues/setAssetProcedureStepFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/setAssetProcedureStepFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>, "assetProcedureStepFieldValues/updateAssetProcedureStepFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/updateAssetProcedureStepFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldValues/deleteAssetProcedureStepFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldValues/deleteAssetProcedureStepFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldValues>[], "assetProcedureStepFieldValues/initializeAssetProcedureStepFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldValues> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldValues>[];
+    };
+    add(payload: Payload<AssetProcedureStepFieldValues>): OptimisticModelResult<AssetProcedureStepFieldValues>;
+    bulkAdd(payload: {
+        values: SerializedFieldValues;
+        payloads: Payload<AssetProcedureStepFieldValues>[];
+    }, batchSize?: number): [Stored<AssetProcedureStepFieldValues>[], Promise<Created<AssetProcedureStepFieldValues>[]>[]];
+    update(payload: UUID<Partial<Payload<AssetProcedureStepFieldValues>>>): OptimisticModelResult<AssetProcedureStepFieldValues>;
+    delete(uuid: AssetProcedureStepFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldValues[]>;
+}

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

@@ -0,0 +1,30 @@
+import { AssetProcedureStepFieldsAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureStepFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureStepFieldsAttachment["uuid"], AssetProcedureStepFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/addAssetProcedureStepFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/setAssetProcedureStepFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>, "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/updateAssetProcedureStepFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFieldsAttachments/deleteAssetProcedureStepFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFieldsAttachments/deleteAssetProcedureStepFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFieldsAttachment>[], "assetProcedureStepFieldsAttachments/initializeAssetProcedureStepFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFieldsAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureStepFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureStepFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureStepFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureStepFieldsAttachment>): Submitted<AssetProcedureStepFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureStepFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureStepFieldsAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFieldsAttachment[]>;
+}

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

@@ -0,0 +1,28 @@
+import { AssetProcedureStepFields, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStepFields["uuid"], AssetProcedureStepFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>, "assetProcedureStepFields/addAssetProcedureStepFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/addAssetProcedureStepFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>, "assetProcedureStepFields/setAssetProcedureStepFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/setAssetProcedureStepFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>, "assetProcedureStepFields/updateAssetProcedureStepFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/updateAssetProcedureStepFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureStepFields/deleteAssetProcedureStepFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureStepFields/deleteAssetProcedureStepFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStepFields>[], "assetProcedureStepFields/initializeAssetProcedureStepFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStepFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStepFields>[];
+    };
+    add(payload: Payload<AssetProcedureStepFields>): OptimisticModelResult<AssetProcedureStepFields>;
+    update(payload: UUID<Partial<Payload<AssetProcedureStepFields>>>): OptimisticModelResult<AssetProcedureStepFields>;
+    delete(uuid: AssetProcedureStepFields["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStepFields[]>;
+}

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

@@ -0,0 +1,28 @@
+import { AssetProcedureStep, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureStepService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureStep["uuid"], AssetProcedureStep, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>, "assetProcedureSteps/addAssetProcedureStep">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/addAssetProcedureSteps">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>, "assetProcedureSteps/setAssetProcedureStep">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/setAssetProcedureSteps">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>, "assetProcedureSteps/updateAssetProcedureStep">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/updateAssetProcedureSteps">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureSteps/deleteAssetProcedureStep">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureSteps/deleteAssetProcedureSteps">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureStep>[], "assetProcedureSteps/initializeAssetProcedureSteps">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureStep> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureStep>[];
+    };
+    add(payload: Payload<AssetProcedureStep>): OptimisticModelResult<AssetProcedureStep>;
+    update(payload: UUID<Partial<Payload<AssetProcedureStep>>>): OptimisticModelResult<AssetProcedureStep>;
+    delete(uuid: AssetProcedureStep["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureStep[]>;
+}

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

@@ -0,0 +1,30 @@
+import { AssetProcedureTypeAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeAttachment["uuid"], AssetProcedureTypeAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/addAssetProcedureTypeAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/addAssetProcedureTypeAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/setAssetProcedureTypeAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/setAssetProcedureTypeAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>, "assetProcedureTypeAttachments/updateAssetProcedureTypeAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/updateAssetProcedureTypeAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeAttachments/deleteAssetProcedureTypeAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeAttachments/deleteAssetProcedureTypeAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeAttachment>[], "assetProcedureTypeAttachments/initializeAssetProcedureTypeAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureTypeAttachment>): AssetProcedureTypeAttachment["uuid"];
+    protected getBlockers(model: Stored<AssetProcedureTypeAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeAttachment>): Submitted<AssetProcedureTypeAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeAttachment[]>;
+}

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

@@ -0,0 +1,31 @@
+import { AssetProcedureTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeFieldValuesAttachment["uuid"], AssetProcedureTypeFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>, "assetProcedureTypeFieldValuesAttachments/addAssetProcedureTypeFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/addAssetProcedureTypeFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>, "assetProcedureTypeFieldValuesAttachments/setAssetProcedureTypeFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/setAssetProcedureTypeFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>, "assetProcedureTypeFieldValuesAttachments/updateAssetProcedureTypeFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/updateAssetProcedureTypeFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldValuesAttachments/deleteAssetProcedureTypeFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldValuesAttachments/deleteAssetProcedureTypeFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValuesAttachment>[], "assetProcedureTypeFieldValuesAttachments/initializeAssetProcedureTypeFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeFieldValuesAttachment>): Submitted<AssetProcedureTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeFieldValuesAttachment>): object;
+    bulkDelete(uuids: AssetProcedureTypeFieldValuesAttachment["uuid"][]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldValuesAttachment[]>;
+}

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

@@ -0,0 +1,33 @@
+import { SerializedFieldValues } from '@overmap-ai/forms';
+import { AssetProcedureTypeFieldValues, Created, Payload, 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 AssetProcedureTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFieldValues["uuid"], AssetProcedureTypeFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>, "assetProcedureTypeFieldValues/addAssetProcedureTypeFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/addAssetProcedureTypeFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>, "assetProcedureTypeFieldValues/setAssetProcedureTypeFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/setAssetProcedureTypeFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>, "assetProcedureTypeFieldValues/updateAssetProcedureTypeFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/updateAssetProcedureTypeFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldValues/deleteAssetProcedureTypeFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldValues/deleteAssetProcedureTypeFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldValues>[], "assetProcedureTypeFieldValues/initializeAssetProcedureTypeFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldValues> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldValues>[];
+    };
+    add(payload: Payload<AssetProcedureTypeFieldValues>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
+    bulkAdd(payload: {
+        values: SerializedFieldValues;
+        payloads: Payload<AssetProcedureTypeFieldValues>[];
+    }, batchSize?: number): [Stored<AssetProcedureTypeFieldValues>[], Promise<Created<AssetProcedureTypeFieldValues>[]>[]];
+    update(payload: UUID<Partial<Payload<AssetProcedureTypeFieldValues>>>): OptimisticModelResult<AssetProcedureTypeFieldValues>;
+    delete(uuid: AssetProcedureTypeFieldValues["uuid"]): Promise<void>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldValues[]>;
+}

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

@@ -0,0 +1,30 @@
+import { AssetProcedureTypeFieldsAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
+import { BaseSDK } from '../base';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class AssetProcedureTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<AssetProcedureTypeFieldsAttachment["uuid"], AssetProcedureTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/addAssetProcedureTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/setAssetProcedureTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>, "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/updateAssetProcedureTypeFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFieldsAttachments/deleteAssetProcedureTypeFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFieldsAttachments/deleteAssetProcedureTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFieldsAttachment>[], "assetProcedureTypeFieldsAttachments/initializeAssetProcedureTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFieldsAttachment>[];
+    };
+    protected getId(model: Stored<AssetProcedureTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<AssetProcedureTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<AssetProcedureTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<AssetProcedureTypeFieldsAttachment>): Submitted<AssetProcedureTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<AssetProcedureTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<AssetProcedureTypeFieldsAttachment>): object;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFieldsAttachment[]>;
+}

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

@@ -0,0 +1,26 @@
+import { AssetProcedureTypeFields, Organization, Payload, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureTypeFields["uuid"], AssetProcedureTypeFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>, "assetProcedureTypeFields/addAssetProcedureTypeFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/addAssetProcedureTypeFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>, "assetProcedureTypeFields/setAssetProcedureTypeFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/setAssetProcedureTypeFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>, "assetProcedureTypeFields/updateAssetProcedureTypeFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/updateAssetProcedureTypeFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypeFields/deleteAssetProcedureTypeFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypeFields/deleteAssetProcedureTypeFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureTypeFields>[], "assetProcedureTypeFields/initializeAssetProcedureTypeFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureTypeFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureTypeFields>[];
+    };
+    add(payload: Payload<AssetProcedureTypeFields>): OptimisticModelResult<AssetProcedureTypeFields>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureTypeFields[]>;
+}

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

@@ -0,0 +1,28 @@
+import { AssetProcedureType, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetProcedureTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetProcedureType["uuid"], AssetProcedureType, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>, "assetProcedureTypes/addAssetProcedureType">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/addAssetProcedureTypes">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>, "assetProcedureTypes/setAssetProcedureType">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/setAssetProcedureTypes">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>, "assetProcedureTypes/updateAssetProcedureType">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/updateAssetProcedureTypes">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetProcedureTypes/deleteAssetProcedureType">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetProcedureTypes/deleteAssetProcedureTypes">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetProcedureType>[], "assetProcedureTypes/initializeAssetProcedureTypes">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetProcedureType> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedureType>[];
+    };
+    add(payload: Payload<AssetProcedureType>): OptimisticModelResult<AssetProcedureType>;
+    update(payload: UUID<Partial<Payload<AssetProcedureType>>>): OptimisticModelResult<AssetProcedureType>;
+    delete(uuid: AssetProcedureType["uuid"]): Promise<undefined>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetProcedureType[]>;
+}

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

@@ -0,0 +1,29 @@
+import { AssetStageCompletion, Payload, Project, Stored } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult, OptimisticMultipleModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetStageCompletionService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetStageCompletion["uuid"], AssetStageCompletion, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/addAssetStageCompletion">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/addAssetStageCompletions">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/setAssetStageCompletion">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/setAssetStageCompletions">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>, "assetStageCompletions/updateAssetStageCompletion">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/updateAssetStageCompletions">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStageCompletions/deleteAssetStageCompletion">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStageCompletions/deleteAssetStageCompletions">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStageCompletion>[], "assetStageCompletions/initializeAssetStageCompletions">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetStageCompletion> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetStageCompletion>[];
+    };
+    add(payload: Payload<AssetStageCompletion>): OptimisticModelResult<AssetStageCompletion>;
+    delete(uuid: AssetStageCompletion["uuid"]): Promise<undefined>;
+    bulkAdd(payloads: Payload<AssetStageCompletion>[]): OptimisticMultipleModelResult<AssetStageCompletion>;
+    bulkDelete(uuids: AssetStageCompletion["uuid"][]): Promise<undefined>;
+    refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<AssetStageCompletion[]>;
+}

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

@@ -0,0 +1,28 @@
+import { AssetStage, Organization, Payload, Stored, UUID } from '../../typings';
+import { BaseSDK } from '../base';
+import { OptimisticModelResult } from '../typings';
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class AssetStageService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<AssetStage["uuid"], AssetStage, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/addAssetStage">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/addAssetStages">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/setAssetStage">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/setAssetStages">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>, "assetStages/updateAssetStage">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/updateAssetStages">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "assetStages/deleteAssetStage">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "assetStages/deleteAssetStages">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<AssetStage>[], "assetStages/initializeAssetStages">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<AssetStage> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetStage>[];
+    };
+    add(payload: Payload<AssetStage>): OptimisticModelResult<AssetStage>;
+    update(payload: UUID<Partial<Payload<AssetStage>>>): OptimisticModelResult<AssetStage>;
+    delete(uuid: AssetStage["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<AssetStage[]>;
+}

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

@@ -9,4 +9,29 @@ export declare abstract class BaseAuthService<TStore extends BaseState, TSDK ext
     abstract prepareAuth(): Promise<void>;
     abstract getAuthHeader(): string;
     abstract handleUnauthorized(request: SuperAgentRequest, response: Response): Promise<void>;
+    /**
+     * Attaches this service's credentials to an outgoing request, and is the only place `performRequest` authenticates.
+     *
+     * A bearer token is a header and nothing else, so the default implementation just sets `Authorization` from
+     * `getAuthHeader()`. A cookie-based schema has no header to return: it needs `withCredentials()` on the request
+     * itself, which a `getAuthHeader()` return value cannot express. Overriding this is how such a service reaches the
+     * request at all.
+     *
+     * NOTE: The empty-header guard is not just tidiness. Sending `Authorization:` with an empty value still counts as a
+     *  non-simple header, so the browser would preflight every request to carry nothing.
+     * @param request
+     * @returns The request, with credentials attached.
+     */
+    applyAuth(request: SuperAgentRequest): SuperAgentRequest;
+    /**
+     * Returns a boolean value indicating whether `response` means "you are not authenticated",
+     * as oopposed to any other failure.
+     *
+     * Only responses for which this method returns true are routed to `handleUnauthorized()`. A bearer token can only
+     * fail with a 401, but a session-based service also has to recognize the 403 that Django's CSRF check produces,
+     * which is otherwise indistinguishable from a genuine permission denial.
+     * @param response The failing response.
+     * @returns A boolean indicating whether the request failed because it was not authenticated.
+     */
+    isAuthFailure(response: Response): boolean;
 }

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

@@ -1,16 +1,16 @@
 import { OvermapRootState } from '../../store';
-import { Payload, RequiredFileModel, Stored, Submitted } from '../../typings';
+import { FileAnnotated, Payload, RequiredFileModel, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { FileAnnotated, OptimisticFileModelResult, OptimisticMultipleFileModelResult } from '../typings';
+import { OptimisticFileModelResult, OptimisticMultipleFileModelResult } from '../typings';
 import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
 export declare abstract class BaseOfflineFileModelApiService<TModelId extends string, TModel extends RequiredFileModel, TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<TModelId, TModel, TState, TSDK> {
+    protected pageSize: number;
     protected abstract getId(model: Stored<TModel>): TModelId;
     protected abstract getBlockers(model: Stored<TModel>): string[];
     protected abstract getBlocks(model: Stored<TModel>): string[];
     protected abstract buildModel(data: Payload<TModel>): Submitted<TModel>;
     protected abstract buildPayload(model: Submitted<TModel>): object;
     protected abstract buildBulkPayload(model: Submitted<TModel>): object;
-    getPresignedUrl(uuid: TModelId, signal?: AbortSignal): Promise<string>;
     add(payload: Payload<TModel> | FileAnnotated<Omit<Payload<TModel>, keyof RequiredFileModel>>): Promise<OptimisticFileModelResult<TModel>>;
     bulkAdd(payloads: (Payload<TModel> | FileAnnotated<Omit<Payload<TModel>, keyof RequiredFileModel>>)[], batchSize?: number): Promise<OptimisticMultipleFileModelResult<TModel>>;
     delete(uuid: TModelId): Promise<void>;

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

@@ -1,6 +1,6 @@
-import { DocumentAttachment, Organization, Payload, RequiredFileModel, Stored, Submitted } from '../../typings';
+import { DocumentAttachment, FileAnnotated, Organization, Payload, RequiredFileModel, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { FileAnnotated, OptimisticMultipleFileModelResult } from '../typings';
+import { OptimisticMultipleFileModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
 import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
 export declare abstract class DocumentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<DocumentAttachment["uuid"], DocumentAttachment, TState, TSDK> {

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

@@ -1,5 +1,5 @@
+import { FilePayload, GetS3UrlResponse, PresignedUrlsResponse } from '../../typings';
 import { BaseSDK } from '../base';
-import { FilePayload, GetS3UrlResponse, PresignedUrlsResponse } from '../typings';
 import { BaseState } from '../../store';
 import { BaseApiService } from './BaseApiService';
 export declare abstract class FileService<TState extends BaseState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
@@ -10,9 +10,9 @@ export declare abstract class FileService<TState extends BaseState, TSDK extends
      * Adds a file to the cache using the sha1 hash as the key and returns the sha1 hash.
      * @param file The file to add to the cache
      */
-    cacheFile(file: File): Promise<void>;
-    uncacheFile(sha1: string): Promise<void>;
-    getFileFromCache(sha1: string): Promise<File | undefined>;
+    addCache(file: File): Promise<void>;
+    removeCache(sha1: string): Promise<void>;
+    fetchCache(sha1: string): Promise<File | undefined>;
     /**
      * Fetches a file based on its URL and SHA1. SHA1 values should be known ahead of time because the SHA1 and URL of
      * any file is stored in a FileModelMixin (see backend). If the expected SHA1 doesn't match the actual SHA1 of the
@@ -22,13 +22,9 @@ export declare abstract class FileService<TState extends BaseState, TSDK extends
      * will be thrown.
      * @param downloadedName (Optional) The name to give the file after download. Set to the name of an attachment, for
      * example.
-     * @param signal (Optional) An abort signal to be passed down to cancel the request
      */
-    fetchFileFromUrl(url: string, expectedSha1: string, downloadedName?: string, signal?: AbortSignal): Promise<File>;
+    fetchFileFromUrl(url: string, expectedSha1: string, downloadedName?: string): Promise<File>;
     processPresignedUrl(sha1: string, presignedUrl: GetS3UrlResponse): Promise<void>;
     processPresignedUrls(presignedUrls: PresignedUrlsResponse): Record<string, Promise<void>>;
     getFilePayload(file: File): Promise<FilePayload>;
-    cachePresignedUrl(sha1: string, presignedUrl: string): Promise<void>;
-    uncachePresignedUrl(sha1: string): Promise<void>;
-    getPresignedUrlFromCache(sha1: string): Promise<string | undefined>;
 }