@d19n/youfibre-odin-sdk 1.0.21 → 1.0.23

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;

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

@@ -31,6 +31,13 @@ export declare class SplitOrderDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkSplitOrderOrders(splitOrderId: string, linkedOrderIds: string[]): Promise<any>;
+    getSplitOrders(splitOrderId: string): Promise<any>;
+    linkSplitOrderSplitOrders(splitOrderId: string, splitOrderIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkSplitOrderSplitOrders(splitOrderId: string, linkedSplitOrderIds: string[]): Promise<any>;
     linkOrderSplitOrders(splitOrderId: string, orderIds: {
         id: string;
         relationType?: RelationTypeEnum;

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

@@ -145,6 +145,39 @@ class SplitOrderDb extends db_provider_1.DbProvider {
             return yield this._deleteLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
         });
     }
+    // Use this function when you want to return a single record
+    getSplitOrders(splitOrderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, splitOrderId, 'SplitOrder');
+        });
+    }
+    linkSplitOrderSplitOrders(splitOrderId, splitOrderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of splitOrderIds) {
+                associationDtos.push({
+                    entity: 'OrderModule:SplitOrder',
+                    recordId: param.id,
+                    linkType: 'SplitOrder__SplitOrder',
+                    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, splitOrderId, associationDtos);
+        });
+    }
+    unlinkSplitOrderSplitOrders(splitOrderId, linkedSplitOrderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedSplitOrderIds) {
+                associationDtos.push({
+                    primaryKey: splitOrderId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+        });
+    }
     linkOrderSplitOrders(splitOrderId, orderIds) {
         return __awaiter(this, void 0, void 0, function* () {
             const associationDtos = [];

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

@@ -24,6 +24,13 @@ export declare class TransactionDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkTransactionPaymentMethods(transactionId: string, linkedPaymentMethodIds: string[]): Promise<any>;
+    getTransactions(transactionId: string): Promise<any>;
+    linkTransactionTransactions(transactionId: string, transactionIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkTransactionTransactions(transactionId: string, linkedTransactionIds: string[]): Promise<any>;
     getInvoices(transactionId: string): Promise<any>;
     linkInvoiceTransactions(transactionId: string, invoiceIds: {
         id: string;

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

@@ -113,6 +113,39 @@ class TransactionDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getTransactions(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, transactionId, 'Transaction');
+        });
+    }
+    linkTransactionTransactions(transactionId, transactionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of transactionIds) {
+                associationDtos.push({
+                    entity: 'BillingModule:Transaction',
+                    recordId: param.id,
+                    linkType: 'Transaction__Transaction',
+                    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, transactionId, associationDtos);
+        });
+    }
+    unlinkTransactionTransactions(transactionId, linkedTransactionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedTransactionIds) {
+                associationDtos.push({
+                    primaryKey: transactionId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, transactionId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getInvoices(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, transactionId, 'Invoice');

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

@@ -150,6 +150,13 @@ export declare class WorkOrderDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkWorkOrderNetomniaInstallVerifications(workOrderId: string, linkedNetomniaInstallVerificationIds: string[]): Promise<any>;
+    getCustomerDeviceOntRemovals(workOrderId: string): Promise<any>;
+    linkWorkOrderCustomerDeviceOntRemovals(workOrderId: string, customerDeviceOntRemovalIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkWorkOrderCustomerDeviceOntRemovals(workOrderId: string, linkedCustomerDeviceOntRemovalIds: string[]): Promise<any>;
     getYfEquipmentCollections(workOrderId: string): Promise<any>;
     linkWorkOrderYfEquipmentCollections(workOrderId: string, yfEquipmentCollectionIds: {
         id: string;
@@ -241,6 +248,13 @@ export declare class WorkOrderDb extends DbProvider {
         relatedAssociationId?: string;
     }[]): Promise<any>;
     unlinkWorkOrderOhInstallationAudits(workOrderId: string, linkedOhInstallationAuditIds: string[]): Promise<any>;
+    getWorkOrders(workOrderId: string): Promise<any>;
+    linkWorkOrderWorkOrders(workOrderId: string, workOrderIds: {
+        id: string;
+        relationType?: RelationTypeEnum;
+        relatedAssociationId?: string;
+    }[]): Promise<any>;
+    unlinkWorkOrderWorkOrders(workOrderId: string, linkedWorkOrderIds: string[]): Promise<any>;
     getOhAuditOfInstallations(workOrderId: string): Promise<any>;
     linkWorkOrderOhAuditOfInstallations(workOrderId: string, ohAuditOfInstallationIds: {
         id: string;

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

@@ -707,6 +707,39 @@ class WorkOrderDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getCustomerDeviceOntRemovals(workOrderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, workOrderId, 'CustomerDeviceOntRemoval');
+        });
+    }
+    linkWorkOrderCustomerDeviceOntRemovals(workOrderId, customerDeviceOntRemovalIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of customerDeviceOntRemovalIds) {
+                associationDtos.push({
+                    entity: 'ServiceModule:CustomerDeviceOntRemoval',
+                    recordId: param.id,
+                    linkType: 'WorkOrder_CustomerDeviceOntRemoval',
+                    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, workOrderId, associationDtos);
+        });
+    }
+    unlinkWorkOrderCustomerDeviceOntRemovals(workOrderId, linkedCustomerDeviceOntRemovalIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedCustomerDeviceOntRemovalIds) {
+                associationDtos.push({
+                    primaryKey: workOrderId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getYfEquipmentCollections(workOrderId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, workOrderId, 'YfEquipmentCollection');
@@ -1136,6 +1169,39 @@ class WorkOrderDb extends db_provider_1.DbProvider {
         });
     }
     // Use this function when you want to return a single record
+    getWorkOrders(workOrderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getLinks(this.moduleName, this.entityName, workOrderId, 'WorkOrder');
+        });
+    }
+    linkWorkOrderWorkOrders(workOrderId, workOrderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const param of workOrderIds) {
+                associationDtos.push({
+                    entity: 'FieldServiceModule:WorkOrder',
+                    recordId: param.id,
+                    linkType: 'WorkOrder__WorkOrder',
+                    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, workOrderId, associationDtos);
+        });
+    }
+    unlinkWorkOrderWorkOrders(workOrderId, linkedWorkOrderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const associationDtos = [];
+            for (const pk of linkedWorkOrderIds) {
+                associationDtos.push({
+                    primaryKey: workOrderId,
+                    linkedRecordPrimaryKey: pk,
+                });
+            }
+            return yield this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+        });
+    }
+    // Use this function when you want to return a single record
     getOhAuditOfInstallations(workOrderId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhAuditOfInstallation');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d19n/youfibre-odin-sdk",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "",
   "author": "@d19n",
   "license": "UNLICENSED",
@@ -11,7 +11,7 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "@d19n/odin-sdk-generator": "^1.0.57",
+    "@d19n/odin-sdk-generator": "^1.0.59",
     "@d19n/odin-types": "^1.0.10"
   },
   "scripts": {

package/src/api-sdk-v1/BillingRequestApi.ts

@@ -101,6 +101,33 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getBillingRequests(billingRequestId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, billingRequestId, 'BillingRequest');
+    }
+        
+   public async linkBillingRequestBillingRequests(billingRequestId: string, billingRequestIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of billingRequestIds){
+      associationDtos.push({
+          entity: 'BillingModule:BillingRequest',
+          recordId: param.id,
+          linkType: 'BillingRequest__BillingRequest',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, billingRequestId, associationDtos);
+   }
+
+   public async unLinkBillingRequestBillingRequests(billingRequestId: string, linkedBillingRequestId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, billingRequestId, linkedBillingRequestId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getFiles(billingRequestId: string) {
       return await this._getLinks(this.moduleName, this.entityName, billingRequestId, 'File');

package/src/api-sdk-v1/CaseApi.ts

@@ -74,6 +74,33 @@
    }
 
   
+    // Use this function when you want to return a single record
+    public async getCases(caseId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, caseId, 'Case');
+    }
+        
+   public async linkCaseCases(caseId: string, caseIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of caseIds){
+      associationDtos.push({
+          entity: 'SupportModule:Case',
+          recordId: param.id,
+          linkType: 'Case__Case',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, caseId, associationDtos);
+   }
+
+   public async unLinkCaseCases(caseId: string, linkedCaseId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, caseId, linkedCaseId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getFiles(caseId: string) {
       return await this._getLinks(this.moduleName, this.entityName, caseId, 'File');

package/src/api-sdk-v1/ConsumptionRateApi.ts

@@ -101,4 +101,31 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getConsumptionRates(consumptionRateId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, consumptionRateId, 'ConsumptionRate');
+    }
+        
+   public async linkConsumptionRateConsumptionRates(consumptionRateId: string, consumptionRateIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of consumptionRateIds){
+      associationDtos.push({
+          entity: 'ProductModule:ConsumptionRate',
+          recordId: param.id,
+          linkType: 'ConsumptionRate__ConsumptionRate',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, consumptionRateId, associationDtos);
+   }
+
+   public async unLinkConsumptionRateConsumptionRates(consumptionRateId: string, linkedConsumptionRateId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, consumptionRateId, linkedConsumptionRateId);
+   }
+
+      
 }

package/src/api-sdk-v1/ConsumptionScheduleApi.ts

@@ -128,4 +128,31 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getConsumptionSchedules(consumptionScheduleId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, consumptionScheduleId, 'ConsumptionSchedule');
+    }
+        
+   public async linkConsumptionScheduleConsumptionSchedules(consumptionScheduleId: string, consumptionScheduleIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of consumptionScheduleIds){
+      associationDtos.push({
+          entity: 'ProductModule:ConsumptionSchedule',
+          recordId: param.id,
+          linkType: 'ConsumptionSchedule__ConsumptionSchedule',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, consumptionScheduleId, associationDtos);
+   }
+
+   public async unLinkConsumptionScheduleConsumptionSchedules(consumptionScheduleId: string, linkedConsumptionScheduleId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, consumptionScheduleId, linkedConsumptionScheduleId);
+   }
+
+      
 }

package/src/api-sdk-v1/ContactApi.ts

@@ -425,6 +425,33 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getContacts(contactId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, contactId, 'Contact');
+    }
+        
+   public async linkContactContacts(contactId: string, contactIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of contactIds){
+      associationDtos.push({
+          entity: 'CrmModule:Contact',
+          recordId: param.id,
+          linkType: 'Contact__Contact',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+   }
+
+   public async unLinkContactContacts(contactId: string, linkedContactId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, contactId, linkedContactId);
+   }
+
+      
    // Use this function when you want to return a single record
    public async getOneTouchSwitchs(contactId: string) {
      return await this._getLinks(this.moduleName, this.entityName, contactId, 'OneTouchSwitch');

package/src/api-sdk-v1/ContactIdentityApi.ts

@@ -101,6 +101,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getContactIdentitys(contactIdentityId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, contactIdentityId, 'ContactIdentity');
+    }
+        
+   public async linkContactIdentityContactIdentitys(contactIdentityId: string, contactIdentityIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of contactIdentityIds){
+      associationDtos.push({
+          entity: 'CrmModule:ContactIdentity',
+          recordId: param.id,
+          linkType: 'ContactIdentity__ContactIdentity',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, contactIdentityId, associationDtos);
+   }
+
+   public async unLinkContactIdentityContactIdentitys(contactIdentityId: string, linkedContactIdentityId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, contactIdentityId, linkedContactIdentityId);
+   }
+
+      
    // Use this function when you want to return a single record
    public async getContacts(contactIdentityId: string) {
      return await this._getLinks(this.moduleName, this.entityName, contactIdentityId, 'Contact');