podverse-orm 5.0.0-beta.1 → 5.0.0-beta.3

package/dist/src/services/item/itemFunding.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemFundingService = void 0;
+const itemFunding_1 = require("@/entities/item/itemFunding");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemFundingService extends baseManyService_1.BaseManyService {
+    constructor() {
+        super(itemFunding_1.ItemFunding, 'item');
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemFundingService = ItemFundingService;

package/dist/src/services/item/itemImage.d.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemImage } from '@/entities/item/itemImage';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemImageDto = {
+    url: string;
+    image_width_size: number | null;
+};
+export declare class ItemImageService extends BaseManyService<ItemImage, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemImageDto): Promise<ItemImage>;
+    updateMany(item: Item, dtos: ItemImageDto[]): Promise<ItemImage[]>;
+}
+export {};

package/dist/src/services/item/itemImage.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemImageService = void 0;
+const itemImage_1 = require("@/entities/item/itemImage");
+const filterImageDtosByHighestWidth_1 = require("@/lib/filterImageDtosByHighestWidth");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemImageService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemImage_1.ItemImage, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: adding image shrinking if an image < 500px is not found
+            const filteredDtos = (0, filterImageDtosByHighestWidth_1.filterDtosByHighestWidth)(dtos);
+            const whereKeys = ['url'];
+            return _super._updateMany.call(this, item, whereKeys, filteredDtos);
+        });
+    }
+}
+exports.ItemImageService = ItemImageService;

package/dist/src/services/item/itemLicense.d.ts

@@ -0,0 +1,13 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemLicense } from '@/entities/item/itemLicense';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemLicenseDto = {
+    identifier: string;
+    url: string | null;
+};
+export declare class ItemLicenseService extends BaseOneService<ItemLicense, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemLicenseDto): Promise<ItemLicense>;
+}
+export {};

package/dist/src/services/item/itemLicense.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemLicenseService = void 0;
+const itemLicense_1 = require("@/entities/item/itemLicense");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemLicenseService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemLicense_1.ItemLicense, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto);
+        });
+    }
+}
+exports.ItemLicenseService = ItemLicenseService;

package/dist/src/services/item/itemLocation.d.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemLocation } from '@/entities/item/itemLocation';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemLocationDto = {
+    geo: string | null;
+    osm: string | null;
+    name: string | null;
+};
+export declare class ItemLocationService extends BaseOneService<ItemLocation, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemLocationDto): Promise<ItemLocation>;
+}
+export {};

package/dist/src/services/item/itemLocation.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemLocationService = void 0;
+const itemLocation_1 = require("@/entities/item/itemLocation");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemLocationService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemLocation_1.ItemLocation, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto);
+        });
+    }
+}
+exports.ItemLocationService = ItemLocationService;

package/dist/src/services/item/itemPerson.d.ts

@@ -0,0 +1,17 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemPerson } from '@/entities/item/itemPerson';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemPersonDto = {
+    name: string;
+    role: string | null;
+    person_group: string | 'cast';
+    img: string | null;
+    href: string | null;
+};
+export declare class ItemPersonService extends BaseManyService<ItemPerson, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemPersonDto): Promise<ItemPerson>;
+    updateMany(item: Item, dtos: ItemPersonDto[]): Promise<ItemPerson[]>;
+}
+export {};

package/dist/src/services/item/itemPerson.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemPersonService = void 0;
+const itemPerson_1 = require("@/entities/item/itemPerson");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemPersonService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemPerson_1.ItemPerson, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['name'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['name'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemPersonService = ItemPersonService;

package/dist/src/services/item/itemSeason.d.ts

@@ -0,0 +1,13 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemSeason } from '@/entities/item/itemSeason';
+import { BaseOneService } from '../base/baseOneService';
+import { ChannelSeason } from '@/entities/channel/channelSeason';
+export type ItemSeasonDto = {
+    title: string | null;
+    channel_season: ChannelSeason;
+};
+export declare class ItemSeasonService extends BaseOneService<ItemSeason, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemSeasonDto): Promise<ItemSeason>;
+}

package/dist/src/services/item/itemSeason.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemSeasonService = void 0;
+const itemSeason_1 = require("@/entities/item/itemSeason");
+const baseOneService_1 = require("../base/baseOneService");
+class ItemSeasonService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemSeason_1.ItemSeason, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto, { relations: ['channel_season'] });
+        });
+    }
+}
+exports.ItemSeasonService = ItemSeasonService;

package/dist/src/services/item/itemSeasonEpisode.d.ts

@@ -0,0 +1,13 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemSeasonEpisode } from '@/entities/item/itemSeasonEpisode';
+import { BaseOneService } from '../base/baseOneService';
+type ItemSeasonEpisodeDto = {
+    display: string | null;
+    episode: number;
+};
+export declare class ItemSeasonEpisodeService extends BaseOneService<ItemSeasonEpisode, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemSeasonEpisodeDto): Promise<ItemSeasonEpisode>;
+}
+export {};

package/dist/src/services/item/itemSeasonEpisode.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemSeasonEpisodeService = void 0;
+const itemSeasonEpisode_1 = require("@/entities/item/itemSeasonEpisode");
+const baseOneService_1 = require("../base/baseOneService");
+class ItemSeasonEpisodeService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemSeasonEpisode_1.ItemSeasonEpisode, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto);
+        });
+    }
+}
+exports.ItemSeasonEpisodeService = ItemSeasonEpisodeService;

package/dist/src/services/item/itemSocialInteract.d.ts

@@ -0,0 +1,17 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemSocialInteract } from '@/entities/item/itemSocialInteract';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemSocialInteractDto = {
+    protocol: string;
+    uri: string;
+    account_id: string | null;
+    account_url: string | null;
+    priority: number | null;
+};
+export declare class ItemSocialInteractService extends BaseManyService<ItemSocialInteract, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemSocialInteractDto): Promise<ItemSocialInteract>;
+    updateMany(item: Item, dtos: ItemSocialInteractDto[]): Promise<ItemSocialInteract[]>;
+}
+export {};

package/dist/src/services/item/itemSocialInteract.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemSocialInteractService = void 0;
+const itemSocialInteract_1 = require("@/entities/item/itemSocialInteract");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemSocialInteractService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemSocialInteract_1.ItemSocialInteract, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['uri'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['uri'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemSocialInteractService = ItemSocialInteractService;

package/dist/src/services/item/itemSoundbite.d.ts

@@ -0,0 +1,16 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemSoundbite } from '@/entities/item/itemSoundbite';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemSoundbiteDto = {
+    start_time: string;
+    duration: string;
+    title: string | null;
+};
+export declare class ItemSoundbiteService extends BaseManyService<ItemSoundbite, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    _getByIdText(id_text: string): Promise<ItemSoundbite | null>;
+    update(item: Item, dto: ItemSoundbiteDto): Promise<ItemSoundbite>;
+    updateMany(item: Item, dtos: ItemSoundbiteDto[]): Promise<ItemSoundbite[]>;
+}
+export {};

package/dist/src/services/item/itemSoundbite.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemSoundbiteService = void 0;
+const itemSoundbite_1 = require("@/entities/item/itemSoundbite");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemSoundbiteService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemSoundbite_1.ItemSoundbite, 'item', transactionalEntityManager);
+    }
+    _getByIdText(id_text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.findOne({ where: { id_text } });
+        });
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['start_time', 'duration'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['start_time', 'duration'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemSoundbiteService = ItemSoundbiteService;

package/dist/src/services/item/itemTranscript.d.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemTranscript } from '@/entities/item/itemTranscript';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemTranscriptDto = {
+    url: string;
+    title?: string | null;
+};
+export declare class ItemTranscriptService extends BaseManyService<ItemTranscript, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemTranscriptDto): Promise<ItemTranscript>;
+    updateMany(item: Item, dtos: ItemTranscriptDto[]): Promise<ItemTranscript[]>;
+}
+export {};

package/dist/src/services/item/itemTranscript.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemTranscriptService = void 0;
+const itemTranscript_1 = require("@/entities/item/itemTranscript");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemTranscriptService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemTranscript_1.ItemTranscript, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['url'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemTranscriptService = ItemTranscriptService;

package/dist/src/services/item/itemTxt.d.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemTxt } from '@/entities/item/itemTxt';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemTxtDto = {
+    purpose: string | null;
+    value: string;
+};
+export declare class ItemTxtService extends BaseManyService<ItemTxt, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(channel: Item, dto: ItemTxtDto): Promise<ItemTxt>;
+    updateMany(channel: Item, dtos: ItemTxtDto[]): Promise<ItemTxt[]>;
+}
+export {};

package/dist/src/services/item/itemTxt.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemTxtService = void 0;
+const itemTxt_1 = require("@/entities/item/itemTxt");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemTxtService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemTxt_1.ItemTxt, 'item', transactionalEntityManager);
+    }
+    update(channel, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['value'];
+            return _super._update.call(this, channel, whereKeys, dto);
+        });
+    }
+    updateMany(channel, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['value'];
+            return _super._updateMany.call(this, channel, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemTxtService = ItemTxtService;

package/dist/src/services/item/itemValue.d.ts

@@ -0,0 +1,15 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '../../entities/item/item';
+import { ItemValue } from '../../entities/item/itemValue';
+import { BaseManyService } from '../base/baseManyService';
+type ItemValueDto = {
+    type: string;
+    method: string;
+    suggested: number | null;
+};
+export declare class ItemValueService extends BaseManyService<ItemValue, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemValueDto): Promise<ItemValue>;
+    updateMany(item: Item, dtos: ItemValueDto[]): Promise<ItemValue[]>;
+}
+export {};

package/dist/src/services/item/itemValue.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemValueService = void 0;
+const itemValue_1 = require("../../entities/item/itemValue");
+const baseManyService_1 = require("../base/baseManyService");
+class ItemValueService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemValue_1.ItemValue, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'method'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'method'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemValueService = ItemValueService;

package/dist/src/services/item/itemValueRecipient.d.ts

@@ -0,0 +1,19 @@
+import { EntityManager } from 'typeorm';
+import { ItemValue } from '@/entities/item/itemValue';
+import { ItemValueRecipient } from '@/entities/item/itemValueRecipient';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemValueRecipientDto = {
+    type: string;
+    address: string;
+    split: number;
+    name: string | null;
+    custom_key: string | null;
+    custom_value: string | null;
+    fee: boolean;
+};
+export declare class ItemValueRecipientService extends BaseManyService<ItemValueRecipient, 'item_value'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item_value: ItemValue, dto: ItemValueRecipientDto): Promise<ItemValueRecipient>;
+    updateMany(item_value: ItemValue, dtos: ItemValueRecipientDto[]): Promise<ItemValueRecipient[]>;
+}
+export {};