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

package/dist/typings/models/assets.d.ts

@@ -1,6 +1,5 @@
-import { SerializedCondition } from '@overmap-ai/forms';
 import { RequiredFileModel } from '../files';
-import { AbbreviationModel, ColorModel, CreatedByModel, GeometryModel, IconModel, IdentifierModel, IdentifierValueModel, IndexedModel, SubmittedAtModel, TimestampedModel, TreeModel, UUIDModel } from './base';
+import { AbbreviationModel, ColorModel, CreatedByModel, GeometryModel, IconModel, IdentifierModel, IdentifierValueModel, IndexedModel, SubmittedAtModel, TimestampedModel, UUIDModel } from './base';
 import { FieldsAttachmentModel, FieldsModel, FieldValuesModel } from './fields';
 import { Organization } from './organizations';
 import { Project } from './projects';
@@ -19,28 +18,6 @@ export interface AssetType extends UUIDModel, TimestampedModel, SubmittedAtModel
     order: number;
     default_status: AssetTypeStatus["uuid"] | null;
 }
-export interface AssetProcedureType extends UUIDModel, TimestampedModel, SubmittedAtModel, CreatedByModel, IconModel, ColorModel, AbbreviationModel {
-    organization: Organization["uuid"];
-    name: string;
-    description: string | null;
-}
-export interface AssetProcedure extends UUIDModel, TimestampedModel, SubmittedAtModel, CreatedByModel, IndexedModel {
-    asset_procedure_type: AssetProcedureType["uuid"];
-    asset_type: AssetType["uuid"];
-    project: Project["uuid"];
-}
-export interface AssetStage extends UUIDModel, TimestampedModel, SubmittedAtModel, CreatedByModel, ColorModel {
-    asset_procedure_type: AssetProcedureType["uuid"];
-    name: string;
-    description: string | null;
-    priority: number;
-}
-export interface AssetStageCompletion extends UUIDModel, TimestampedModel, SubmittedAtModel, CreatedByModel {
-    asset: Asset["uuid"];
-    asset_stage: AssetStage["uuid"];
-    asset_procedure: AssetProcedure["uuid"];
-}
-export type CompletedStagesMapping = Record<Asset["uuid"], Record<AssetStage["uuid"], AssetStageCompletion["submitted_at"]>>;
 export interface AssetTypeFields extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel {
     asset_type: AssetType["uuid"];
 }
@@ -54,42 +31,6 @@ export interface AssetTypeFieldValues extends UUIDModel, SubmittedAtModel, Times
 export interface AssetTypeFieldValuesAttachment extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
     field_values: AssetTypeFieldValues["uuid"];
 }
-export interface AssetProcedureTypeFields extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel {
-    asset_procedure_type: AssetProcedureType["uuid"];
-}
-export interface AssetProcedureTypeFieldsAttachment extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
-    fields_revision: AssetProcedureTypeFields["uuid"];
-}
-export interface AssetProcedureTypeFieldValues extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldValuesModel {
-    fields_revision: AssetProcedureTypeFields["uuid"];
-    asset_procedure: AssetProcedure["uuid"];
-    asset: Asset["uuid"];
-}
-export interface AssetProcedureTypeFieldValuesAttachment extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
-    field_values: AssetProcedureTypeFieldValues["uuid"];
-}
-export interface AssetProcedureStep extends UUIDModel, TimestampedModel, SubmittedAtModel, CreatedByModel, ColorModel, TreeModel<string> {
-    asset_procedure_type: AssetProcedureType["uuid"];
-    name: string;
-    description: string | null;
-    order: number;
-}
-export interface AssetProcedureStepFields extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel {
-    asset_procedure_step: AssetProcedureStep["uuid"];
-    field_conditions?: SerializedCondition[] | null;
-}
-export interface AssetProcedureStepFieldsAttachment extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
-    fields_revision: AssetProcedureStepFields["uuid"];
-}
-export interface AssetProcedureStepFieldValues extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldValuesModel {
-    fields_revision: AssetProcedureStepFields["uuid"];
-    asset_procedure: AssetProcedure["uuid"];
-    asset_procedure_step: AssetProcedureStep["uuid"];
-    asset: Asset["uuid"];
-}
-export interface AssetProcedureStepFieldValuesAttachment extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsAttachmentModel {
-    field_values: AssetProcedureStepFieldValues["uuid"];
-}
 export interface AssetTypeIdentifier extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, IdentifierModel {
     asset_type: AssetType["uuid"];
 }
@@ -103,12 +44,13 @@ export interface AssetAttachment extends UUIDModel, TimestampedModel, SubmittedA
 export interface AssetTypeAttachment extends UUIDModel, TimestampedModel, SubmittedAtModel, RequiredFileModel, CreatedByModel {
     asset_type: AssetType["uuid"];
 }
-export interface AssetProcedureTypeAttachment extends UUIDModel, TimestampedModel, SubmittedAtModel, RequiredFileModel, CreatedByModel {
-    asset_procedure_type: AssetProcedureType["uuid"];
-}
 export interface AssetTypeStatus extends UUIDModel, SubmittedAtModel, TimestampedModel, ColorModel, CreatedByModel {
     asset_type: AssetType["uuid"];
     name: string;
     type: AssetStatusType;
     order: number;
 }
+export interface AssetComment extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel {
+    asset: Asset["uuid"];
+    content: string;
+}

package/dist/typings/models/issues.d.ts

@@ -41,9 +41,8 @@ export interface IssueUpdate extends UUIDModel, CreatedByModel, SubmittedAtModel
     changes: Partial<Record<IssueUpdateChange, IssueUpdateChangeTypes[IssueUpdateChange]>>;
 }
 export interface IssueAssociation extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel {
-    associated_issue: Issue["uuid"];
-    issue: Issue["uuid"] | null;
-    asset: Asset["uuid"] | null;
+    issue: Issue["uuid"];
+    asset: Asset["uuid"];
 }
 export interface IssueTypeFields extends UUIDModel, SubmittedAtModel, TimestampedModel, CreatedByModel, FieldsModel {
     issue_type: IssueType["uuid"];

package/dist/utils/models/assets.d.ts

@@ -1,5 +1,3 @@
-import { Tree } from 'ts-tree-lib';
-import { AssetProcedureStep, AssetTypeStatus, Stored } from '../../typings';
-export declare const getAssetProcedureStepTrees: (assetProcedureSteps: Stored<AssetProcedureStep>[]) => Tree<Stored<AssetProcedureStep>>[];
-export declare const getAssetProcedureStepSubTree: (uuid: AssetProcedureStep["uuid"], assetProcedureSteps: Stored<AssetProcedureStep>[]) => Tree<Stored<AssetProcedureStep>>;
+import { AssetComment, AssetTypeStatus, Stored } from '../../typings';
+export declare const assetCommentSortFn: (a: Stored<AssetComment>, b: Stored<AssetComment>) => number;
 export declare const assetTypeStatusSortFn: (a: Stored<AssetTypeStatus>, b: Stored<AssetTypeStatus>) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@overmap-ai/core",
-	"version": "1.0.78-project-status-and-fields.0",
+	"version": "1.0.78-project-status-and-fields.2",
 	"description": "Core functionality for Overmap",
 	"keywords": [
 		"components",

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

@@ -1,28 +0,0 @@
-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 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<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<AssetProcedure> | undefined>;
-        selectByIds: (uuids: string[]) => (state: any) => Stored<AssetProcedure>[];
-    };
-    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

@@ -1,31 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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[]>;
-}