@d19n/youfibre-odin-sdk 1.0.1

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

@@ -0,0 +1,1547 @@
+
+  import { OauthParams } from '@d19n/odin-sdk-generator/dist/api.interfaces';
+  import { ApiProvider } from '@d19n/odin-sdk-generator/dist/api.provider';
+  import { OdinSearchV2 } from '@d19n/odin-types/dist/interfaces/v2.db.interfaces';
+  import { BatchDeleteParam, BatchRestoreParam, OdinRecordCreateDto, OdinRecordUpdateDto, OdinLinkedRecordUpdateDto, RelationTypeEnum } from '@d19n/odin-types/dist/dtos/odin.dtos';
+
+  export class FileApi extends ApiProvider {
+
+      private readonly moduleName: string = 'SchemaModule';
+      private readonly entityName: string = 'File';
+
+      constructor(protected readonly authParams: OauthParams) {
+        super(authParams);
+      }
+
+  
+   public async schema() {
+      return await this.getSchema(this.moduleName, this.entityName);
+   }
+
+   // Use this function when you want to search and handle all pagination on your own
+   public async searchRecords(params: Partial<OdinSearchV2>) {
+      return await this._searchRecords(this.moduleName, this.entityName, params);
+   }
+   
+   // Use this function to re-index records in elastic search
+	 public async reIndexRecords(body: { id: string, schemaId: string }[]) {
+      return await this._reIndexRecords(body);
+   }
+
+   // Use this function when you want paginating through the results to be handled
+   public async searchAllRecordsAndPaginate(params: Partial<OdinSearchV2>) {
+      return await this._searchAllRecordsAndPaginate(this.moduleName, this.entityName, params);
+   }
+
+   // Use this function when you want to return a single record
+   public async getByPrimaryKey(fileId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, fileId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(fileId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, fileId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(fileId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, fileId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(fileIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, fileIds);
+   }
+
+   // Use this function when you want to upsert one or many records
+   public async upsert(upsertDtos: OdinRecordCreateDto[]) {
+      return await this._upsert(this.moduleName, this.entityName, upsertDtos);
+   }
+
+   // Use this function when you want to update one or many records
+   public async update(updateDtos: OdinRecordUpdateDto[]) {
+      return await this._update(this.moduleName, this.entityName, updateDtos);
+   }
+
+   // Use this function when you want to delete one or many records
+   public async delete(fileIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, fileIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(fileIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, fileIds);
+   }
+
+  
+   // 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 addAppointmentFiles(fileId: string, appointmentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   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);
+  }
+
+  public async removeAppointmentFiles(fileId: string, appointmentIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of appointmentIds){
+     associationDtos.push({
+        entity: 'CrmModule:Appointment',
+        recordId: pk,
+     });
+   }
+
+    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 addUgExternalAuditFiles(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 removeUgExternalAuditFiles(fileId: string, ugExternalAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ugExternalAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:UgExternalAudit',
+        recordId: 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) {
+      return await this._getLinks(this.moduleName, this.entityName, fileId, 'Note');
+    }
+        
+   public async addFileNotes(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: 'File__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, fileId, associationDtos);
+   }
+
+   public async removeFileNotes(fileId: string, noteIds: string[]) {
+
+    const associationDtos = [];
+    for(const pk of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: pk,
+      });
+    }
+
+     return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
+   }
+
+      
+   // 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 addWorkOrderFiles(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 removeWorkOrderFiles(fileId: string, workOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of workOrderIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:WorkOrder',
+        recordId: 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 addInternalInstallAuditFiles(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 removeInternalInstallAuditFiles(fileId: string, internalInstallAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of internalInstallAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:InternalInstallAudit',
+        recordId: 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 addCaseFiles(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 removeCaseFiles(fileId: string, caseIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of caseIds){
+     associationDtos.push({
+        entity: 'SupportModule:Case',
+        recordId: 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 addLeadFiles(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 removeLeadFiles(fileId: string, leadIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of leadIds){
+     associationDtos.push({
+        entity: 'CrmModule:Lead',
+        recordId: 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 addContactFiles(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 removeContactFiles(fileId: string, contactIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of contactIds){
+     associationDtos.push({
+        entity: 'CrmModule:Contact',
+        recordId: 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 addOrderFiles(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 removeOrderFiles(fileId: string, orderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of orderIds){
+     associationDtos.push({
+        entity: 'OrderModule:Order',
+        recordId: 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 addBillingRequestFiles(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 removeBillingRequestFiles(fileId: string, billingRequestIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of billingRequestIds){
+     associationDtos.push({
+        entity: 'BillingModule:BillingRequest',
+        recordId: 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 addTransactionFiles(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 removeTransactionFiles(fileId: string, transactionIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of transactionIds){
+     associationDtos.push({
+        entity: 'BillingModule:Transaction',
+        recordId: 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 addPaymentMethodFiles(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 removePaymentMethodFiles(fileId: string, paymentMethodIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of paymentMethodIds){
+     associationDtos.push({
+        entity: 'BillingModule:PaymentMethod',
+        recordId: 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 addCustomerDeviceOntFiles(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 removeCustomerDeviceOntFiles(fileId: string, customerDeviceOntIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of customerDeviceOntIds){
+     associationDtos.push({
+        entity: 'ServiceModule:CustomerDeviceOnt',
+        recordId: 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 addCreditNoteFiles(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 removeCreditNoteFiles(fileId: string, creditNoteIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of creditNoteIds){
+     associationDtos.push({
+        entity: 'BillingModule:CreditNote',
+        recordId: 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 addAddressFiles(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 removeAddressFiles(fileId: string, addressIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of addressIds){
+     associationDtos.push({
+        entity: 'CrmModule:Address',
+        recordId: 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 addChangeReasonFiles(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 removeChangeReasonFiles(fileId: string, changeReasonIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of changeReasonIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:ChangeReason',
+        recordId: 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 addDiscountFiles(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 removeDiscountFiles(fileId: string, discountIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of discountIds){
+     associationDtos.push({
+        entity: 'ProductModule:Discount',
+        recordId: 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 addPaymentMethodRefundFiles(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 removePaymentMethodRefundFiles(fileId: string, paymentMethodRefundIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of paymentMethodRefundIds){
+     associationDtos.push({
+        entity: 'BillingModule:PaymentMethodRefund',
+        recordId: 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 addServiceAppointmentFiles(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 removeServiceAppointmentFiles(fileId: string, serviceAppointmentIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of serviceAppointmentIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:ServiceAppointment',
+        recordId: 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 addBillingAdjustmentFiles(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 removeBillingAdjustmentFiles(fileId: string, billingAdjustmentIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of billingAdjustmentIds){
+     associationDtos.push({
+        entity: 'OrderModule:BillingAdjustment',
+        recordId: 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 addActivityFiles(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 removeActivityFiles(fileId: string, activityIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of activityIds){
+     associationDtos.push({
+        entity: 'SchemaModule:Activity',
+        recordId: 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 addNetomniaInstallVerificationFiles(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 removeNetomniaInstallVerificationFiles(fileId: string, netomniaInstallVerificationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of netomniaInstallVerificationIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:NetomniaInstallVerification',
+        recordId: 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 addNetomniaFtthServiceVisitSheetFiles(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 removeNetomniaFtthServiceVisitSheetFiles(fileId: string, netomniaFtthServiceVisitSheetIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of netomniaFtthServiceVisitSheetIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:NetomniaFtthServiceVisitSheet',
+        recordId: 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 addNetomniaFtth1StageInstallAuditFiles(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 removeNetomniaFtth1StageInstallAuditFiles(fileId: string, netomniaFtth1StageInstallAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of netomniaFtth1StageInstallAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:NetomniaFtth1StageInstallAudit',
+        recordId: 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 addCustomerDeviceRouterFiles(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 removeCustomerDeviceRouterFiles(fileId: string, customerDeviceRouterIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of customerDeviceRouterIds){
+     associationDtos.push({
+        entity: 'ServiceModule:CustomerDeviceRouter',
+        recordId: 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 addVisitFiles(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 removeVisitFiles(fileId: string, visitIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of visitIds){
+     associationDtos.push({
+        entity: 'CrmModule:Visit',
+        recordId: 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 addYfEquipmentCollectionFiles(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 removeYfEquipmentCollectionFiles(fileId: string, yfEquipmentCollectionIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of yfEquipmentCollectionIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:YfEquipmentCollection',
+        recordId: 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 addYfFieldServiceVisitFiles(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 removeYfFieldServiceVisitFiles(fileId: string, yfFieldServiceVisitIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of yfFieldServiceVisitIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:YfFieldServiceVisit',
+        recordId: 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 addRemediationRequiredReasonFiles(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 removeRemediationRequiredReasonFiles(fileId: string, remediationRequiredReasonIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of remediationRequiredReasonIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:RemediationRequiredReason',
+        recordId: 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 addInvoiceFiles(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 removeInvoiceFiles(fileId: string, invoiceIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of invoiceIds){
+     associationDtos.push({
+        entity: 'BillingModule:Invoice',
+        recordId: 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 addFingerprintFiles(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 removeFingerprintFiles(fileId: string, fingerprintIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of fingerprintIds){
+     associationDtos.push({
+        entity: 'CrmModule:Fingerprint',
+        recordId: 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 addSweeperMaintenanceAuditFiles(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 removeSweeperMaintenanceAuditFiles(fileId: string, sweeperMaintenanceAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of sweeperMaintenanceAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:SweeperMaintenanceAudit',
+        recordId: 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 addBlockageReportA55Files(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 removeBlockageReportA55Files(fileId: string, blockageReportA55Ids: string[]) {
+
+   const associationDtos = [];
+   for(const pk of blockageReportA55Ids){
+     associationDtos.push({
+        entity: 'FieldServiceModule:BlockageReportA55',
+        recordId: 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 addUgInstallationAuditFiles(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 removeUgInstallationAuditFiles(fileId: string, ugInstallationAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ugInstallationAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:UgInstallationAudit',
+        recordId: 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 addOhInstallationAuditFiles(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 removeOhInstallationAuditFiles(fileId: string, ohInstallationAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ohInstallationAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:OhInstallationAudit',
+        recordId: 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 addServiceVisitAuditFiles(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 removeServiceVisitAuditFiles(fileId: string, serviceVisitAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of serviceVisitAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:ServiceVisitAudit',
+        recordId: 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 addOhAuditOfInstallationFiles(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 removeOhAuditOfInstallationFiles(fileId: string, ohAuditOfInstallationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ohAuditOfInstallationIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:OhAuditOfInstallation',
+        recordId: 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 addUgAuditOfInstallationFiles(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 removeUgAuditOfInstallationFiles(fileId: string, ugAuditOfInstallationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ugAuditOfInstallationIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:UgAuditOfInstallation',
+        recordId: 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 addUgInProgressAuditFiles(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 removeUgInProgressAuditFiles(fileId: string, ugInProgressAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ugInProgressAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:UgInProgressAudit',
+        recordId: 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 addOhInProgressAuditFiles(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 removeOhInProgressAuditFiles(fileId: string, ohInProgressAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ohInProgressAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:OhInProgressAudit',
+        recordId: 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 addOverlayRealA55Files(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 removeOverlayRealA55Files(fileId: string, overlayRealA55Ids: string[]) {
+
+   const associationDtos = [];
+   for(const pk of overlayRealA55Ids){
+     associationDtos.push({
+        entity: 'FieldServiceModule:OverlayRealA55',
+        recordId: 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 addOhExternalAuditFiles(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 removeOhExternalAuditFiles(fileId: string, ohExternalAuditIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of ohExternalAuditIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:OhExternalAudit',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, fileId, associationDtos);
+  }
+
+      
+}