@d19n/youfibre-odin-sdk 1.0.19 → 1.0.21

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

@@ -64,40 +64,75 @@
    }
 
   
-    // 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}[]) {
-
-    const associationDtos = [];
-    for(const param of fileIds){
-      associationDtos.push({
-          entity: 'SchemaModule:File',
-          recordId: param.id,
-          linkType: 'Appointment__File',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
+   public async linkAppointmentFiles(fileId: string, appointmentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-     return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+   const associationDtos = [];
+   for(const param of appointmentIds){
+     associationDtos.push({
+         entity: 'CrmModule:Appointment',
+         recordId: param.id,
+         linkType: 'Appointment__File',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
-   public async unlinkAppointmentFiles(fileId: string, linkedFileIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedFileIds){
+    return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+  public async unlinkAppointmentFiles(fileId: string, linkedAppointmentIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedAppointmentIds){
      associationDtos.push({
         primaryKey: fileId,
         linkedRecordPrimaryKey: pk,
      });
    }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
+
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+      
+   // 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}[]) {
+
+   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, linkedUgExternalAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedUgExternalAuditIds){
+     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 getNotes(fileId: string) {
@@ -134,4 +169,1644 @@
    }
 
       
+   // 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, linkedWorkOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedWorkOrderIds){
+     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 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, linkedInternalInstallAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedInternalInstallAuditIds){
+     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 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');
+   }
+        
+   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, linkedCaseIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCaseIds){
+     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 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, linkedLeadIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedLeadIds){
+     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 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, linkedContactIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedContactIds){
+     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 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, linkedOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrderIds){
+     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 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, linkedBillingRequestIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedBillingRequestIds){
+     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 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, linkedTransactionIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedTransactionIds){
+     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 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, linkedPaymentMethodIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedPaymentMethodIds){
+     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 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, linkedCustomerDeviceOntIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCustomerDeviceOntIds){
+     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 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, linkedCreditNoteIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCreditNoteIds){
+     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 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, linkedAddressIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedAddressIds){
+     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 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, linkedChangeReasonIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedChangeReasonIds){
+     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 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, linkedDiscountIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedDiscountIds){
+     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 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, linkedPaymentMethodRefundIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedPaymentMethodRefundIds){
+     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 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, linkedServiceAppointmentIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedServiceAppointmentIds){
+     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 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, linkedBillingAdjustmentIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedBillingAdjustmentIds){
+     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 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, linkedActivityIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedActivityIds){
+     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 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, linkedNetomniaInstallVerificationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedNetomniaInstallVerificationIds){
+     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 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, linkedNetomniaFtthServiceVisitSheetIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedNetomniaFtthServiceVisitSheetIds){
+     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 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, linkedNetomniaFtth1StageInstallAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedNetomniaFtth1StageInstallAuditIds){
+     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 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, linkedCustomerDeviceRouterIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCustomerDeviceRouterIds){
+     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 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, linkedVisitIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedVisitIds){
+     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 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');
+   }
+        
+   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, linkedYfEquipmentCollectionIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedYfEquipmentCollectionIds){
+     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 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, linkedYfFieldServiceVisitIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedYfFieldServiceVisitIds){
+     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 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, linkedRemediationRequiredReasonIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedRemediationRequiredReasonIds){
+     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 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, linkedInvoiceIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedInvoiceIds){
+     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 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, linkedFingerprintIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedFingerprintIds){
+     associationDtos.push({
+        primaryKey: fileId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+      
+   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, linkedNoteIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedNoteIds){
+     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 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, linkedSweeperMaintenanceAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedSweeperMaintenanceAuditIds){
+     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 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, linkedBlockageReportA55Ids: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedBlockageReportA55Ids){
+     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 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, linkedUgInstallationAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedUgInstallationAuditIds){
+     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 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, linkedOhInstallationAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOhInstallationAuditIds){
+     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 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, linkedServiceVisitAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedServiceVisitAuditIds){
+     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 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, linkedOhAuditOfInstallationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOhAuditOfInstallationIds){
+     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 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, linkedUgAuditOfInstallationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedUgAuditOfInstallationIds){
+     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 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');
+   }
+        
+   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, linkedUgInProgressAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedUgInProgressAuditIds){
+     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 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, linkedOhInProgressAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOhInProgressAuditIds){
+     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 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');
+   }
+        
+   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, linkedOverlayRealA55Ids: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOverlayRealA55Ids){
+     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 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, linkedOhExternalAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOhExternalAuditIds){
+     associationDtos.push({
+        primaryKey: fileId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+      
 }