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

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

@@ -1,36 +1,34 @@
-import { OvermapRootState } from '../../store';
-import { IssueComment, IssueCommentAttachment, Project, Stored } from '../../typings';
+import { FilePayload, IssueComment, IssueCommentAttachment, Project, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueCommentAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class IssueCommentAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, IssueCommentAttachment["uuid"], IssueCommentAttachment> {
     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 buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    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: (args: string[]) => (state: OvermapRootState) => Stored<IssueCommentAttachment>[];
+    };
+    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_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        issue_comment: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        issue_comment: 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;
+        issue_comment: string;
     };
     bulkAdd(payloads: {
         issueCommentUuid: IssueComment["uuid"];

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

@@ -1,11 +1,28 @@
-import { OvermapRootState } from '../../store';
-import { IssueComment, Payload, Project, UUID } from '../../typings';
+import { IssueComment, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueCommentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => 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,29 @@
-import { OvermapRootState } from '../../store';
-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 { BaseApiService } from './BaseApiService';
-export declare abstract class IssueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => 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>;
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<Issue[]>;
 }

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

@@ -1,36 +1,34 @@
-import { OvermapRootState } from '../../store';
-import { IssueType, IssueTypeAttachment, Organization, Stored } from '../../typings';
+import { FilePayload, IssueType, IssueTypeAttachment, Organization, Stored, Submitted } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseAttachmentService, BuildAttachmentPayloadData, BuildOfflineAttachmentData } from './BaseAttachmentService';
-export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseAttachmentService<TState, TSDK, IssueTypeAttachment> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineAttachmentModelService, BuildModelData } from './BaseOfflineAttachmentModelService';
+export declare abstract class IssueTypeAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineAttachmentModelService<TState, TSDK, IssueTypeAttachment["uuid"], IssueTypeAttachment> {
     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 buildOfflineAttachment(data: BuildOfflineAttachmentData): import('../..').UUID<{
-        file: string;
-        file_sha1: string;
-        created_by: number | undefined;
+    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: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeAttachment>[];
+    };
+    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_type: string;
-        submitted_at: string;
-        description: string | undefined;
-        issue_type: string;
-    }>;
-    protected buildAttachmentPayload(data: BuildAttachmentPayloadData): {
-        issue_type: 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;
+        issue_type: string;
     };
     bulkAdd(payloads: {
         issueTypeUuid: IssueType["uuid"];

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, Project } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeFieldValuesAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeFieldValuesAttachment["uuid"], IssueTypeFieldValuesAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/addIssueTypeFieldValuesAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/setIssueTypeFieldValuesAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldValuesAttachment>, "issueTypeFieldValuesAttachments/updateIssueTypeFieldValuesAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').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<import('../..').Stored<IssueTypeFieldValuesAttachment>[], "issueTypeFieldValuesAttachments/initializeIssueTypeFieldValuesAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<IssueTypeFieldValuesAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<IssueTypeFieldValuesAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldValuesUuid: IssueTypeFieldValues["uuid"];
         fieldIdentifier: string;

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { IssueTypeFieldValues, Payload, Project, UUID } from '../../typings';
+import { IssueTypeFieldValues, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeFieldValuesService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => 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,9 +1,26 @@
-import { OvermapRootState } from '../../store';
 import { IssueTypeFields, IssueTypeFieldsAttachment, Organization } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticMultipleModelResult } from '../typings';
-import { BaseUploadService } from './BaseUploadService';
-export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseUploadService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueTypeFieldsAttachmentService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueTypeFieldsAttachment["uuid"], IssueTypeFieldsAttachment, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/addIssueTypeFieldsAttachment">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/addIssueTypeFieldsAttachments">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/setIssueTypeFieldsAttachment">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/setIssueTypeFieldsAttachments">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueTypeFieldsAttachment>, "issueTypeFieldsAttachments/updateIssueTypeFieldsAttachment">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').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<import('../..').Stored<IssueTypeFieldsAttachment>[], "issueTypeFieldsAttachments/initializeIssueTypeFieldsAttachments">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, import('../..').Stored<IssueTypeFieldsAttachment> | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<IssueTypeFieldsAttachment>[];
+    };
     bulkAdd(payloads: {
         fieldsRevisionUuid: IssueTypeFields["uuid"];
         fieldIdentifier: string;

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { IssueTypeFields, Organization, Payload } from '../../typings';
+import { IssueTypeFields, Organization, Payload, Stored } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeFieldsService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => 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 { OvermapRootState } from '../../store';
-import { IssueTypeIdentifier, Organization, Payload, UUID } from '../../typings';
+import { IssueTypeIdentifier, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeIdentifierService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => 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,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { IssueTypeIdentifierValue, Payload, Project, UUID } from '../../typings';
+import { IssueTypeIdentifierValue, Payload, Project, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeIdentifierValueService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => Stored<IssueTypeIdentifierValue>[];
+    };
     add(payload: Payload<IssueTypeIdentifierValue>): OptimisticModelResult<IssueTypeIdentifierValue>;
     update(payload: UUID<Partial<Payload<IssueTypeIdentifierValue>>>): OptimisticModelResult<IssueTypeIdentifierValue>;
     delete(uuid: IssueTypeIdentifierValue["uuid"]): Promise<undefined>;

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

@@ -1,9 +1,26 @@
-import { OvermapRootState } from '../../store';
-import { IssueType, Organization, Payload, UUID } from '../../typings';
+import { IssueType, Organization, Payload, Stored, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueTypeService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+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: (args: string[]) => (state: OvermapRootState) => 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: (args: string[]) => (state: OvermapRootState) => 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[]>;
+}

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

@@ -1,7 +1,24 @@
-import { OvermapRootState } from '../../store';
 import { IssueUpdate, Project } from '../../typings';
 import { BaseSDK } from '../base';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class IssueUpdateService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseOfflineModelApiService } from './BaseOfflineModelApiService';
+export declare abstract class IssueUpdateService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseOfflineModelApiService<IssueUpdate["uuid"], IssueUpdate, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>, "issueUpdates/addIssueUpdate">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>[], "issueUpdates/addIssueUpdates">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>, "issueUpdates/setIssueUpdate">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>[], "issueUpdates/setIssueUpdates">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>, "issueUpdates/updateIssueUpdate">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>[], "issueUpdates/updateIssueUpdates">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "issueUpdates/deleteIssueUpdate">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "issueUpdates/deleteIssueUpdates">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').Stored<IssueUpdate>[], "issueUpdates/initializeIssueUpdates">;
+    };
+    selectors: {
+        selectById: (args: string) => (state: OvermapRootState) => import('../..').Stored<IssueUpdate> | undefined;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => import('../..').Stored<IssueUpdate>[];
+    };
     refreshStore(projectUuid: Project["uuid"], signal?: AbortSignal): Promise<IssueUpdate[]>;
 }

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

@@ -1,7 +1,7 @@
 import { default as request } from 'superagent';
-import { BaseState } from '../../store';
 import { BaseSDK } from '../base';
 import { TokenPair } from '../typings';
+import { BaseState } from '../../store';
 import { BaseAuthService } from './BaseAuthService';
 /**
  * Handles login, logout and renewing tokens

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

@@ -1,10 +1,27 @@
-import { OvermapRootState } from '../../store';
 import { Organization, OrganizationAccess, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
 import { OptimisticModelResult } from '../typings';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class OrganizationAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseModelApiService } from './BaseModelApiService';
+export declare abstract class OrganizationAccessService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseModelApiService<OrganizationAccess["uuid"], OrganizationAccess, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess, "organizationAccess/addOrganizationAccess">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/addOrganizationAccesses">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess, "organizationAccess/setOrganizationAccess">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/setOrganizationAccesses">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess, "organizationAccess/updateOrganizationAccess">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/updateOrganizationAccesses">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "organizationAccess/deleteOrganizationAccess">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "organizationAccess/deleteOrganizationAccesses">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<OrganizationAccess[], "organizationAccess/initializeOrganizationAccesses">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, OrganizationAccess | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => OrganizationAccess[];
+    };
     update(payload: UUID<Payload<OrganizationAccess>>): OptimisticModelResult<OrganizationAccess>;
-    remove(uuid: OrganizationAccess["uuid"]): Promise<undefined>;
+    delete(uuid: OrganizationAccess["uuid"]): Promise<undefined>;
     refreshStore(organizationUuid: Organization["uuid"], signal?: AbortSignal): Promise<OrganizationAccess[]>;
 }

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

@@ -1,8 +1,25 @@
-import { OvermapRootState } from '../../store';
 import { Organization, Payload, UUID } from '../../typings';
 import { BaseSDK } from '../base';
-import { BaseApiService } from './BaseApiService';
-export declare abstract class OrganizationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseApiService<TState, TSDK> {
+import { OvermapRootState } from '../../store';
+import { BaseModelApiService } from './BaseModelApiService';
+export declare abstract class OrganizationService<TState extends OvermapRootState, TSDK extends BaseSDK<TState>> extends BaseModelApiService<Organization["uuid"], Organization, TState, TSDK> {
+    name: string;
+    url: string;
+    actions: {
+        addOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization, "organizations/addOrganization">;
+        addMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/addOrganizations">;
+        setOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization, "organizations/setOrganization">;
+        setMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/setOrganizations">;
+        updateOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization, "organizations/updateOrganization">;
+        updateMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/updateOrganizations">;
+        deleteOne: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "organizations/deleteOrganization">;
+        deleteMany: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "organizations/deleteOrganizations">;
+        initialize: import('@reduxjs/toolkit').ActionCreatorWithPayload<Organization[], "organizations/initializeOrganizations">;
+    };
+    selectors: {
+        selectById: import('../..').OvermapSelectorWithArgs<string, Organization | undefined>;
+        selectByIds: (args: string[]) => (state: OvermapRootState) => Organization[];
+    };
     add(payload: Payload<Organization>): Promise<Organization>;
     update(payload: UUID<Partial<Payload<Organization>>>): Promise<Organization>;
     invite(organizationUuid: Organization["uuid"], email: string): Promise<undefined>;