@d19n/youfibre-odin-sdk 1.0.21 → 1.0.22

package/dist/db-sdk-v1/ContactIdentityDb.js

@@ -113,6 +113,39 @@ class ContactIdentityDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getContactIdentitys(contactIdentityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, contactIdentityId, 'ContactIdentity');
+        });
+    }
+    linkContactIdentityContactIdentitys(contactIdentityId, contactIdentityIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of contactIdentityIds) {
+                associationDtos.push({
+                    entity: 'CrmModule:ContactIdentity',
+                    recordId: param.id,
+                    linkType: 'ContactIdentity__ContactIdentity',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, contactIdentityId, associationDtos);
+        });
+    }
+    unlinkContactIdentityContactIdentitys(contactIdentityId, linkedContactIdentityIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedContactIdentityIds) {
+                associationDtos.push({
+                    primaryKey: contactIdentityId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, contactIdentityId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getContacts(contactIdentityId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, contactIdentityId, 'Contact');

package/dist/db-sdk-v1/InvoiceItemDb.d.ts

@@ -24,4 +24,11 @@ export declare class InvoiceItemDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkInvoiceInvoiceItems(invoiceItemId: string, linkedInvoiceIds: string[]): Promise<any>;
+    getInvoiceItems(invoiceItemId: string): Promise<any>;
+    linkInvoiceItemInvoiceItems(invoiceItemId: string, invoiceItemIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkInvoiceItemInvoiceItems(invoiceItemId: string, linkedInvoiceItemIds: string[]): Promise<any>;
 }

package/dist/db-sdk-v1/InvoiceItemDb.js

@@ -112,5 +112,38 @@ class InvoiceItemDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getInvoiceItems(invoiceItemId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, invoiceItemId, 'InvoiceItem');
+        });
+    }
+    linkInvoiceItemInvoiceItems(invoiceItemId, invoiceItemIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of invoiceItemIds) {
+                associationDtos.push({
+                    entity: 'BillingModule:InvoiceItem',
+                    recordId: param.id,
+                    linkType: 'InvoiceItem__InvoiceItem',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
+        });
+    }
+    unlinkInvoiceItemInvoiceItems(invoiceItemId, linkedInvoiceItemIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedInvoiceItemIds) {
+                associationDtos.push({
+                    primaryKey: invoiceItemId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
+        });
+    }
 }
 exports.InvoiceItemDb = InvoiceItemDb;

package/dist/db-sdk-v1/MilestoneDb.d.ts

@@ -31,6 +31,13 @@ export declare class MilestoneDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkMilestoneTasks(milestoneId: string, linkedTaskIds: string[]): Promise<any>;
+    getMilestones(milestoneId: string): Promise<any>;
+    linkMilestoneMilestones(milestoneId: string, milestoneIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkMilestoneMilestones(milestoneId: string, linkedMilestoneIds: string[]): Promise<any>;
     getNotes(milestoneId: string): Promise<any>;
     linkMilestoneNotes(milestoneId: string, noteIds: {
         id: string;

package/dist/db-sdk-v1/MilestoneDb.js

@@ -146,6 +146,39 @@ class MilestoneDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getMilestones(milestoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, milestoneId, 'Milestone');
+        });
+    }
+    linkMilestoneMilestones(milestoneId, milestoneIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of milestoneIds) {
+                associationDtos.push({
+                    entity: 'ProjectModule:Milestone',
+                    recordId: param.id,
+                    linkType: 'Milestone__Milestone',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, milestoneId, associationDtos);
+        });
+    }
+    unlinkMilestoneMilestones(milestoneId, linkedMilestoneIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedMilestoneIds) {
+                associationDtos.push({
+                    primaryKey: milestoneId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, milestoneId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getNotes(milestoneId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, milestoneId, 'Note');

package/dist/db-sdk-v1/NoteDb.d.ts

@@ -346,6 +346,13 @@ export declare class NoteDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkSmsMessageNotes(noteId: string, linkedSmsMessageIds: string[]): Promise<any>;
+    getNotes(noteId: string): Promise<any>;
+    linkNoteNotes(noteId: string, noteIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkNoteNotes(noteId: string, linkedNoteIds: string[]): Promise<any>;
     linkNoteFiles(noteId: string, fileIds: {
         id: string;
         relationType?: RelationTypeEnum;

package/dist/db-sdk-v1/NoteDb.js

@@ -1630,6 +1630,39 @@ class NoteDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getNotes(noteId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, noteId, 'Note');
+        });
+    }
+    linkNoteNotes(noteId, noteIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of noteIds) {
+                associationDtos.push({
+                    entity: 'SupportModule:Note',
+                    recordId: param.id,
+                    linkType: 'Note__Note',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+        });
+    }
+    unlinkNoteNotes(noteId, linkedNoteIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedNoteIds) {
+                associationDtos.push({
+                    primaryKey: noteId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+        });
+    }
     linkNoteFiles(noteId, fileIds) {
         return __awaiter(this, void 0, void 0, function* () {
             const associationDtos = [];

package/dist/db-sdk-v1/OfferDb.d.ts

@@ -38,6 +38,13 @@ export declare class OfferDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkOrderItemOffers(offerId: string, linkedOrderItemIds: string[]): Promise<any>;
+    getOffers(offerId: string): Promise<any>;
+    linkOfferOffers(offerId: string, offerIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkOfferOffers(offerId: string, linkedOfferIds: string[]): Promise<any>;
     getDiscounts(offerId: string): Promise<any>;
     linkOfferDiscounts(offerId: string, discountIds: {
         id: string;

package/dist/db-sdk-v1/OfferDb.js

@@ -179,6 +179,39 @@ class OfferDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getOffers(offerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, offerId, 'Offer');
+        });
+    }
+    linkOfferOffers(offerId, offerIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of offerIds) {
+                associationDtos.push({
+                    entity: 'ProductModule:Offer',
+                    recordId: param.id,
+                    linkType: 'Offer__Offer',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, offerId, associationDtos);
+        });
+    }
+    unlinkOfferOffers(offerId, linkedOfferIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedOfferIds) {
+                associationDtos.push({
+                    primaryKey: offerId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, offerId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getDiscounts(offerId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, offerId, 'Discount');

package/dist/db-sdk-v1/OrderDb.d.ts

@@ -116,6 +116,13 @@ export declare class OrderDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkOrderActivitys(orderId: string, linkedActivityIds: string[]): Promise<any>;
+    getOrders(orderId: string): Promise<any>;
+    linkOrderOrders(orderId: string, orderIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkOrderOrders(orderId: string, linkedOrderIds: string[]): Promise<any>;
     getPicRequests(orderId: string): Promise<any>;
     linkPicRequestOrders(orderId: string, picRequestIds: {
         id: string;

package/dist/db-sdk-v1/OrderDb.js

@@ -547,6 +547,39 @@ class OrderDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getOrders(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, orderId, 'Order');
+        });
+    }
+    linkOrderOrders(orderId, orderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of orderIds) {
+                associationDtos.push({
+                    entity: 'OrderModule:Order',
+                    recordId: param.id,
+                    linkType: 'Order__Order',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, orderId, associationDtos);
+        });
+    }
+    unlinkOrderOrders(orderId, linkedOrderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedOrderIds) {
+                associationDtos.push({
+                    primaryKey: orderId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, orderId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getPicRequests(orderId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, orderId, 'PICRequest');

package/dist/db-sdk-v1/OrderItemDb.d.ts

@@ -101,6 +101,13 @@ export declare class OrderItemDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkOrderItemActivitys(orderItemId: string, linkedActivityIds: string[]): Promise<any>;
+    getOrderItems(orderItemId: string): Promise<any>;
+    linkOrderItemOrderItems(orderItemId: string, orderItemIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkOrderItemOrderItems(orderItemId: string, linkedOrderItemIds: string[]): Promise<any>;
     getVoiceConfigurations(orderItemId: string): Promise<any>;
     linkOrderItemVoiceConfigurations(orderItemId: string, voiceConfigurationIds: {
         id: string;

package/dist/db-sdk-v1/OrderItemDb.js

@@ -476,6 +476,39 @@ class OrderItemDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getOrderItems(orderItemId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, orderItemId, 'OrderItem');
+        });
+    }
+    linkOrderItemOrderItems(orderItemId, orderItemIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of orderItemIds) {
+                associationDtos.push({
+                    entity: 'OrderModule:OrderItem',
+                    recordId: param.id,
+                    linkType: 'OrderItem__OrderItem',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, orderItemId, associationDtos);
+        });
+    }
+    unlinkOrderItemOrderItems(orderItemId, linkedOrderItemIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedOrderItemIds) {
+                associationDtos.push({
+                    primaryKey: orderItemId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, orderItemId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getVoiceConfigurations(orderItemId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, orderItemId, 'VoiceConfiguration');

package/dist/db-sdk-v1/OrganizationDb.d.ts

@@ -38,4 +38,11 @@ export declare class OrganizationDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkLeadOrganizations(organizationId: string, linkedLeadIds: string[]): Promise<any>;
+    getOrganizations(organizationId: string): Promise<any>;
+    linkOrganizationOrganizations(organizationId: string, organizationIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkOrganizationOrganizations(organizationId: string, linkedOrganizationIds: string[]): Promise<any>;
 }

package/dist/db-sdk-v1/OrganizationDb.js

@@ -178,5 +178,38 @@ class OrganizationDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, organizationId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getOrganizations(organizationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, organizationId, 'Organization');
+        });
+    }
+    linkOrganizationOrganizations(organizationId, organizationIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of organizationIds) {
+                associationDtos.push({
+                    entity: 'CrmModule:Organization',
+                    recordId: param.id,
+                    linkType: 'Organization__Organization',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, organizationId, associationDtos);
+        });
+    }
+    unlinkOrganizationOrganizations(organizationId, linkedOrganizationIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedOrganizationIds) {
+                associationDtos.push({
+                    primaryKey: organizationId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, organizationId, associationDtos);
+        });
+    }
 }
 exports.OrganizationDb = OrganizationDb;

package/dist/db-sdk-v1/ProductComponentDb.d.ts

@@ -31,4 +31,11 @@ export declare class ProductComponentDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkProductProductComponents(productComponentId: string, linkedProductIds: string[]): Promise<any>;
+    getProductComponents(productComponentId: string): Promise<any>;
+    linkProductComponentProductComponents(productComponentId: string, productComponentIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkProductComponentProductComponents(productComponentId: string, linkedProductComponentIds: string[]): Promise<any>;
 }

package/dist/db-sdk-v1/ProductComponentDb.js

@@ -145,5 +145,38 @@ class ProductComponentDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, productComponentId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getProductComponents(productComponentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, productComponentId, 'ProductComponent');
+        });
+    }
+    linkProductComponentProductComponents(productComponentId, productComponentIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of productComponentIds) {
+                associationDtos.push({
+                    entity: 'ProductModule:ProductComponent',
+                    recordId: param.id,
+                    linkType: 'ProductComponent__ProductComponent',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, productComponentId, associationDtos);
+        });
+    }
+    unlinkProductComponentProductComponents(productComponentId, linkedProductComponentIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedProductComponentIds) {
+                associationDtos.push({
+                    primaryKey: productComponentId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, productComponentId, associationDtos);
+        });
+    }
 }
 exports.ProductComponentDb = ProductComponentDb;

package/dist/db-sdk-v1/ProductDb.d.ts

@@ -1,6 +1,6 @@
 import { DbProvider } from '@d19n/odin-sdk-generator/dist/db.provider';
 import { OdinSearchV2 } from '@d19n/odin-types/dist/interfaces/v2.db.interfaces';
-import { OdinRecordCreateDto, OdinRecordUpdateDto, RelationTypeEnum } from '@d19n/odin-types/dist/dtos/odin.dtos';
+import { OdinRecordCreateDto, OdinRecordUpdateDto, OdinLinkedRecordUpdateDto, RelationTypeEnum } from '@d19n/odin-types/dist/dtos/odin.dtos';
 export declare class ProductDb extends DbProvider {
     protected readonly principal: any;
     protected readonly dbService: any;
@@ -80,4 +80,12 @@ export declare class ProductDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkOrderItemProducts(productId: string, linkedOrderItemIds: string[]): Promise<any>;
+    getProducts(productId: string): Promise<any>;
+    linkProductProducts(productId: string, productIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkProductProducts(productId: string, linkedProductIds: string[]): Promise<any>;
+    updateProductProductLinkProperties(productId: string, dbRecordAssociationId: string, updateDto: OdinLinkedRecordUpdateDto): Promise<any>;
 }

package/dist/db-sdk-v1/ProductDb.js

@@ -376,5 +376,43 @@ class ProductDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, productId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getProducts(productId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, productId, 'Product');
+        });
+    }
+    linkProductProducts(productId, productIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of productIds) {
+                associationDtos.push({
+                    entity: 'ProductModule:Product',
+                    recordId: param.id,
+                    linkType: 'Product__Product',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, productId, associationDtos);
+        });
+    }
+    unlinkProductProducts(productId, linkedProductIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedProductIds) {
+                associationDtos.push({
+                    primaryKey: productId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, productId, associationDtos);
+        });
+    }
+    updateProductProductLinkProperties(productId, dbRecordAssociationId, updateDto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._updateLinkProperties('ProductModule', 'Product', productId, dbRecordAssociationId, updateDto);
+        });
+    }
 }
 exports.ProductDb = ProductDb;

package/dist/db-sdk-v1/RestrictionDb.d.ts

@@ -31,4 +31,11 @@ export declare class RestrictionDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkProductComponentRestrictions(restrictionId: string, linkedProductComponentIds: string[]): Promise<any>;
+    getRestrictions(restrictionId: string): Promise<any>;
+    linkRestrictionRestrictions(restrictionId: string, restrictionIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkRestrictionRestrictions(restrictionId: string, linkedRestrictionIds: string[]): Promise<any>;
 }

package/dist/db-sdk-v1/RestrictionDb.js

@@ -145,5 +145,38 @@ class RestrictionDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, restrictionId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getRestrictions(restrictionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, restrictionId, 'Restriction');
+        });
+    }
+    linkRestrictionRestrictions(restrictionId, restrictionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of restrictionIds) {
+                associationDtos.push({
+                    entity: 'ProductModule:Restriction',
+                    recordId: param.id,
+                    linkType: 'Restriction__Restriction',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, restrictionId, associationDtos);
+        });
+    }
+    unlinkRestrictionRestrictions(restrictionId, linkedRestrictionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedRestrictionIds) {
+                associationDtos.push({
+                    primaryKey: restrictionId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, restrictionId, associationDtos);
+        });
+    }
 }
 exports.RestrictionDb = RestrictionDb;

package/dist/db-sdk-v1/ServiceDb.d.ts

@@ -24,4 +24,11 @@ export declare class ServiceDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkProductServices(serviceId: string, linkedProductIds: string[]): Promise<any>;
+    getServices(serviceId: string): Promise<any>;
+    linkServiceServices(serviceId: string, serviceIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkServiceServices(serviceId: string, linkedServiceIds: string[]): Promise<any>;
 }

package/dist/db-sdk-v1/ServiceDb.js

@@ -112,5 +112,38 @@ class ServiceDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, serviceId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getServices(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, serviceId, 'Service');
+        });
+    }
+    linkServiceServices(serviceId, serviceIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of serviceIds) {
+                associationDtos.push({
+                    entity: 'ServiceModule:Service',
+                    recordId: param.id,
+                    linkType: 'Service__Service',
+                    relationType: param === null || param === void 0 ? void 0 : param.relationType,
+                    relatedAssociationId: param === null || param === void 0 ? void 0 : param.relatedAssociationId
+                });
+            }
+            return yield this._createLinks(this.moduleName, this.entityName, serviceId, associationDtos);
+        });
+    }
+    unlinkServiceServices(serviceId, linkedServiceIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedServiceIds) {
+                associationDtos.push({
+                    primaryKey: serviceId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, serviceId, associationDtos);
+        });
+    }
 }
 exports.ServiceDb = ServiceDb;