@d19n/youfibre-odin-sdk 1.0.21 → 1.0.23

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

@@ -101,6 +101,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getTransactions(transactionId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, transactionId, 'Transaction');
+    }
+        
+   public async linkTransactionTransactions(transactionId: string, transactionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of transactionIds){
+      associationDtos.push({
+          entity: 'BillingModule:Transaction',
+          recordId: param.id,
+          linkType: 'Transaction__Transaction',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, transactionId, associationDtos);
+   }
+
+   public async unLinkTransactionTransactions(transactionId: string, linkedTransactionId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, transactionId, linkedTransactionId);
+   }
+
+      
    // Use this function when you want to return a single record
    public async getInvoices(transactionId: string) {
      return await this._getLinks(this.moduleName, this.entityName, transactionId, 'Invoice');

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

@@ -587,6 +587,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getCustomerDeviceOntRemovals(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'CustomerDeviceOntRemoval');
+    }
+        
+   public async linkWorkOrderCustomerDeviceOntRemovals(workOrderId: string, customerDeviceOntRemovalIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of customerDeviceOntRemovalIds){
+      associationDtos.push({
+          entity: 'ServiceModule:CustomerDeviceOntRemoval',
+          recordId: param.id,
+          linkType: 'WorkOrder_CustomerDeviceOntRemoval',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async unLinkWorkOrderCustomerDeviceOntRemovals(workOrderId: string, linkedCustomerDeviceOntRemovalId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, linkedCustomerDeviceOntRemovalId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getYfEquipmentCollections(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'YfEquipmentCollection');
@@ -938,6 +965,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getWorkOrders(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'WorkOrder');
+    }
+        
+   public async linkWorkOrderWorkOrders(workOrderId: string, workOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of workOrderIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:WorkOrder',
+          recordId: param.id,
+          linkType: 'WorkOrder__WorkOrder',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async unLinkWorkOrderWorkOrders(workOrderId: string, linkedWorkOrderId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, linkedWorkOrderId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getOhAuditOfInstallations(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhAuditOfInstallation');

package/src/db-sdk-v1/BillingRequestDb.ts

@@ -99,6 +99,41 @@
   }
 
       
+    // 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, linkedBillingRequestIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedBillingRequestIds){
+     associationDtos.push({
+        primaryKey: billingRequestId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, billingRequestId, associationDtos);
+   }
+
+      
     // 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/db-sdk-v1/CaseDb.ts

@@ -64,6 +64,41 @@
    }
 
   
+    // 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, linkedCaseIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedCaseIds){
+     associationDtos.push({
+        primaryKey: caseId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, caseId, associationDtos);
+   }
+
+      
     // 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/db-sdk-v1/ConsumptionRateDb.ts

@@ -99,4 +99,39 @@
   }
 
       
+    // 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, linkedConsumptionRateIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedConsumptionRateIds){
+     associationDtos.push({
+        primaryKey: consumptionRateId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, consumptionRateId, associationDtos);
+   }
+
+      
 }

package/src/db-sdk-v1/ConsumptionScheduleDb.ts

@@ -134,4 +134,39 @@
   }
 
       
+    // 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, linkedConsumptionScheduleIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedConsumptionScheduleIds){
+     associationDtos.push({
+        primaryKey: consumptionScheduleId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, consumptionScheduleId, associationDtos);
+   }
+
+      
 }

package/src/db-sdk-v1/ContactDb.ts

@@ -519,6 +519,41 @@
   }
 
       
+    // 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, linkedContactIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedContactIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+   }
+
+      
    // 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/db-sdk-v1/ContactIdentityDb.ts

@@ -99,6 +99,41 @@
    }
 
       
+    // 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, linkedContactIdentityIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedContactIdentityIds){
+     associationDtos.push({
+        primaryKey: contactIdentityId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, contactIdentityId, associationDtos);
+   }
+
+      
    // 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');

package/src/db-sdk-v1/FileDb.ts

@@ -239,41 +239,6 @@
   }
 
       
-   // Use this function when you want to return a single record
-   public async getKnowledgeArticles(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'KnowledgeArticle');
-   }
-        
-   public async linkKnowledgeArticleFiles(fileId: string, knowledgeArticleIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of knowledgeArticleIds){
-     associationDtos.push({
-         entity: 'SupportModule:KnowledgeArticle',
-         recordId: param.id,
-         linkType: 'KnowledgeArticle__File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkKnowledgeArticleFiles(fileId: string, linkedKnowledgeArticleIds: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedKnowledgeArticleIds){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
    // Use this function when you want to return a single record
    public async getCases(fileId: string) {
      return await this._getLinks(this.moduleName, this.entityName, fileId, 'Case');
@@ -1009,76 +974,6 @@
   }
 
       
-   // Use this function when you want to return a single record
-   public async getNetomniaFtth2StageInstallAudits(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'NetomniaFtth2StageInstallAudit');
-   }
-        
-   public async linkNetomniaFtth2StageInstallAuditFiles(fileId: string, netomniaFtth2StageInstallAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of netomniaFtth2StageInstallAuditIds){
-     associationDtos.push({
-         entity: 'FieldServiceModule:NetomniaFtth2StageInstallAudit',
-         recordId: param.id,
-         linkType: 'NetomniaFtth2StageInstallAudit__File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkNetomniaFtth2StageInstallAuditFiles(fileId: string, linkedNetomniaFtth2StageInstallAuditIds: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedNetomniaFtth2StageInstallAuditIds){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
-   // Use this function when you want to return a single record
-   public async getYfStockCounts(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'YfStockCount');
-   }
-        
-   public async linkYfStockCountFiles(fileId: string, yfStockCountIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of yfStockCountIds){
-     associationDtos.push({
-         entity: 'FieldServiceModule:YfStockCount',
-         recordId: param.id,
-         linkType: 'YfStockCount__File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkYfStockCountFiles(fileId: string, linkedYfStockCountIds: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedYfStockCountIds){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
    // Use this function when you want to return a single record
    public async getYfEquipmentCollections(fileId: string) {
      return await this._getLinks(this.moduleName, this.entityName, fileId, 'YfEquipmentCollection');
@@ -1529,111 +1424,6 @@
   }
 
       
-   // Use this function when you want to return a single record
-   public async getUgRetroAudits(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'UgRetroAudit');
-   }
-        
-   public async linkUgRetroAuditFiles(fileId: string, ugRetroAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of ugRetroAuditIds){
-     associationDtos.push({
-         entity: 'FieldServiceModule:UgRetroAudit',
-         recordId: param.id,
-         linkType: 'UgRetroAudit__File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkUgRetroAuditFiles(fileId: string, linkedUgRetroAuditIds: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedUgRetroAuditIds){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
-   // Use this function when you want to return a single record
-   public async getOhRetroAudits(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'OhRetroAudit');
-   }
-        
-   public async linkOhRetroAuditFiles(fileId: string, ohRetroAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of ohRetroAuditIds){
-     associationDtos.push({
-         entity: 'FieldServiceModule:OhRetroAudit',
-         recordId: param.id,
-         linkType: 'OhRetroAudit__File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkOhRetroAuditFiles(fileId: string, linkedOhRetroAuditIds: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedOhRetroAuditIds){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
-   // Use this function when you want to return a single record
-   public async getRemediationOutcomeForms(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'RemediationOutcomeForm');
-   }
-        
-   public async linkRemediationOutcomeFormFiles(fileId: string, remediationOutcomeFormIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of remediationOutcomeFormIds){
-     associationDtos.push({
-         entity: 'FieldServiceModule:RemediationOutcomeForm',
-         recordId: param.id,
-         linkType: 'RemediationOutcomeForm_File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkRemediationOutcomeFormFiles(fileId: string, linkedRemediationOutcomeFormIds: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedRemediationOutcomeFormIds){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
    // Use this function when you want to return a single record
    public async getUgInProgressAudits(fileId: string) {
      return await this._getLinks(this.moduleName, this.entityName, fileId, 'UgInProgressAudit');
@@ -1704,41 +1494,6 @@
   }
 
       
-   // Use this function when you want to return a single record
-   public async getBlockageA55s(fileId: string) {
-     return await this._getLinks(this.moduleName, this.entityName, fileId, 'BlockageA55');
-   }
-        
-   public async linkOverlayA55Files(fileId: string, blockageA55Ids: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-   const associationDtos = [];
-   for(const param of blockageA55Ids){
-     associationDtos.push({
-         entity: 'FieldServiceModule:BlockageA55',
-         recordId: param.id,
-         linkType: 'OverlayA55_File',
-         relationType: param?.relationType,
-         relatedAssociationId: param?.relatedAssociationId
-     });
-   }
-
-    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-  public async unlinkOverlayA55Files(fileId: string, linkedBlockageA55Ids: string[]) {
-
-   const associationDtos = [];
-   for(const pk of linkedBlockageA55Ids){
-     associationDtos.push({
-        primaryKey: fileId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
-  }
-
-      
    // Use this function when you want to return a single record
    public async getOverlayRealA55s(fileId: string) {
      return await this._getLinks(this.moduleName, this.entityName, fileId, 'OverlayRealA55');

package/src/db-sdk-v1/InvoiceItemDb.ts

@@ -99,4 +99,39 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getInvoiceItems(invoiceItemId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, invoiceItemId, 'InvoiceItem');
+    }
+        
+   public async linkInvoiceItemInvoiceItems(invoiceItemId: string, invoiceItemIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of invoiceItemIds){
+      associationDtos.push({
+          entity: 'BillingModule:InvoiceItem',
+          recordId: param.id,
+          linkType: 'InvoiceItem__InvoiceItem',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
+   }
+
+   public async unlinkInvoiceItemInvoiceItems(invoiceItemId: string, linkedInvoiceItemIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedInvoiceItemIds){
+     associationDtos.push({
+        primaryKey: invoiceItemId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
+   }
+
+      
 }