@overmap-ai/core 1.0.79-project-folder.1 → 1.0.80-url-field-support.0

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

@@ -1,31 +1,30 @@
-import { FilePayload, Issue, IssueAttachment, Project, Stored, Submitted } from '../../typings';
+import { IssueAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
-export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueAttachment["uuid"], IssueAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueAttachment["uuid"], IssueAttachment, TState, TSDK> {
     name: string;
     url: string;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
-    protected getId(model: Stored<IssueAttachment>): IssueAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<IssueAttachment>;
-    protected buildPayload(model: Submitted<IssueAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        issue: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/addIssueAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/addIssueAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/setIssueAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/setIssueAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>, "issueAttachments/updateIssueAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/updateIssueAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueAttachments/deleteIssueAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueAttachments/deleteIssueAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueAttachment>[], "issueAttachments/initializeIssueAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueAttachment>[];
     };
-    bulkAdd(payloads: {
-        issueUuid: Issue["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueAttachment>>;
-    delete(uuid: IssueAttachment["uuid"]): Promise<void>;
+    protected getId(model: Stored<IssueAttachment>): IssueAttachment["uuid"];
+    protected getBlockers(model: Stored<IssueAttachment>): string[];
+    protected getBlocks(model: Stored<IssueAttachment>): string[];
+    protected buildModel(data: Payload<IssueAttachment>): Submitted<IssueAttachment>;
+    protected buildPayload(model: Submitted<IssueAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueAttachment>): object;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueAttachment[]>;
 }

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

@@ -1,31 +1,30 @@
-import { FilePayload, IssueComment, IssueCommentAttachment, Project, Stored, Submitted } from '../../typings';
+import { IssueCommentAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
-export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueCommentAttachment["uuid"], IssueCommentAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueCommentAttachment["uuid"], IssueCommentAttachment, TState, TSDK> {
     name: string;
     url: string;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
-    protected getId(model: Stored<IssueCommentAttachment>): IssueCommentAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<IssueCommentAttachment>;
-    protected buildPayload(model: Submitted<IssueCommentAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        issue_comment: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/addIssueCommentAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/addIssueCommentAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/setIssueCommentAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/setIssueCommentAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>, "issueCommentAttachments/updateIssueCommentAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/updateIssueCommentAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueCommentAttachments/deleteIssueCommentAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueCommentAttachments/deleteIssueCommentAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueCommentAttachment>[], "issueCommentAttachments/initializeIssueCommentAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueCommentAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueCommentAttachment>[];
     };
-    bulkAdd(payloads: {
-        issueCommentUuid: IssueComment["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueCommentAttachment>>;
-    delete(uuid: IssueCommentAttachment["uuid"]): Promise<void>;
+    protected getId(model: Stored<IssueCommentAttachment>): IssueCommentAttachment["uuid"];
+    protected getBlockers(model: Stored<IssueCommentAttachment>): string[];
+    protected getBlocks(model: Stored<IssueCommentAttachment>): string[];
+    protected buildModel(data: Payload<IssueCommentAttachment>): Submitted<IssueCommentAttachment>;
+    protected buildPayload(model: Submitted<IssueCommentAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueCommentAttachment>): object;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueCommentAttachment[]>;
 }

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

@@ -1,11 +1,28 @@
-import { IssueComment, Payload, Project, UUID } from '../../typings';
+import { IssueComment, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueComment["uuid"], IssueComment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/addIssueComment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/addIssueComments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/setIssueComment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/setIssueComments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>, "issueComments/updateIssueComment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/updateIssueComments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueComments/deleteIssueComment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueComments/deleteIssueComments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueComment>[], "issueComments/initializeIssueComments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueComment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueComment>[];
+    };
     add(payload: Omit<Payload<IssueComment>, "author">): OptimisticModelResult<IssueComment>;
     update(payload: UUID<Partial<Payload<IssueComment>>>): OptimisticModelResult<IssueComment>;
-    remove(uuid: IssueComment["uuid"]): Promise<undefined>;
+    delete(uuid: IssueComment["uuid"]): Promise<undefined>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueComment[]>;
 }

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

@@ -1,11 +1,30 @@
-import { Issue, Payload, Project, UUID } from '../../typings';
+import { Created, Issue, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<Issue["uuid"], Issue, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/addIssue">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/addIssues">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/setIssue">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/setIssues">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>, "issues/updateIssue">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/updateIssues">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issues/deleteIssue">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issues/deleteIssues">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<Issue>[], "issues/initializeIssues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<Issue> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<Issue>[];
+    };
     add(payload: Payload<Issue>): OptimisticModelResult<Issue>;
     update(payload: UUID<Partial<Payload<Issue>>>): OptimisticModelResult<Issue>;
-    remove(uuid: Issue["uuid"]): Promise<undefined>;
+    bulkUpdate(payloads: UUID<Partial<Payload<Issue>>>[], batchSize?: number): [Stored<Issue>[], Promise<Created<Issue>[]>[]];
+    delete(uuid: Issue["uuid"]): Promise<undefined>;
+    bulkDelete(uuids: Issue["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Issue[]>;
 }

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

@@ -1,31 +1,30 @@
-import { FilePayload, IssueType, IssueTypeAttachment, Organization, Stored, Submitted } from '../../typings';
+import { IssueTypeAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseAttachmentService, BuildModelData } from './BaseAttachmentService';
-export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueTypeAttachment["uuid"], IssueTypeAttachment> {
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueTypeAttachment["uuid"], IssueTypeAttachment, TState, TSDK> {
     name: string;
     url: string;
-    initializeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">;
-    addAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">;
-    updateAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">;
-    removeAttachments: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
-    removeAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">;
-    setAttachment: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">;
-    selectAttachment: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
-    protected getId(model: Stored<IssueTypeAttachment>): IssueTypeAttachment["uuid"];
-    protected buildModel(data: BuildModelData): Submitted<IssueTypeAttachment>;
-    protected buildPayload(model: Submitted<IssueTypeAttachment>, filePayload: FilePayload): {
-        uuid: string;
-        file_name: string;
-        file_sha1: string;
-        file_extension: string;
-        issue_type: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/addIssueTypeAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/addIssueTypeAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/setIssueTypeAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/setIssueTypeAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>, "issueTypeAttachments/updateIssueTypeAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/updateIssueTypeAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeAttachments/deleteIssueTypeAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeAttachments/deleteIssueTypeAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeAttachment>[], "issueTypeAttachments/initializeIssueTypeAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeAttachment>[];
     };
-    bulkAdd(payloads: {
-        issueTypeUuid: IssueType["uuid"];
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueTypeAttachment>>;
-    delete(uuid: IssueTypeAttachment["uuid"]): Promise<void>;
+    protected getId(model: Stored<IssueTypeAttachment>): IssueTypeAttachment["uuid"];
+    protected getBlockers(model: Stored<IssueTypeAttachment>): string[];
+    protected getBlocks(model: Stored<IssueTypeAttachment>): string[];
+    protected buildModel(data: Payload<IssueTypeAttachment>): Submitted<IssueTypeAttachment>;
+    protected buildPayload(model: Submitted<IssueTypeAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueTypeAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeAttachment[]>;
 }

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

@@ -1,14 +1,31 @@
-import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, Project } from '../../typings';
+import { IssueTypeFieldValuesAttachment, Payload, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
-    bulkAdd(payloads: {
-        fieldValuesUuid: IssueTypeFieldValues["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldValuesAttachment>>;
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueTypeFieldValuesAttachment["uuid"], IssueTypeFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldValuesAttachments/deleteIssueTypeFieldValuesAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldValuesAttachments/deleteIssueTypeFieldValuesAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/initializeIssueTypeFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValuesAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldValuesAttachment>[];
+    };
+    protected getId(model: Stored<IssueTypeFieldValuesAttachment>): string;
+    protected getBlockers(model: Stored<IssueTypeFieldValuesAttachment>): string[];
+    protected getBlocks(model: Stored<IssueTypeFieldValuesAttachment>): string[];
+    protected buildModel(data: Payload<IssueTypeFieldValuesAttachment>): Submitted<IssueTypeFieldValuesAttachment>;
+    protected buildPayload(model: Submitted<IssueTypeFieldValuesAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueTypeFieldValuesAttachment>): object;
     bulkDelete(uuids: IssueTypeFieldValuesAttachment["uuid"][]): Promise<void>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldValuesAttachment[]>;
 }

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

@@ -1,9 +1,26 @@
-import { IssueTypeFieldValues, Payload, Project, UUID } from '../../typings';
+import { IssueTypeFieldValues, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeFieldValues["uuid"], IssueTypeFieldValues, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/addIssueTypeFieldValues">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/addIssueTypeFieldValuesMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/setIssueTypeFieldValues">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/setIssueTypeFieldValuesMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>, "issueTypeFieldValues/updateIssueTypeFieldValues">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/updateIssueTypeFieldValuesMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldValues/deleteIssueTypeFieldValues">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldValues/deleteIssueTypeFieldValuesMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldValues>[], "issueTypeFieldValues/initializeIssueTypeFieldValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFieldValues> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldValues>[];
+    };
     add(payload: Payload<IssueTypeFieldValues>): OptimisticModelResult<IssueTypeFieldValues>;
     update(payload: UUID<Partial<Payload<IssueTypeFieldValues>>>): OptimisticModelResult<IssueTypeFieldValues>;
     delete(uuid: IssueTypeFieldValues["uuid"]): Promise<void>;

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

@@ -1,13 +1,30 @@
-import { IssueTypeFields, IssueTypeFieldsAttachment, Organization } from '../../typings';
+import { IssueTypeFieldsAttachment, Organization, Payload, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
-import { OptimisticMultipleModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
-    bulkAdd(payloads: {
-        fieldsRevisionUuid: IssueTypeFields["uuid"];
-        fieldIdentifier: string;
-        file: File;
-    }[]): Promise<OptimisticMultipleModelResult<IssueTypeFieldsAttachment>>;
+import { BaseOfflineFileModelApiService } from './BaseOfflineFileModelApiService';
+export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineFileModelApiService<IssueTypeFieldsAttachment["uuid"], IssueTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachments">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachment">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFieldsAttachments/deleteIssueTypeFieldsAttachments">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFieldsAttachment> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldsAttachment>[];
+    };
+    protected getId(model: Stored<IssueTypeFieldsAttachment>): string;
+    protected getBlockers(model: Stored<IssueTypeFieldsAttachment>): string[];
+    protected getBlocks(model: Stored<IssueTypeFieldsAttachment>): string[];
+    protected buildModel(data: Payload<IssueTypeFieldsAttachment>): Submitted<IssueTypeFieldsAttachment>;
+    protected buildPayload(model: Submitted<IssueTypeFieldsAttachment>): object;
+    protected buildBulkPayload(model: Submitted<IssueTypeFieldsAttachment>): object;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeFieldsAttachment[]>;
 }

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

@@ -1,9 +1,26 @@
-import { IssueTypeFields, Organization, Payload } from '../../typings';
+import { IssueTypeFields, Organization, Payload, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeFields["uuid"], IssueTypeFields, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>, "issueTypeFields/addIssueTypeFields">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>[], "issueTypeFields/addIssueTypeFieldsMany">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>, "issueTypeFields/setIssueTypeFields">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>[], "issueTypeFields/setIssueTypeFieldsMany">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>, "issueTypeFields/updateIssueTypeFields">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>[], "issueTypeFields/updateIssueTypeFieldsMany">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeFields/deleteIssueTypeFields">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeFields/deleteIssueTypeFieldsMany">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeFields>[], "issueTypeFields/initializeIssueTypeFields">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeFields> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFields>[];
+    };
     add(payload: Payload<IssueTypeFields>): OptimisticModelResult<IssueTypeFields>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeFields[]>;
 }

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

@@ -1,9 +1,26 @@
-import { IssueTypeIdentifier, Organization, Payload, UUID } from '../../typings';
+import { IssueTypeIdentifier, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeIdentifier["uuid"], IssueTypeIdentifier, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>, "issueTypeIdentifiers/addIssueTypeIdentifier">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>[], "issueTypeIdentifiers/addIssueTypeIdentifiers">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>, "issueTypeIdentifiers/setIssueTypeIdentifier">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>[], "issueTypeIdentifiers/setIssueTypeIdentifiers">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>, "issueTypeIdentifiers/updateIssueTypeIdentifier">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>[], "issueTypeIdentifiers/updateIssueTypeIdentifiers">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeIdentifiers/deleteIssueTypeIdentifier">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeIdentifiers/deleteIssueTypeIdentifiers">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifier>[], "issueTypeIdentifiers/initializeIssueTypeIdentifiers">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeIdentifier> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeIdentifier>[];
+    };
     add(payload: Payload<IssueTypeIdentifier>): OptimisticModelResult<IssueTypeIdentifier>;
     update(payload: UUID<Partial<Payload<IssueTypeIdentifier>>>): OptimisticModelResult<IssueTypeIdentifier>;
     delete(uuid: IssueTypeIdentifier["uuid"]): Promise<undefined>;

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

@@ -1,11 +1,27 @@
-import { IssueTypeIdentifierValue, Payload, Project, UUID } from '../../typings';
+import { IssueTypeIdentifierValue, Payload, Project, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeIdentifierValue["uuid"], IssueTypeIdentifierValue, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>, "issueTypeIdentifierValues/addIssueTypeIdentifierValue">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>[], "issueTypeIdentifierValues/addIssueTypeIdentifierValues">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>, "issueTypeIdentifierValues/setIssueTypeIdentifierValue">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>[], "issueTypeIdentifierValues/setIssueTypeIdentifierValues">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>, "issueTypeIdentifierValues/updateIssueTypeIdentifierValue">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>[], "issueTypeIdentifierValues/updateIssueTypeIdentifierValues">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeIdentifierValues/deleteIssueTypeIdentifierValue">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeIdentifierValues/deleteIssueTypeIdentifierValues">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeIdentifierValue>[], "issueTypeIdentifierValues/initializeIssueTypeIdentifierValues">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeIdentifierValue> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeIdentifierValue>[];
+    };
     add(payload: Payload<IssueTypeIdentifierValue>): OptimisticModelResult<IssueTypeIdentifierValue>;
-    update(payload: UUID<Partial<Payload<IssueTypeIdentifierValue>>>): OptimisticModelResult<IssueTypeIdentifierValue>;
     delete(uuid: IssueTypeIdentifierValue["uuid"]): Promise<undefined>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueTypeIdentifierValue[]>;
 }

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

@@ -0,0 +1,28 @@
+import { IssueTypePriority, 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 IssueTypePriorityService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypePriority["uuid"], IssueTypePriority, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>, "issueTypePriorities/addIssueTypePriority">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>[], "issueTypePriorities/addIssueTypePriorities">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>, "issueTypePriorities/setIssueTypePriority">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>[], "issueTypePriorities/setIssueTypePriorities">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>, "issueTypePriorities/updateIssueTypePriority">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>[], "issueTypePriorities/updateIssueTypePriorities">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypePriorities/deleteIssueTypePriority">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypePriorities/deleteIssueTypePriorities">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypePriority>[], "issueTypePriorities/initializeIssueTypePriorities">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypePriority> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypePriority>[];
+    };
+    add(payload: Payload<IssueTypePriority>): OptimisticModelResult<IssueTypePriority>;
+    update(payload: UUID<Partial<Payload<IssueTypePriority>>>): OptimisticModelResult<IssueTypePriority>;
+    delete(uuid: IssueTypePriority["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypePriority[]>;
+}

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

@@ -1,9 +1,26 @@
-import { IssueType, Organization, Payload, UUID } from '../../typings';
+import { IssueType, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
 import { OvermapRootState } from '../../store';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueType["uuid"], IssueType, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/addIssueType">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/addIssueTypes">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/setIssueType">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/setIssueTypes">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>, "issueTypes/updateIssueType">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/updateIssueTypes">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypes/deleteIssueType">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypes/deleteIssueTypes">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueType>[], "issueTypes/initializeIssueTypes">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueType> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueType>[];
+    };
     add(payload: Payload<IssueType>): OptimisticModelResult<IssueType>;
     update(payload: UUID<Partial<Payload<IssueType>>>): OptimisticModelResult<IssueType>;
     delete(uuid: IssueType["uuid"]): Promise<void>;

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

@@ -0,0 +1,28 @@
+import { IssueTypeStatus, 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 IssueTypeStatusService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeStatus["uuid"], IssueTypeStatus, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>, "issueTypeStatuses/addIssueTypeStatus">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>[], "issueTypeStatuses/addIssueTypeStatuses">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>, "issueTypeStatuses/setIssueTypeStatus">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>[], "issueTypeStatuses/setIssueTypeStatuses">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>, "issueTypeStatuses/updateIssueTypeStatus">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>[], "issueTypeStatuses/updateIssueTypeStatuses">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueTypeStatuses/deleteIssueTypeStatus">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueTypeStatuses/deleteIssueTypeStatuses">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Stored<IssueTypeStatus>[], "issueTypeStatuses/initializeIssueTypeStatuses">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Stored<IssueTypeStatus> | undefined>;
+        selectByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeStatus>[];
+    };
+    add(payload: Payload<IssueTypeStatus>): OptimisticModelResult<IssueTypeStatus>;
+    update(payload: UUID<Partial<Payload<IssueTypeStatus>>>): OptimisticModelResult<IssueTypeStatus>;
+    delete(uuid: IssueTypeStatus["uuid"]): Promise<void>;
+    refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<IssueTypeStatus[]>;
+}