@overmap-ai/core 1.0.78-bulk-project-access.2 → 1.0.78-bulk-update.1

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

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

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

@@ -1,35 +1,34 @@
-import { OvermapRootState } from '../../store';
-import { Organization, Project, ProjectAttachment, Stored } from '../../typings';
+import { FilePayload, Organization, Project, ProjectAttachment, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, ProjectAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class ProjectAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, ProjectAttachment["uuid"], ProjectAttachment> {
     name: string;
     url: string;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAttachment> | undefined>;
-    protected buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/addProjectAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/addProjectAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/setProjectAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/setProjectAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>, "projectAttachments/updateProjectAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/updateProjectAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectAttachments/deleteProjectAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectAttachments/deleteProjectAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<ProjectAttachment>[], "projectAttachments/initializeProjectAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<ProjectAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Stored<ProjectAttachment>[];
+    };
+    protected getId(model: Stored<ProjectAttachment>): ProjectAttachment["uuid"];
+    protected buildModel(data: BuildModelData): Submitted<ProjectAttachment>;
+    protected buildPayload(model: Submitted<ProjectAttachment>, filePayload: FilePayload): {
+        uuid: string;
         file_name: string;
-        file_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        project: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        project: string;
-        modelUuid: import('../..').UUIDModel["uuid"];
-        uuid: import('../..').UUIDModel["uuid"];
-        description: import('../..').Attachment["description"];
-        file_sha1: import('../..').FileWithNameModel["file_sha1"];
-        file_name: import('../..').FileWithNameModel["file_name"];
+        file_sha1: string;
         file_extension: string;
+        project: string;
     };
     bulkAdd(payloads: {
         projectUuid: Project["uuid"];

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { Project, ProjectFile } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticGenericResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class ProjectFileService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<ProjectFile["uuid"], ProjectFile, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/addProjectFile">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/addProjectFiles">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/setProjectFile">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/setProjectFiles">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>, "projectFiles/updateProjectFile">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/updateProjectFiles">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "projectFiles/deleteProjectFile">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "projectFiles/deleteProjectFiles">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<ProjectFile>[], "projectFiles/initializeProjectFiles">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<ProjectFile> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<ProjectFile>[];
+    };
     saveExisting(file: ProjectFile): Promise<ProjectFile>;
     saveActive(): OptimisticGenericResult<ProjectFile>;
     delete(uuid: ProjectFile["uuid"]): Promise<undefined>;

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

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

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

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

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

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

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

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

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

@@ -1,12 +1,12 @@
 export * from './AgentService';
 export * from './AssetAttachmentService';
-export * from './AssetProcedureAttachmentService';
-export * from './AssetProcedureFieldsAttachmentService';
-export * from './AssetProcedureFieldsService';
-export * from './AssetProcedureFieldValuesAttachmentService';
-export * from './AssetProcedureFieldValuesService';
-export * from './AssetProcedureInstanceService';
+export * from './AssetProcedureTypeAttachmentService';
+export * from './AssetProcedureTypeFieldsAttachmentService';
+export * from './AssetProcedureTypeFieldsService';
+export * from './AssetProcedureTypeFieldValuesAttachmentService';
+export * from './AssetProcedureTypeFieldValuesService';
 export * from './AssetProcedureService';
+export * from './AssetProcedureTypeService';
 export * from './AssetProcedureStepFieldsAttachmentService';
 export * from './AssetProcedureStepFieldsService';
 export * from './AssetProcedureStepFieldValuesAttachmentService';
@@ -23,6 +23,7 @@ export * from './AssetTypeFieldValuesService';
 export * from './AssetTypeIdentifierService';
 export * from './AssetTypeIdentifierValueService';
 export * from './AssetTypeService';
+export * from './AssetTypeStatusService';
 export * from './BaseApiService';
 export * from './CategoryService';
 export * from './DocumentAttachmentService';
@@ -51,6 +52,7 @@ export * from './IssueTypeFieldValuesService';
 export * from './IssueTypeIdentifierService';
 export * from './IssueTypeIdentifierValueService';
 export * from './IssueTypeService';
+export * from './IssueTypeStatusService';
 export * from './IssueUpdateService';
 export * from './JWTAuthService';
 export * from './OrganizationAccessService';
@@ -62,3 +64,6 @@ export * from './ProjectService';
 export * from './TeamMembershipService';
 export * from './TeamService';
 export * from './UserService';
+export * from './BaseModelApiService';
+export * from './BaseOfflineModelApiService';
+export * from './BaseOfflineAttachmentModelService';

package/dist/sdk/typings.d.ts

@@ -1,8 +1,7 @@
 import { Store } from '@reduxjs/toolkit';
-import { default as request } from 'superagent';
-import { HttpMethod } from '../enums';
 import { BaseState } from '../store';
 import { Created, Model, Stored, Submitted } from '../typings';
+import { HttpMethod } from '../enums';
 import { DeferredPromise } from '../utils';
 import { BaseSDK } from './base';
 import { GetS3UrlResponse, GetS3UrlSuccessResponse } from './services';
@@ -15,6 +14,7 @@ export interface Credentials {
     username: string;
     password: string;
 }
+export type QueryParams = Record<string, string | boolean | number | undefined>;
 /** You should not have to use this type in SDK service modules. Use SDKRequest instead. */
 export interface RequestDetails {
     /** `url` is assumed to be relative to the BASE URL, unless `isExternalUrl` is `true` */
@@ -23,15 +23,18 @@ export interface RequestDetails {
     checkAuth?: boolean;
     /** A unique identifier for the request. */
     uuid: string;
-    /** If true, the request will be sent immediately, bypassing the outbox. */
-    immediate?: boolean;
     isExternalUrl?: boolean;
     isResponseBlob?: boolean;
-    queryParams?: Record<string, string | boolean | number | undefined>;
+    queryParams?: QueryParams;
     isAuthNeeded?: boolean;
     /** The hash of any included attachments being uploaded to S3, retrieved from cache before the request is fired */
     attachmentHash?: string;
     headers?: Record<string, string>;
+    payload?: object;
+    method: HttpMethod;
+    s3url?: GetS3UrlResponse;
+}
+export interface OfflineRequestDetails extends RequestDetails {
     description?: string;
     /**
      * A list of offline_ids referenced that must be resolved before this request can be sent.
@@ -39,59 +42,20 @@ export interface RequestDetails {
     blockers: string[];
     /** A list of offline_ids of all objects being created or altered. */
     blocks: string[];
-    payload?: object;
-    /** Set automatically by the SDK. Do not set yourself. This is equal to the first element in `requestIdentifiers`.*/
-    _primaryIdentifier?: string;
-    method: HttpMethod;
-    s3url?: GetS3UrlResponse;
 }
 /** Represents the details of a request. The `uuid` field is optional. It only needs to be specified if the consuming
  * code may have to cancel or otherwise modify the request at a later time. */
 export type SDKRequest = Omit<RequestDetails, "uuid"> & {
     uuid?: string;
 };
-export type PaginatedSDKRequest = SDKRequest & {
-    limit: number;
-    paginate: true;
+export type OfflineSDKRequest = Omit<OfflineRequestDetails, "uuid"> & {
+    uuid?: string;
 };
-/**
- * Represents the result of a successful API request.
- * @deprecated Use `T` directly instead.
- */
-export type ApiSuccessResult<T> = T;
-/**
- * Represents a successful API result for one instance of a model.
- * @deprecated Use `T` directly instead.
- */
-export type ApiResult<T> = T;
-/**
- * Represents a successful API result for one instance of a model.
- * @deprecated Use `Created<T>` directly instead.
- */
-export type ApiModelSuccessResult<T extends Model | undefined> = Created<T>;
-/**
- * Represents a successful API result containing an array of instances of the specified model shape.
- * @deprecated Use `Created<T>[]` directly instead.
- */
-export type ApiMultipleSuccessResult<T> = Created<T>[];
-/**
- * Represents an error message, which is not specific to the model's type. This is stored in the `result` field of an
- * `APIError` instance.
- */
-export interface APIErrorResult {
-    success: false;
-    errorMessage: string;
-    response?: request.Response;
-}
-/**
- * Represents a successful API result for one instance of a model.
- * @deprecated Use `Created<T>` directly instead.
- */
-export type ApiModelResult<T extends Model | undefined> = Created<T>;
-/**
- * @deprecated Use `Created<T>[]` directly instead.
- */
-export type ApiMultipleModelResult<T extends Model> = Created<T>[];
+export type ModelSDKRequest = Omit<SDKRequest, "url">;
+export type PaginatedSDKRequest = Omit<SDKRequest, "queryParams"> & {
+    queryParams?: Omit<QueryParams, "limit" | "paginate">;
+};
+export type PaginatedModelSDKRequest = Omit<PaginatedSDKRequest, "url">;
 /**
  * An "optimistic" result consists of two things:
  * 1. An offline model instance from the store (with the assumption that the API request will succeed)
@@ -116,11 +80,4 @@ export type PaginatedResult<T> = {
     previous: string | null;
     results: T;
 };
-export interface OfflineMetaEffect {
-    request: RequestDetails;
-    /** An ISO timestamp of when the request was created. */
-    timestamp: string;
-    BASE_URL: string;
-    serviceName: string;
-}
 export type PresignedUrlsResponse = Record<string, GetS3UrlSuccessResponse>;

package/dist/sdk/utils.d.ts

@@ -0,0 +1,2 @@
+import { HttpMethod } from '../enums';
+export declare function getRequestDescription(method: HttpMethod, modelName: string, many: boolean): string;

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

@@ -1,15 +1,14 @@
-import { PayloadAction } from '@reduxjs/toolkit';
-import { ModelState } from './typings';
-export interface OvermapModelAdapter<TId extends string | number | symbol, TModel> {
-    addOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
-    addMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    setOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
-    setMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    updateOne: (state: ModelState<TId, TModel>, action: PayloadAction<TModel>) => void;
-    updateMany: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    deleteOne: (state: ModelState<TId, TModel>, action: PayloadAction<TId>) => void;
-    deleteMany: (state: ModelState<TId, TModel>, action: PayloadAction<TId[]>) => void;
-    initialize: (state: ModelState<TId, TModel>, action: PayloadAction<TModel[]>) => void;
-    getInitialState: <TState extends object>(state: TState) => TState & ModelState<TId, TModel>;
+import { CaseReducer } from '@reduxjs/toolkit';
+import { AddManyPayloadAction, AddOnePayloadAction, DeleteManyPayloadAction, DeleteOnePayloadAction, InitializePayloadAction, ModelState, SetManyPayloadAction, SetOnePayloadAction, UpdateManyPayloadAction, UpdateOnePayloadAction } from './typings';
+export interface OvermapModelAdapter<TId extends PropertyKey, TModel, TState extends ModelState<TId, TModel>> {
+    addOne: CaseReducer<TState, AddOnePayloadAction<TModel>>;
+    addMany: CaseReducer<TState, AddManyPayloadAction<TModel>>;
+    setOne: CaseReducer<TState, SetOnePayloadAction<TModel>>;
+    setMany: CaseReducer<TState, SetManyPayloadAction<TModel>>;
+    updateOne: CaseReducer<TState, UpdateOnePayloadAction<TModel>>;
+    updateMany: CaseReducer<TState, UpdateManyPayloadAction<TModel>>;
+    deleteOne: CaseReducer<TState, DeleteOnePayloadAction<TId>>;
+    deleteMany: CaseReducer<TState, DeleteManyPayloadAction<TId>>;
+    initialize: CaseReducer<TState, InitializePayloadAction<TModel>>;
 }
-export declare function createModelAdapter<TId extends string | number | symbol, TModel>(computeModelId: (model: TModel) => TId): OvermapModelAdapter<TId, TModel>;
+export declare function createModelAdapter<TId extends PropertyKey, TModel, TState extends ModelState<TId, TModel>>(computeModelId: (model: TModel) => TId): OvermapModelAdapter<TId, TModel, TState>;

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

@@ -1,6 +1,25 @@
+import { PayloadAction, ActionCreatorWithPayload } from '@reduxjs/toolkit';
 export interface ModelState<TId extends number | string | symbol, TModel> {
     instances: Record<TId, TModel>;
 }
 export interface SelectionState<TSelection> {
     selection: TSelection[];
 }
+export type InitializePayloadAction<TModel> = PayloadAction<TModel[]>;
+export type AddOnePayloadAction<TModel> = PayloadAction<TModel>;
+export type AddManyPayloadAction<TModel> = PayloadAction<TModel[]>;
+export type UpdateOnePayloadAction<TModel> = PayloadAction<TModel>;
+export type UpdateManyPayloadAction<TModel> = PayloadAction<TModel[]>;
+export type DeleteOnePayloadAction<TId> = PayloadAction<TId>;
+export type DeleteManyPayloadAction<TId> = PayloadAction<TId[]>;
+export type SetOnePayloadAction<TModel> = PayloadAction<TModel>;
+export type SetManyPayloadAction<TModel> = PayloadAction<TModel[]>;
+export type InitializePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;
+export type AddOnePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel>;
+export type AddManyPayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;
+export type UpdateOnePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel>;
+export type UpdateManyPayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;
+export type DeleteOnePayloadActionCreator<TId> = ActionCreatorWithPayload<TId>;
+export type DeleteManyPayloadActionCreator<TId> = ActionCreatorWithPayload<TId[]>;
+export type SetOnePayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel>;
+export type SetManyPayloadActionCreator<TModel> = ActionCreatorWithPayload<TModel[]>;

package/dist/store/reducers.d.ts

@@ -56,19 +56,21 @@ export declare const overmapReducers: {
     issueTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').IssueTypeFieldValuesAttachmentState>;
     issueTypeIdentifierReducer: import('redux').Reducer<import('./slices').IssueTypeIdentifierState>;
     issueTypeIdentifierValueReducer: import('redux').Reducer<import('./slices').IssueTypeIdentifierValueState>;
+    issueTypeStatusReducer: import('redux').Reducer<import('./slices').IssueTypeStatusState>;
     assetTypeFieldsReducer: import('redux').Reducer<import('./slices').AssetTypeFieldsState>;
     assetTypeFieldValuesReducer: import('redux').Reducer<import('./slices').AssetTypeFieldValuesState>;
     assetTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeFieldsAttachmentState>;
     assetTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetTypeFieldValuesAttachmentState>;
     assetTypeIdentifierReducer: import('redux').Reducer<import('./slices').AssetTypeIdentifierState>;
     assetTypeIdentifierValueReducer: import('redux').Reducer<import('./slices').AssetTypeIdentifierValueState>;
+    assetTypeStatusReducer: import('redux').Reducer<import('./slices').AssetTypeStatusState>;
+    assetProcedureTypeReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeState>;
     assetProcedureReducer: import('redux').Reducer<import('./slices').AssetProcedureState>;
-    assetProcedureInstanceReducer: import('redux').Reducer<import('./slices').AssetProcedureInstanceState>;
-    assetProcedureFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldsState>;
-    assetProcedureFieldValuesReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldValuesState>;
-    assetProcedureFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldsAttachmentState>;
-    assetProcedureFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureFieldValuesAttachmentState>;
-    assetProcedureAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureAttachmentState>;
+    assetProcedureTypeFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldsState>;
+    assetProcedureTypeFieldValuesReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldValuesState>;
+    assetProcedureTypeFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldsAttachmentState>;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeFieldValuesAttachmentState>;
+    assetProcedureTypeAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureTypeAttachmentState>;
     assetProcedureStepFieldsAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldsAttachmentState>;
     assetProcedureStepFieldsReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldsState>;
     assetProcedureStepFieldValuesAttachmentReducer: import('redux').Reducer<import('./slices').AssetProcedureStepFieldValuesAttachmentState>;
@@ -123,19 +125,21 @@ export declare const overmapReducer: import('redux').Reducer<{
     issueTypeFieldValuesAttachmentReducer: import('./slices').IssueTypeFieldValuesAttachmentState;
     issueTypeIdentifierReducer: import('./slices').IssueTypeIdentifierState;
     issueTypeIdentifierValueReducer: import('./slices').IssueTypeIdentifierValueState;
+    issueTypeStatusReducer: import('./slices').IssueTypeStatusState;
     assetTypeFieldsReducer: import('./slices').AssetTypeFieldsState;
     assetTypeFieldValuesReducer: import('./slices').AssetTypeFieldValuesState;
     assetTypeFieldsAttachmentReducer: import('./slices').AssetTypeFieldsAttachmentState;
     assetTypeFieldValuesAttachmentReducer: import('./slices').AssetTypeFieldValuesAttachmentState;
     assetTypeIdentifierReducer: import('./slices').AssetTypeIdentifierState;
     assetTypeIdentifierValueReducer: import('./slices').AssetTypeIdentifierValueState;
+    assetTypeStatusReducer: import('./slices').AssetTypeStatusState;
+    assetProcedureTypeReducer: import('./slices').AssetProcedureTypeState;
     assetProcedureReducer: import('./slices').AssetProcedureState;
-    assetProcedureInstanceReducer: import('./slices').AssetProcedureInstanceState;
-    assetProcedureFieldsReducer: import('./slices').AssetProcedureFieldsState;
-    assetProcedureFieldValuesReducer: import('./slices').AssetProcedureFieldValuesState;
-    assetProcedureFieldsAttachmentReducer: import('./slices').AssetProcedureFieldsAttachmentState;
-    assetProcedureFieldValuesAttachmentReducer: import('./slices').AssetProcedureFieldValuesAttachmentState;
-    assetProcedureAttachmentReducer: import('./slices').AssetProcedureAttachmentState;
+    assetProcedureTypeFieldsReducer: import('./slices').AssetProcedureTypeFieldsState;
+    assetProcedureTypeFieldValuesReducer: import('./slices').AssetProcedureTypeFieldValuesState;
+    assetProcedureTypeFieldsAttachmentReducer: import('./slices').AssetProcedureTypeFieldsAttachmentState;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('./slices').AssetProcedureTypeFieldValuesAttachmentState;
+    assetProcedureTypeAttachmentReducer: import('./slices').AssetProcedureTypeAttachmentState;
     assetProcedureStepFieldsAttachmentReducer: import('./slices').AssetProcedureStepFieldsAttachmentState;
     assetProcedureStepFieldsReducer: import('./slices').AssetProcedureStepFieldsState;
     assetProcedureStepFieldValuesAttachmentReducer: import('./slices').AssetProcedureStepFieldValuesAttachmentState;
@@ -189,19 +193,21 @@ export declare const overmapReducer: import('redux').Reducer<{
     issueTypeFieldValuesAttachmentReducer: import('./slices').IssueTypeFieldValuesAttachmentState | undefined;
     issueTypeIdentifierReducer: import('./slices').IssueTypeIdentifierState | undefined;
     issueTypeIdentifierValueReducer: import('./slices').IssueTypeIdentifierValueState | undefined;
+    issueTypeStatusReducer: import('./slices').IssueTypeStatusState | undefined;
     assetTypeFieldsReducer: import('./slices').AssetTypeFieldsState | undefined;
     assetTypeFieldValuesReducer: import('./slices').AssetTypeFieldValuesState | undefined;
     assetTypeFieldsAttachmentReducer: import('./slices').AssetTypeFieldsAttachmentState | undefined;
     assetTypeFieldValuesAttachmentReducer: import('./slices').AssetTypeFieldValuesAttachmentState | undefined;
     assetTypeIdentifierReducer: import('./slices').AssetTypeIdentifierState | undefined;
     assetTypeIdentifierValueReducer: import('./slices').AssetTypeIdentifierValueState | undefined;
+    assetTypeStatusReducer: import('./slices').AssetTypeStatusState | undefined;
+    assetProcedureTypeReducer: import('./slices').AssetProcedureTypeState | undefined;
     assetProcedureReducer: import('./slices').AssetProcedureState | undefined;
-    assetProcedureInstanceReducer: import('./slices').AssetProcedureInstanceState | undefined;
-    assetProcedureFieldsReducer: import('./slices').AssetProcedureFieldsState | undefined;
-    assetProcedureFieldValuesReducer: import('./slices').AssetProcedureFieldValuesState | undefined;
-    assetProcedureFieldsAttachmentReducer: import('./slices').AssetProcedureFieldsAttachmentState | undefined;
-    assetProcedureFieldValuesAttachmentReducer: import('./slices').AssetProcedureFieldValuesAttachmentState | undefined;
-    assetProcedureAttachmentReducer: import('./slices').AssetProcedureAttachmentState | undefined;
+    assetProcedureTypeFieldsReducer: import('./slices').AssetProcedureTypeFieldsState | undefined;
+    assetProcedureTypeFieldValuesReducer: import('./slices').AssetProcedureTypeFieldValuesState | undefined;
+    assetProcedureTypeFieldsAttachmentReducer: import('./slices').AssetProcedureTypeFieldsAttachmentState | undefined;
+    assetProcedureTypeFieldValuesAttachmentReducer: import('./slices').AssetProcedureTypeFieldValuesAttachmentState | undefined;
+    assetProcedureTypeAttachmentReducer: import('./slices').AssetProcedureTypeAttachmentState | undefined;
     assetProcedureStepFieldsAttachmentReducer: import('./slices').AssetProcedureStepFieldsAttachmentState | undefined;
     assetProcedureStepFieldsReducer: import('./slices').AssetProcedureStepFieldsState | undefined;
     assetProcedureStepFieldValuesAttachmentReducer: import('./slices').AssetProcedureStepFieldValuesAttachmentState | undefined;