@d19n/youfibre-odin-sdk 1.0.21 → 1.0.23

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

@@ -101,4 +101,31 @@
   }
 
       
+   // Use this function when you want to return a single record
+   public async getWorkOrders(customerDeviceOntRemovalId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, customerDeviceOntRemovalId, 'WorkOrder');
+   }
+        
+   public async linkWorkOrderCustomerDeviceOntRemovals(customerDeviceOntRemovalId: 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_CustomerDeviceOntRemoval',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, customerDeviceOntRemovalId, associationDtos);
+  }
+
+  public async unLinkWorkOrderCustomerDeviceOntRemovals(customerDeviceOntRemovalId: string, linkedWorkOrderId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, customerDeviceOntRemovalId, linkedWorkOrderId);
+  }
+
+      
 }

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

@@ -209,33 +209,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, linkedKnowledgeArticleId: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedKnowledgeArticleId);
-  }
-
-      
    // 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');
@@ -803,60 +776,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, linkedNetomniaFtth2StageInstallAuditId: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedNetomniaFtth2StageInstallAuditId);
-  }
-
-      
-   // 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, linkedYfStockCountId: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedYfStockCountId);
-  }
-
-      
    // 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');
@@ -1203,87 +1122,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, linkedUgRetroAuditId: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedUgRetroAuditId);
-  }
-
-      
-   // 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, linkedOhRetroAuditId: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOhRetroAuditId);
-  }
-
-      
-   // 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, linkedRemediationOutcomeFormId: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedRemediationOutcomeFormId);
-  }
-
-      
    // 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');
@@ -1338,33 +1176,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, linkedBlockageA55Id: string) {
-  
-    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedBlockageA55Id);
-  }
-
-      
    // 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/api-sdk-v1/InvoiceItemApi.ts

@@ -101,4 +101,31 @@
   }
 
       
+    // 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, linkedInvoiceItemId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, invoiceItemId, linkedInvoiceItemId);
+   }
+
+      
 }

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

@@ -128,6 +128,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getMilestones(milestoneId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, milestoneId, 'Milestone');
+    }
+        
+   public async linkMilestoneMilestones(milestoneId: string, milestoneIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of milestoneIds){
+      associationDtos.push({
+          entity: 'ProjectModule:Milestone',
+          recordId: param.id,
+          linkType: 'Milestone__Milestone',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, milestoneId, associationDtos);
+   }
+
+   public async unLinkMilestoneMilestones(milestoneId: string, linkedMilestoneId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, milestoneId, linkedMilestoneId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getNotes(milestoneId: string) {
       return await this._getLinks(this.moduleName, this.entityName, milestoneId, 'Note');

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

@@ -1343,6 +1343,33 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getNotes(noteId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, noteId, 'Note');
+    }
+        
+   public async linkNoteNotes(noteId: string, noteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: param.id,
+          linkType: 'Note__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+   }
+
+   public async unLinkNoteNotes(noteId: string, linkedNoteId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, noteId, linkedNoteId);
+   }
+
+      
    public async linkNoteFiles(noteId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
     const associationDtos = [];

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

@@ -155,6 +155,33 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getOffers(offerId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, offerId, 'Offer');
+    }
+        
+   public async linkOfferOffers(offerId: string, offerIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of offerIds){
+      associationDtos.push({
+          entity: 'ProductModule:Offer',
+          recordId: param.id,
+          linkType: 'Offer__Offer',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, offerId, associationDtos);
+   }
+
+   public async unLinkOfferOffers(offerId: string, linkedOfferId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, offerId, linkedOfferId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getDiscounts(offerId: string) {
       return await this._getLinks(this.moduleName, this.entityName, offerId, 'Discount');

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

@@ -456,6 +456,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getOrders(orderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, orderId, 'Order');
+    }
+        
+   public async linkOrderOrders(orderId: string, orderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of orderIds){
+      associationDtos.push({
+          entity: 'OrderModule:Order',
+          recordId: param.id,
+          linkType: 'Order__Order',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, orderId, associationDtos);
+   }
+
+   public async unLinkOrderOrders(orderId: string, linkedOrderId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, orderId, linkedOrderId);
+   }
+
+      
    // Use this function when you want to return a single record
    public async getPicRequests(orderId: string) {
      return await this._getLinks(this.moduleName, this.entityName, orderId, 'PICRequest');

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

@@ -398,6 +398,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getOrderItems(orderItemId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, orderItemId, 'OrderItem');
+    }
+        
+   public async linkOrderItemOrderItems(orderItemId: string, orderItemIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of orderItemIds){
+      associationDtos.push({
+          entity: 'OrderModule:OrderItem',
+          recordId: param.id,
+          linkType: 'OrderItem__OrderItem',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, orderItemId, associationDtos);
+   }
+
+   public async unLinkOrderItemOrderItems(orderItemId: string, linkedOrderItemId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, orderItemId, linkedOrderItemId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getVoiceConfigurations(orderItemId: string) {
       return await this._getLinks(this.moduleName, this.entityName, orderItemId, 'VoiceConfiguration');

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

@@ -155,4 +155,31 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getOrganizations(organizationId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, organizationId, 'Organization');
+    }
+        
+   public async linkOrganizationOrganizations(organizationId: string, organizationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of organizationIds){
+      associationDtos.push({
+          entity: 'CrmModule:Organization',
+          recordId: param.id,
+          linkType: 'Organization__Organization',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, organizationId, associationDtos);
+   }
+
+   public async unLinkOrganizationOrganizations(organizationId: string, linkedOrganizationId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, organizationId, linkedOrganizationId);
+   }
+
+      
 }

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

@@ -317,4 +317,35 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getProducts(productId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, productId, 'Product');
+    }
+        
+   public async linkProductProducts(productId: string, productIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of productIds){
+      associationDtos.push({
+          entity: 'ProductModule:Product',
+          recordId: param.id,
+          linkType: 'Product__Product',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, productId, associationDtos);
+   }
+
+   public async unLinkProductProducts(productId: string, linkedProductId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, productId, linkedProductId);
+   }
+
+      
+   public async addProductProductLinkProperties(productId: string, dbRecordAssociationId: string, updateDto: OdinLinkedRecordUpdateDto) {
+
+     return await this._updateLinkProperties('ProductModule', 'Product', productId, dbRecordAssociationId, updateDto);
+   }
 }

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

@@ -128,4 +128,31 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getProductComponents(productComponentId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, productComponentId, 'ProductComponent');
+    }
+        
+   public async linkProductComponentProductComponents(productComponentId: string, productComponentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of productComponentIds){
+      associationDtos.push({
+          entity: 'ProductModule:ProductComponent',
+          recordId: param.id,
+          linkType: 'ProductComponent__ProductComponent',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, productComponentId, associationDtos);
+   }
+
+   public async unLinkProductComponentProductComponents(productComponentId: string, linkedProductComponentId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, productComponentId, linkedProductComponentId);
+   }
+
+      
 }

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

@@ -128,4 +128,31 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getRestrictions(restrictionId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, restrictionId, 'Restriction');
+    }
+        
+   public async linkRestrictionRestrictions(restrictionId: string, restrictionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of restrictionIds){
+      associationDtos.push({
+          entity: 'ProductModule:Restriction',
+          recordId: param.id,
+          linkType: 'Restriction__Restriction',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, restrictionId, associationDtos);
+   }
+
+   public async unLinkRestrictionRestrictions(restrictionId: string, linkedRestrictionId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, restrictionId, linkedRestrictionId);
+   }
+
+      
 }

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

@@ -101,4 +101,31 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getServices(serviceId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, serviceId, 'Service');
+    }
+        
+   public async linkServiceServices(serviceId: string, serviceIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of serviceIds){
+      associationDtos.push({
+          entity: 'ServiceModule:Service',
+          recordId: param.id,
+          linkType: 'Service__Service',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, serviceId, associationDtos);
+   }
+
+   public async unLinkServiceServices(serviceId: string, linkedServiceId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, serviceId, linkedServiceId);
+   }
+
+      
 }

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

@@ -128,6 +128,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getSplitOrders(splitOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, splitOrderId, 'SplitOrder');
+    }
+        
+   public async linkSplitOrderSplitOrders(splitOrderId: string, splitOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of splitOrderIds){
+      associationDtos.push({
+          entity: 'OrderModule:SplitOrder',
+          recordId: param.id,
+          linkType: 'SplitOrder__SplitOrder',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+   }
+
+   public async unLinkSplitOrderSplitOrders(splitOrderId: string, linkedSplitOrderId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, splitOrderId, linkedSplitOrderId);
+   }
+
+      
    public async linkOrderSplitOrders(splitOrderId: string, orderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
    const associationDtos = [];