@d19n/youfibre-odin-sdk 1.0.19 → 1.0.21

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

@@ -74,32 +74,59 @@
    }
 
   
-    // Use this function when you want to return a single record
-    public async getFiles(fileId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, fileId, 'File');
-    }
+   // Use this function when you want to return a single record
+   public async getAppointments(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Appointment');
+   }
         
-   public async linkAppointmentFiles(fileId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+   public async linkAppointmentFiles(fileId: string, appointmentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-    const associationDtos = [];
-    for(const param of fileIds){
-      associationDtos.push({
-          entity: 'SchemaModule:File',
-          recordId: param.id,
-          linkType: 'Appointment__File',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
+   const associationDtos = [];
+   for(const param of appointmentIds){
+     associationDtos.push({
+         entity: 'CrmModule:Appointment',
+         recordId: param.id,
+         linkType: 'Appointment__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
 
-     return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkAppointmentFiles(fileId: string, linkedAppointmentId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedAppointmentId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getUgExternalAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'UgExternalAudit');
    }
+        
+   public async linkUgExternalAuditFiles(fileId: string, ugExternalAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-   public async unLinkAppointmentFiles(fileId: string, linkedFileId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedFileId);
+   const associationDtos = [];
+   for(const param of ugExternalAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:UgExternalAudit',
+         recordId: param.id,
+         linkType: 'UgExternalAudit_File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkUgExternalAuditFiles(fileId: string, linkedUgExternalAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedUgExternalAuditId);
+  }
+
       
     // Use this function when you want to return a single record
     public async getNotes(fileId: string) {
@@ -128,4 +155,1268 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getWorkOrders(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'WorkOrder');
+   }
+        
+   public async linkWorkOrderFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkWorkOrderFiles(fileId: string, linkedWorkOrderId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedWorkOrderId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getInternalInstallAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'InternalInstallAudit');
+   }
+        
+   public async linkInternalInstallAuditFiles(fileId: string, internalInstallAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of internalInstallAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:InternalInstallAudit',
+         recordId: param.id,
+         linkType: 'InternalInstallAudit_File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkInternalInstallAuditFiles(fileId: string, linkedInternalInstallAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedInternalInstallAuditId);
+  }
+
+      
+   // 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');
+   }
+        
+   public async linkCaseFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkCaseFiles(fileId: string, linkedCaseId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedCaseId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getLeads(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Lead');
+   }
+        
+   public async linkLeadFiles(fileId: string, leadIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of leadIds){
+     associationDtos.push({
+         entity: 'CrmModule:Lead',
+         recordId: param.id,
+         linkType: 'Lead__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkLeadFiles(fileId: string, linkedLeadId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedLeadId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getContacts(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Contact');
+   }
+        
+   public async linkContactFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkContactFiles(fileId: string, linkedContactId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedContactId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrders(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Order');
+   }
+        
+   public async linkOrderFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkOrderFiles(fileId: string, linkedOrderId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOrderId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getBillingRequests(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'BillingRequest');
+   }
+        
+   public async linkBillingRequestFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkBillingRequestFiles(fileId: string, linkedBillingRequestId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedBillingRequestId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getTransactions(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Transaction');
+   }
+        
+   public async linkTransactionFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkTransactionFiles(fileId: string, linkedTransactionId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedTransactionId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getPaymentMethods(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'PaymentMethod');
+   }
+        
+   public async linkPaymentMethodFiles(fileId: string, paymentMethodIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of paymentMethodIds){
+     associationDtos.push({
+         entity: 'BillingModule:PaymentMethod',
+         recordId: param.id,
+         linkType: 'PaymentMethod__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkPaymentMethodFiles(fileId: string, linkedPaymentMethodId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedPaymentMethodId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCustomerDeviceOnts(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'CustomerDeviceOnt');
+   }
+        
+   public async linkCustomerDeviceOntFiles(fileId: string, customerDeviceOntIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of customerDeviceOntIds){
+     associationDtos.push({
+         entity: 'ServiceModule:CustomerDeviceOnt',
+         recordId: param.id,
+         linkType: 'CustomerDeviceOnt__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkCustomerDeviceOntFiles(fileId: string, linkedCustomerDeviceOntId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedCustomerDeviceOntId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCreditNotes(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'CreditNote');
+   }
+        
+   public async linkCreditNoteFiles(fileId: string, creditNoteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of creditNoteIds){
+     associationDtos.push({
+         entity: 'BillingModule:CreditNote',
+         recordId: param.id,
+         linkType: 'CreditNote__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkCreditNoteFiles(fileId: string, linkedCreditNoteId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedCreditNoteId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getAddresss(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Address');
+   }
+        
+   public async linkAddressFiles(fileId: string, addressIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of addressIds){
+     associationDtos.push({
+         entity: 'CrmModule:Address',
+         recordId: param.id,
+         linkType: 'Address__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkAddressFiles(fileId: string, linkedAddressId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedAddressId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getChangeReasons(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'ChangeReason');
+   }
+        
+   public async linkChangeReasonFiles(fileId: string, changeReasonIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of changeReasonIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:ChangeReason',
+         recordId: param.id,
+         linkType: 'ChangeReason__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkChangeReasonFiles(fileId: string, linkedChangeReasonId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedChangeReasonId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getDiscounts(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Discount');
+   }
+        
+   public async linkDiscountFiles(fileId: string, discountIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of discountIds){
+     associationDtos.push({
+         entity: 'ProductModule:Discount',
+         recordId: param.id,
+         linkType: 'Discount__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkDiscountFiles(fileId: string, linkedDiscountId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedDiscountId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getPaymentMethodRefunds(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'PaymentMethodRefund');
+   }
+        
+   public async linkPaymentMethodRefundFiles(fileId: string, paymentMethodRefundIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of paymentMethodRefundIds){
+     associationDtos.push({
+         entity: 'BillingModule:PaymentMethodRefund',
+         recordId: param.id,
+         linkType: 'PaymentMethodRefund__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkPaymentMethodRefundFiles(fileId: string, linkedPaymentMethodRefundId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedPaymentMethodRefundId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getServiceAppointments(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'ServiceAppointment');
+   }
+        
+   public async linkServiceAppointmentFiles(fileId: string, serviceAppointmentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of serviceAppointmentIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:ServiceAppointment',
+         recordId: param.id,
+         linkType: 'ServiceAppointment__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkServiceAppointmentFiles(fileId: string, linkedServiceAppointmentId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedServiceAppointmentId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getBillingAdjustments(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'BillingAdjustment');
+   }
+        
+   public async linkBillingAdjustmentFiles(fileId: string, billingAdjustmentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of billingAdjustmentIds){
+     associationDtos.push({
+         entity: 'OrderModule:BillingAdjustment',
+         recordId: param.id,
+         linkType: 'BillingAdjustment__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkBillingAdjustmentFiles(fileId: string, linkedBillingAdjustmentId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedBillingAdjustmentId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getActivitys(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Activity');
+   }
+        
+   public async linkActivityFiles(fileId: string, activityIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of activityIds){
+     associationDtos.push({
+         entity: 'SchemaModule:Activity',
+         recordId: param.id,
+         linkType: 'Activity__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkActivityFiles(fileId: string, linkedActivityId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedActivityId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getNetomniaInstallVerifications(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'NetomniaInstallVerification');
+   }
+        
+   public async linkNetomniaInstallVerificationFiles(fileId: string, netomniaInstallVerificationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of netomniaInstallVerificationIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:NetomniaInstallVerification',
+         recordId: param.id,
+         linkType: 'NetomniaInstallVerification__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkNetomniaInstallVerificationFiles(fileId: string, linkedNetomniaInstallVerificationId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedNetomniaInstallVerificationId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getNetomniaFtthServiceVisitSheets(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'NetomniaFtthServiceVisitSheet');
+   }
+        
+   public async linkNetomniaFtthServiceVisitSheetFiles(fileId: string, netomniaFtthServiceVisitSheetIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of netomniaFtthServiceVisitSheetIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:NetomniaFtthServiceVisitSheet',
+         recordId: param.id,
+         linkType: 'NetomniaFtthServiceVisitSheet__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkNetomniaFtthServiceVisitSheetFiles(fileId: string, linkedNetomniaFtthServiceVisitSheetId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedNetomniaFtthServiceVisitSheetId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getNetomniaFtth1StageInstallAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'NetomniaFtth1StageInstallAudit');
+   }
+        
+   public async linkNetomniaFtth1StageInstallAuditFiles(fileId: string, netomniaFtth1StageInstallAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of netomniaFtth1StageInstallAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:NetomniaFtth1StageInstallAudit',
+         recordId: param.id,
+         linkType: 'NetomniaFtth1StageInstallAudit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkNetomniaFtth1StageInstallAuditFiles(fileId: string, linkedNetomniaFtth1StageInstallAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedNetomniaFtth1StageInstallAuditId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCustomerDeviceRouters(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'CustomerDeviceRouter');
+   }
+        
+   public async linkCustomerDeviceRouterFiles(fileId: string, customerDeviceRouterIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of customerDeviceRouterIds){
+     associationDtos.push({
+         entity: 'ServiceModule:CustomerDeviceRouter',
+         recordId: param.id,
+         linkType: 'CustomerDeviceRouter__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkCustomerDeviceRouterFiles(fileId: string, linkedCustomerDeviceRouterId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedCustomerDeviceRouterId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getVisits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Visit');
+   }
+        
+   public async linkVisitFiles(fileId: string, visitIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of visitIds){
+     associationDtos.push({
+         entity: 'CrmModule:Visit',
+         recordId: param.id,
+         linkType: 'Visit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkVisitFiles(fileId: string, linkedVisitId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedVisitId);
+  }
+
+      
+   // 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');
+   }
+        
+   public async linkYfEquipmentCollectionFiles(fileId: string, yfEquipmentCollectionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of yfEquipmentCollectionIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:YfEquipmentCollection',
+         recordId: param.id,
+         linkType: 'YfEquipmentCollection__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkYfEquipmentCollectionFiles(fileId: string, linkedYfEquipmentCollectionId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedYfEquipmentCollectionId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getYfFieldServiceVisits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'YfFieldServiceVisit');
+   }
+        
+   public async linkYfFieldServiceVisitFiles(fileId: string, yfFieldServiceVisitIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of yfFieldServiceVisitIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:YfFieldServiceVisit',
+         recordId: param.id,
+         linkType: 'YfFieldServiceVisit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkYfFieldServiceVisitFiles(fileId: string, linkedYfFieldServiceVisitId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedYfFieldServiceVisitId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getRemediationRequiredReasons(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'RemediationRequiredReason');
+   }
+        
+   public async linkRemediationRequiredReasonFiles(fileId: string, remediationRequiredReasonIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of remediationRequiredReasonIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:RemediationRequiredReason',
+         recordId: param.id,
+         linkType: 'RemediationRequiredReason__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkRemediationRequiredReasonFiles(fileId: string, linkedRemediationRequiredReasonId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedRemediationRequiredReasonId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getInvoices(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Invoice');
+   }
+        
+   public async linkInvoiceFiles(fileId: string, invoiceIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of invoiceIds){
+     associationDtos.push({
+         entity: 'BillingModule:Invoice',
+         recordId: param.id,
+         linkType: 'Invoice__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkInvoiceFiles(fileId: string, linkedInvoiceId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedInvoiceId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getFingerprints(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'Fingerprint');
+   }
+        
+   public async linkFingerprintFiles(fileId: string, fingerprintIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of fingerprintIds){
+     associationDtos.push({
+         entity: 'CrmModule:Fingerprint',
+         recordId: param.id,
+         linkType: 'Fingerprint__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkFingerprintFiles(fileId: string, linkedFingerprintId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedFingerprintId);
+  }
+
+      
+   public async linkNoteFiles(fileId: 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__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkNoteFiles(fileId: string, linkedNoteId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedNoteId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getSweeperMaintenanceAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'SweeperMaintenanceAudit');
+   }
+        
+   public async linkSweeperMaintenanceAuditFiles(fileId: string, sweeperMaintenanceAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of sweeperMaintenanceAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:SweeperMaintenanceAudit',
+         recordId: param.id,
+         linkType: 'SweeperMaintenanceAudit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkSweeperMaintenanceAuditFiles(fileId: string, linkedSweeperMaintenanceAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedSweeperMaintenanceAuditId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getBlockageReportA55s(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'BlockageReportA55');
+   }
+        
+   public async linkBlockageReportA55Files(fileId: string, blockageReportA55Ids: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of blockageReportA55Ids){
+     associationDtos.push({
+         entity: 'FieldServiceModule:BlockageReportA55',
+         recordId: param.id,
+         linkType: 'BlockageReportA55__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkBlockageReportA55Files(fileId: string, linkedBlockageReportA55Id: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedBlockageReportA55Id);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getUgInstallationAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'UgInstallationAudit');
+   }
+        
+   public async linkUgInstallationAuditFiles(fileId: string, ugInstallationAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ugInstallationAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:UgInstallationAudit',
+         recordId: param.id,
+         linkType: 'UgInstallationAudit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkUgInstallationAuditFiles(fileId: string, linkedUgInstallationAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedUgInstallationAuditId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhInstallationAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'OhInstallationAudit');
+   }
+        
+   public async linkOhInstallationAuditFiles(fileId: string, ohInstallationAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ohInstallationAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:OhInstallationAudit',
+         recordId: param.id,
+         linkType: 'OhInstallationAudit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkOhInstallationAuditFiles(fileId: string, linkedOhInstallationAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOhInstallationAuditId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getServiceVisitAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'ServiceVisitAudit');
+   }
+        
+   public async linkServiceVisitAuditFiles(fileId: string, serviceVisitAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of serviceVisitAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:ServiceVisitAudit',
+         recordId: param.id,
+         linkType: 'ServiceVisitAudit__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkServiceVisitAuditFiles(fileId: string, linkedServiceVisitAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedServiceVisitAuditId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhAuditOfInstallations(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'OhAuditOfInstallation');
+   }
+        
+   public async linkOhAuditOfInstallationFiles(fileId: string, ohAuditOfInstallationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ohAuditOfInstallationIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:OhAuditOfInstallation',
+         recordId: param.id,
+         linkType: 'OhAuditOfInstallation__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkOhAuditOfInstallationFiles(fileId: string, linkedOhAuditOfInstallationId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOhAuditOfInstallationId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getUgAuditOfInstallations(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'UgAuditOfInstallation');
+   }
+        
+   public async linkUgAuditOfInstallationFiles(fileId: string, ugAuditOfInstallationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ugAuditOfInstallationIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:UgAuditOfInstallation',
+         recordId: param.id,
+         linkType: 'UgAuditOfInstallation__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkUgAuditOfInstallationFiles(fileId: string, linkedUgAuditOfInstallationId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedUgAuditOfInstallationId);
+  }
+
+      
+   // 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');
+   }
+        
+   public async linkUgInProgressAuditFiles(fileId: string, ugInProgressAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ugInProgressAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:UgInProgressAudit',
+         recordId: param.id,
+         linkType: 'UgInProgressAudit_File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkUgInProgressAuditFiles(fileId: string, linkedUgInProgressAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedUgInProgressAuditId);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhInProgressAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'OhInProgressAudit');
+   }
+        
+   public async linkOhInProgressAuditFiles(fileId: string, ohInProgressAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ohInProgressAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:OhInProgressAudit',
+         recordId: param.id,
+         linkType: 'OhInProgressAudit_File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkOhInProgressAuditFiles(fileId: string, linkedOhInProgressAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOhInProgressAuditId);
+  }
+
+      
+   // 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');
+   }
+        
+   public async linkOverlayRealA55Files(fileId: string, overlayRealA55Ids: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of overlayRealA55Ids){
+     associationDtos.push({
+         entity: 'FieldServiceModule:OverlayRealA55',
+         recordId: param.id,
+         linkType: 'OverlayRealA55_File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkOverlayRealA55Files(fileId: string, linkedOverlayRealA55Id: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOverlayRealA55Id);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhExternalAudits(fileId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, fileId, 'OhExternalAudit');
+   }
+        
+   public async linkOhExternalAuditFiles(fileId: string, ohExternalAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of ohExternalAuditIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:OhExternalAudit',
+         recordId: param.id,
+         linkType: 'OhExternalAudit_File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unLinkOhExternalAuditFiles(fileId: string, linkedOhExternalAuditId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, linkedOhExternalAuditId);
+  }
+
+      
 }