import { ipcClient } from './ipc-client';

export function nhentaiSaveFavorites(): Promise<void> {
  return ipcClient.ask(IpcChannel.NHENTAI_SAVE_FAVORITES, undefined);
}

export function nhentaiGetWork(galleryId: string): Promise<WorkEntityInterface> {
  return ipcClient.ask(IpcChannel.NHENTAI_GET_WORK, { galleryId });
}

type IpcChannelEntityRead =
  | IpcChannel.ENTITY_READ_AUTHOR
  | IpcChannel.ENTITY_READ_AUTHOR_NAME
  | IpcChannel.ENTITY_READ_AUTHOR_ROLE
  | IpcChannel.ENTITY_READ_AUTHOR_ROLE_NAME
  | IpcChannel.ENTITY_READ_CHARACTER_TAG
  | IpcChannel.ENTITY_READ_COLLECTION
  | IpcChannel.ENTITY_READ_COLLECTION_NAME
  | IpcChannel.ENTITY_READ_COLLECTION_PART
  | IpcChannel.ENTITY_READ_COPY
  | IpcChannel.ENTITY_READ_INTERACTION_TAG
  | IpcChannel.ENTITY_READ_LANGUAGE
  | IpcChannel.ENTITY_READ_SITE
  | IpcChannel.ENTITY_READ_SITE_NAME
  | IpcChannel.ENTITY_READ_SOURCE
  | IpcChannel.ENTITY_READ_TAG
  | IpcChannel.ENTITY_READ_TAG_NAME
  | IpcChannel.ENTITY_READ_TRANSFORMATION
  | IpcChannel.ENTITY_READ_TRANSFORMATION_TYPE
  | IpcChannel.ENTITY_READ_TRANSFORMATION_TYPE_NAME
  | IpcChannel.ENTITY_READ_WORK_AUTHOR
  | IpcChannel.ENTITY_READ_WORK_CHARACTER
  | IpcChannel.ENTITY_READ_WORK_CHARACTER_NAME
  | IpcChannel.ENTITY_READ_WORK
  | IpcChannel.ENTITY_READ_WORK_NAME
  | IpcChannel.ENTITY_READ_WORK_TAG
  | IpcChannel.ENTITY_READ_WORLD
  | IpcChannel.ENTITY_READ_WORLD_NAME
  | IpcChannel.ENTITY_READ_WORLD_CHARACTER
  | IpcChannel.ENTITY_READ_WORLD_CHARACTER_NAME;

/**
 * when there are duplicate requests to the same entity, the existing promise is returned
 *
 * this promise is deleted once resolved, this is not a cache!
 */
const entityReadPromiseCollector: {
  [channel in IpcChannelEntityRead]: {
    [identifier in Identifier]?: Promise<IpcAnswer<channel>>;
  };
} = {
  [IpcChannel.ENTITY_READ_AUTHOR]: {},
  [IpcChannel.ENTITY_READ_AUTHOR_NAME]: {},
  [IpcChannel.ENTITY_READ_AUTHOR_ROLE]: {},
  [IpcChannel.ENTITY_READ_AUTHOR_ROLE_NAME]: {},
  [IpcChannel.ENTITY_READ_CHARACTER_TAG]: {},
  [IpcChannel.ENTITY_READ_COLLECTION]: {},
  [IpcChannel.ENTITY_READ_COLLECTION_NAME]: {},
  [IpcChannel.ENTITY_READ_COLLECTION_PART]: {},
  [IpcChannel.ENTITY_READ_COPY]: {},
  [IpcChannel.ENTITY_READ_INTERACTION_TAG]: {},
  [IpcChannel.ENTITY_READ_LANGUAGE]: {},
  [IpcChannel.ENTITY_READ_SITE]: {},
  [IpcChannel.ENTITY_READ_SITE_NAME]: {},
  [IpcChannel.ENTITY_READ_SOURCE]: {},
  [IpcChannel.ENTITY_READ_TAG]: {},
  [IpcChannel.ENTITY_READ_TAG_NAME]: {},
  [IpcChannel.ENTITY_READ_TRANSFORMATION]: {},
  [IpcChannel.ENTITY_READ_TRANSFORMATION_TYPE]: {},
  [IpcChannel.ENTITY_READ_TRANSFORMATION_TYPE_NAME]: {},
  [IpcChannel.ENTITY_READ_WORK_AUTHOR]: {},
  [IpcChannel.ENTITY_READ_WORK_CHARACTER]: {},
  [IpcChannel.ENTITY_READ_WORK_CHARACTER_NAME]: {},
  [IpcChannel.ENTITY_READ_WORK]: {},
  [IpcChannel.ENTITY_READ_WORK_NAME]: {},
  [IpcChannel.ENTITY_READ_WORK_TAG]: {},
  [IpcChannel.ENTITY_READ_WORLD]: {},
  [IpcChannel.ENTITY_READ_WORLD_NAME]: {},
  [IpcChannel.ENTITY_READ_WORLD_CHARACTER]: {},
  [IpcChannel.ENTITY_READ_WORLD_CHARACTER_NAME]: {},
};

function readCollected<T extends IpcChannelEntityRead>(channel: T, identifier: IpcParameter<T>): Promise<IpcAnswer<T>> {
  if (entityReadPromiseCollector[channel][identifier] === undefined) {
    // @ts-ignore -- no fucking clue how to type this correctly
    entityReadPromiseCollector[channel][identifier] = ipcClient.ask<T>(channel, identifier).then((value) => {
      delete entityReadPromiseCollector[channel][identifier];
      return value;
    });
  }
  return entityReadPromiseCollector[channel][identifier] as unknown as Promise<IpcAnswer<T>>;
}

export const entityApi = {
  createAuthor(data: Partial<AuthorSerializedInterface>): Promise<AuthorSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_AUTHOR, data);
  },
  createAuthorName(data: Partial<AuthorNameSerializedInterface>): Promise<AuthorNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_AUTHOR_NAME, data);
  },
  createAuthorRole(data: Partial<AuthorRoleSerializedInterface>): Promise<AuthorRoleSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_AUTHOR_ROLE, data);
  },
  createAuthorRoleName(data: Partial<AuthorRoleNameSerializedInterface>): Promise<AuthorRoleNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_AUTHOR_ROLE_NAME, data);
  },
  createCharacterTag(data: Partial<CharacterTagSerializedInterface>): Promise<CharacterTagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_CHARACTER_TAG, data);
  },
  createCollection(data: Partial<CollectionSerializedInterface>): Promise<CollectionSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_COLLECTION, data);
  },
  createCollectionName(data: Partial<CollectionNameSerializedInterface>): Promise<CollectionNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_COLLECTION_NAME, data);
  },
  createCollectionPart(data: Partial<CollectionPartSerializedInterface>): Promise<CollectionPartSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_COLLECTION_PART, data);
  },
  createCopy(data: Partial<CopySerializedInterface>): Promise<CopySerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_COPY, data);
  },
  createInteractionTag(data: Partial<InteractionTagSerializedInterface>): Promise<InteractionTagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_INTERACTION_TAG, data);
  },
  createSite(data: Partial<SiteSerializedInterface>): Promise<SiteSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_SITE, data);
  },
  createSiteName(data: Partial<SiteNameSerializedInterface>): Promise<SiteNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_SITE_NAME, data);
  },
  createSource(data: Partial<SourceSerializedInterface>): Promise<SourceSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_SOURCE, data);
  },
  createTag(data: Partial<TagSerializedInterface>): Promise<TagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_TAG, data);
  },
  createTagName(data: Partial<TagNameSerializedInterface>): Promise<TagNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_TAG_NAME, data);
  },
  createTransformation(data: Partial<TransformationSerializedInterface>): Promise<TransformationSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_TRANSFORMATION, data);
  },
  createTransformationType(
    data: Partial<TransformationTypeSerializedInterface>,
  ): Promise<TransformationTypeSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE, data);
  },
  createTransformationTypeName(
    data: Partial<TransformationTypeNameSerializedInterface>,
  ): Promise<TransformationTypeNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE_NAME, data);
  },
  createWorkAuthor(data: Partial<WorkAuthorSerializedInterface>): Promise<WorkAuthorSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORK_AUTHOR, data);
  },
  createWorkCharacter(data: Partial<WorkCharacterSerializedInterface>): Promise<WorkCharacterSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORK_CHARACTER, data);
  },
  createWorkCharacterName(
    data: Partial<WorkCharacterNameSerializedInterface>,
  ): Promise<WorkCharacterNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORK_CHARACTER_NAME, data);
  },
  createWork(data: Partial<WorkSerializedInterface>): Promise<WorkSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORK, data);
  },
  createWorkName(data: Partial<WorkNameSerializedInterface>): Promise<WorkNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORK_NAME, data);
  },
  createWorkTag(data: Partial<WorkTagSerializedInterface>): Promise<WorkTagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORK_TAG, data);
  },
  createWorld(data: Partial<WorldSerializedInterface>): Promise<WorldSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORLD, data);
  },
  createWorldName(data: Partial<WorldNameSerializedInterface>): Promise<WorldNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORLD_NAME, data);
  },
  createWorldCharacter(data: Partial<WorldCharacterSerializedInterface>): Promise<WorldCharacterSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORLD_CHARACTER, data);
  },
  createWorldCharacterName(
    data: Partial<WorldCharacterNameSerializedInterface>,
  ): Promise<WorldCharacterNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_CREATE_WORLD_CHARACTER_NAME, data);
  },

  readAuthor(id: number): Promise<AuthorSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_AUTHOR, id);
  },
  readAuthorName(id: number): Promise<AuthorNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_AUTHOR_NAME, id);
  },
  readAuthorRole(id: number): Promise<AuthorRoleSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_AUTHOR_ROLE, id);
  },
  readAuthorRoleName(id: number): Promise<AuthorRoleNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_AUTHOR_ROLE_NAME, id);
  },
  readCharacterTag(id: number): Promise<CharacterTagSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_CHARACTER_TAG, id);
  },
  readCollection(id: number): Promise<CollectionSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_COLLECTION, id);
  },
  readCollectionName(id: number): Promise<CollectionNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_COLLECTION_NAME, id);
  },
  readCollectionPart(id: number): Promise<CollectionPartSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_COLLECTION_PART, id);
  },
  readCopy(id: number): Promise<CopySerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_COPY, id);
  },
  readInteractionTag(id: number): Promise<InteractionTagSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_INTERACTION_TAG, id);
  },
  readLanguage(code: string): Promise<LanguageSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_LANGUAGE, code);
  },
  readSite(id: number): Promise<SiteSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_SITE, id);
  },
  readSiteName(id: number): Promise<SiteNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_SITE_NAME, id);
  },
  readSource(id: number): Promise<SourceSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_SOURCE, id);
  },
  readTag(id: number): Promise<TagSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_TAG, id);
  },
  readTagName(id: number): Promise<TagNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_TAG_NAME, id);
  },
  readTransformation(id: number): Promise<TransformationSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_TRANSFORMATION, id);
  },
  readTransformationType(id: number): Promise<TransformationTypeSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_TRANSFORMATION_TYPE, id);
  },
  readTransformationTypeName(id: number): Promise<TransformationTypeNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_TRANSFORMATION_TYPE_NAME, id);
  },
  readWorkAuthor(id: number): Promise<WorkAuthorSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORK_AUTHOR, id);
  },
  readWorkCharacter(id: number): Promise<WorkCharacterSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORK_CHARACTER, id);
  },
  readWorkCharacterName(id: number): Promise<WorkCharacterNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORK_CHARACTER_NAME, id);
  },
  readWork(id: number): Promise<WorkSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORK, id);
  },
  readWorkName(id: number): Promise<WorkNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORK_NAME, id);
  },
  readWorkTag(id: number): Promise<WorkTagSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORK_TAG, id);
  },
  readWorld(id: number): Promise<WorldSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORLD, id);
  },
  readWorldName(id: number): Promise<WorldNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORLD_NAME, id);
  },
  readWorldCharacter(id: number): Promise<WorldCharacterSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORLD_CHARACTER, id);
  },
  readWorldCharacterName(id: number): Promise<WorldCharacterNameSerializedInterface> {
    return readCollected(IpcChannel.ENTITY_READ_WORLD_CHARACTER_NAME, id);
  },

  updateAuthor(id: number, partial: Partial<AuthorSerializedInterface>): Promise<AuthorSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_AUTHOR, { id, partial });
  },
  updateAuthorName(
    id: number,
    partial: Partial<AuthorNameSerializedInterface>,
  ): Promise<AuthorNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_AUTHOR_NAME, { id, partial });
  },
  updateAuthorRole(
    id: number,
    partial: Partial<AuthorRoleSerializedInterface>,
  ): Promise<AuthorRoleSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_AUTHOR_ROLE, { id, partial });
  },
  updateAuthorRoleName(
    id: number,
    partial: Partial<AuthorRoleNameSerializedInterface>,
  ): Promise<AuthorRoleNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_AUTHOR_ROLE_NAME, { id, partial });
  },
  updateCharacterTag(
    id: number,
    partial: Partial<CharacterTagSerializedInterface>,
  ): Promise<CharacterTagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_CHARACTER_TAG, { id, partial });
  },
  updateCollection(
    id: number,
    partial: Partial<CollectionSerializedInterface>,
  ): Promise<CollectionSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_COLLECTION, { id, partial });
  },
  updateCollectionName(
    id: number,
    partial: Partial<CollectionNameSerializedInterface>,
  ): Promise<CollectionNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_COLLECTION_NAME, { id, partial });
  },
  updateCollectionPart(
    id: number,
    partial: Partial<CollectionPartSerializedInterface>,
  ): Promise<CollectionPartSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_COLLECTION_PART, { id, partial });
  },
  updateCopy(id: number, partial: Partial<CopySerializedInterface>): Promise<CopySerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_COPY, { id, partial });
  },
  updateInteractionTag(
    id: number,
    partial: Partial<InteractionTagSerializedInterface>,
  ): Promise<InteractionTagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_INTERACTION_TAG, { id, partial });
  },
  updateSite(id: number, partial: Partial<SiteSerializedInterface>): Promise<SiteSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_SITE, { id, partial });
  },
  updateSiteName(id: number, partial: Partial<SiteNameSerializedInterface>): Promise<SiteNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_SITE_NAME, { id, partial });
  },
  updateSource(id: number, partial: Partial<SourceSerializedInterface>): Promise<SourceSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_SOURCE, { id, partial });
  },
  updateTag(id: number, partial: Partial<TagSerializedInterface>): Promise<TagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_TAG, { id, partial });
  },
  updateTagName(id: number, partial: Partial<TagNameSerializedInterface>): Promise<TagNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_TAG_NAME, { id, partial });
  },
  updateTransformation(
    id: number,
    partial: Partial<TransformationSerializedInterface>,
  ): Promise<TransformationSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_TRANSFORMATION, { id, partial });
  },
  updateTransformationType(
    id: number,
    partial: Partial<TransformationTypeSerializedInterface>,
  ): Promise<TransformationTypeSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_TRANSFORMATION_TYPE, { id, partial });
  },
  updateTransformationTypeName(
    id: number,
    partial: Partial<TransformationTypeNameSerializedInterface>,
  ): Promise<TransformationTypeNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_TRANSFORMATION_TYPE_NAME, { id, partial });
  },
  updateWorkAuthor(
    id: number,
    partial: Partial<WorkAuthorSerializedInterface>,
  ): Promise<WorkAuthorSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORK_AUTHOR, { id, partial });
  },
  updateWorkCharacter(
    id: number,
    partial: Partial<WorkCharacterSerializedInterface>,
  ): Promise<WorkCharacterSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORK_CHARACTER, { id, partial });
  },
  updateWorkCharacterName(
    id: number,
    partial: Partial<WorkCharacterNameSerializedInterface>,
  ): Promise<WorkCharacterNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORK_CHARACTER_NAME, { id, partial });
  },
  updateWork(id: number, partial: Partial<WorkSerializedInterface>): Promise<WorkSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORK, { id, partial });
  },
  updateWorkName(id: number, partial: Partial<WorkNameSerializedInterface>): Promise<WorkNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORK_NAME, { id, partial });
  },
  updateWorkTag(id: number, partial: Partial<WorkTagSerializedInterface>): Promise<WorkTagSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORK_TAG, { id, partial });
  },
  updateWorld(id: number, partial: Partial<WorldSerializedInterface>): Promise<WorldSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORLD, { id, partial });
  },
  updateWorldName(id: number, partial: Partial<WorldNameSerializedInterface>): Promise<WorldNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORLD_NAME, { id, partial });
  },
  updateWorldCharacter(
    id: number,
    partial: Partial<WorldCharacterSerializedInterface>,
  ): Promise<WorldCharacterSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORLD_CHARACTER, { id, partial });
  },
  updateWorldCharacterName(
    id: number,
    partial: Partial<WorldCharacterNameSerializedInterface>,
  ): Promise<WorldCharacterNameSerializedInterface> {
    return ipcClient.ask(IpcChannel.ENTITY_UPDATE_WORLD_CHARACTER_NAME, { id, partial });
  },

  deleteAuthor(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_AUTHOR, id);
  },
  deleteAuthorName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_AUTHOR_NAME, id);
  },
  deleteAuthorRole(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_AUTHOR_ROLE, id);
  },
  deleteAuthorRoleName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_AUTHOR_ROLE_NAME, id);
  },
  deleteCharacterTag(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_CHARACTER_TAG, id);
  },
  deleteCollection(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_COLLECTION, id);
  },
  deleteCollectionName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_COLLECTION_NAME, id);
  },
  deleteCollectionPart(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_COLLECTION_PART, id);
  },
  deleteCopy(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_COPY, id);
  },
  deleteInteractionTag(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_INTERACTION_TAG, id);
  },
  deleteSite(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_SITE, id);
  },
  deleteSiteName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_SITE_NAME, id);
  },
  deleteSource(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_SOURCE, id);
  },
  deleteTag(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_TAG, id);
  },
  deleteTagName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_TAG_NAME, id);
  },
  deleteTransformation(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_TRANSFORMATION, id);
  },
  deleteTransformationType(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_TRANSFORMATION_TYPE, id);
  },
  deleteTransformationTypeName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_TRANSFORMATION_TYPE_NAME, id);
  },
  deleteWorkAuthor(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORK_AUTHOR, id);
  },
  deleteWorkCharacter(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORK_CHARACTER, id);
  },
  deleteWorkCharacterName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORK_CHARACTER_NAME, id);
  },
  deleteWork(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORK, id);
  },
  deleteWorkName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORK_NAME, id);
  },
  deleteWorkTag(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORK_TAG, id);
  },
  deleteWorld(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORLD, id);
  },
  deleteWorldName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORLD_NAME, id);
  },
  deleteWorldCharacter(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORLD_CHARACTER, id);
  },
  deleteWorldCharacterName(id: number): Promise<void> {
    return ipcClient.ask(IpcChannel.ENTITY_DELETE_WORLD_CHARACTER_NAME, id);
  },
};