@d19n/youfibre-odin-sdk 1.0.1

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

@@ -0,0 +1,2142 @@
+
+  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 NoteApi extends ApiProvider {
+
+      private readonly moduleName: string = 'SupportModule';
+      private readonly entityName: string = 'Note';
+
+      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(noteId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, noteId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(noteId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, noteId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(noteId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, noteId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(noteIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, noteIds);
+   }
+
+   // 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(noteIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, noteIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(noteIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, noteIds);
+   }
+
+  
+   // Use this function when you want to return a single record
+   public async getUgExternalAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'UgExternalAudit');
+   }
+        
+   public async addUgExternalAuditNotes(noteId: 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_Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeUgExternalAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getWorkOrders(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'WorkOrder');
+   }
+        
+   public async addWorkOrderNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeWorkOrderNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getAppointments(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Appointment');
+   }
+        
+   public async addAppointmentNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeAppointmentNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getContacts(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Contact');
+   }
+        
+   public async addContactNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeContactNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getLeads(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Lead');
+   }
+        
+   public async addLeadNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeLeadNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrders(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Order');
+   }
+        
+   public async addOrderNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOrderNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getAccounts(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Account');
+   }
+        
+   public async addAccountNotes(noteId: string, accountIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of accountIds){
+     associationDtos.push({
+         entity: 'CrmModule:Account',
+         recordId: param.id,
+         linkType: 'Account__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeAccountNotes(noteId: string, accountIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of accountIds){
+     associationDtos.push({
+        entity: 'CrmModule:Account',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getPrograms(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Program');
+   }
+        
+   public async addProgramNotes(noteId: string, programIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of programIds){
+     associationDtos.push({
+         entity: 'ProjectModule:Program',
+         recordId: param.id,
+         linkType: 'Program__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeProgramNotes(noteId: string, programIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of programIds){
+     associationDtos.push({
+        entity: 'ProjectModule:Program',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getProjects(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Project');
+   }
+        
+   public async addProjectNotes(noteId: string, projectIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of projectIds){
+     associationDtos.push({
+         entity: 'ProjectModule:Project',
+         recordId: param.id,
+         linkType: 'Project__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeProjectNotes(noteId: string, projectIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of projectIds){
+     associationDtos.push({
+        entity: 'ProjectModule:Project',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getInvoices(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Invoice');
+   }
+        
+   public async addInvoiceNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeInvoiceNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getMilestones(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Milestone');
+   }
+        
+   public async addMilestoneNotes(noteId: string, milestoneIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of milestoneIds){
+     associationDtos.push({
+         entity: 'ProjectModule:Milestone',
+         recordId: param.id,
+         linkType: 'Milestone__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeMilestoneNotes(noteId: string, milestoneIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of milestoneIds){
+     associationDtos.push({
+        entity: 'ProjectModule:Milestone',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getTasks(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Task');
+   }
+        
+   public async addTaskNotes(noteId: string, taskIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of taskIds){
+     associationDtos.push({
+         entity: 'ProjectModule:Task',
+         recordId: param.id,
+         linkType: 'Task__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeTaskNotes(noteId: string, taskIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of taskIds){
+     associationDtos.push({
+        entity: 'ProjectModule:Task',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getSubtasks(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Subtask');
+   }
+        
+   public async addSubtaskNotes(noteId: string, subtaskIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of subtaskIds){
+     associationDtos.push({
+         entity: 'ProjectModule:Subtask',
+         recordId: param.id,
+         linkType: 'Subtask__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeSubtaskNotes(noteId: string, subtaskIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of subtaskIds){
+     associationDtos.push({
+        entity: 'ProjectModule:Subtask',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getFiles(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'File');
+   }
+        
+   public async addFileNotes(noteId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of fileIds){
+     associationDtos.push({
+         entity: 'SchemaModule:File',
+         recordId: param.id,
+         linkType: 'File__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeFileNotes(noteId: string, fileIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of fileIds){
+     associationDtos.push({
+        entity: 'SchemaModule:File',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getDiscounts(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Discount');
+   }
+        
+   public async addDiscountNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeDiscountNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getBillingAdjustments(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'BillingAdjustment');
+   }
+        
+   public async addBillingAdjustmentNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeBillingAdjustmentNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrderItems(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OrderItem');
+   }
+        
+   public async addOrderItemNotes(noteId: string, orderItemIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of orderItemIds){
+     associationDtos.push({
+         entity: 'OrderModule:OrderItem',
+         recordId: param.id,
+         linkType: 'OrderItem__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOrderItemNotes(noteId: string, orderItemIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of orderItemIds){
+     associationDtos.push({
+        entity: 'OrderModule:OrderItem',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getTransactions(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Transaction');
+   }
+        
+   public async addTransactionNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeTransactionNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getServiceAppointmentConfigs(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'ServiceAppointmentConfig');
+   }
+        
+   public async addServiceAppointmentConfigNotes(noteId: string, serviceAppointmentConfigIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of serviceAppointmentConfigIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:ServiceAppointmentConfig',
+         recordId: param.id,
+         linkType: 'ServiceAppointmentConfig__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeServiceAppointmentConfigNotes(noteId: string, serviceAppointmentConfigIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of serviceAppointmentConfigIds){
+     associationDtos.push({
+        entity: 'FieldServiceModule:ServiceAppointmentConfig',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCommissions(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Commission');
+   }
+        
+   public async addCommissionNotes(noteId: string, commissionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of commissionIds){
+     associationDtos.push({
+         entity: 'BillingModule:Commission',
+         recordId: param.id,
+         linkType: 'Commission__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeCommissionNotes(noteId: string, commissionIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of commissionIds){
+     associationDtos.push({
+        entity: 'BillingModule:Commission',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getInternalInstallAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'InternalInstallAudit');
+   }
+        
+   public async addInternalInstallAuditNotes(noteId: 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_Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeInternalInstallAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getChurnRequests(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'ChurnRequest');
+   }
+        
+   public async addChurnRequestNotes(noteId: string, churnRequestIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of churnRequestIds){
+     associationDtos.push({
+         entity: 'OrderModule:ChurnRequest',
+         recordId: param.id,
+         linkType: 'ChurnRequest__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeChurnRequestNotes(noteId: string, churnRequestIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of churnRequestIds){
+     associationDtos.push({
+        entity: 'OrderModule:ChurnRequest',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getPICRequests(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'PICRequest');
+   }
+        
+   public async addPicRequestNotes(noteId: string, picRequestIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of picRequestIds){
+     associationDtos.push({
+         entity: 'OrderModule:PICRequest',
+         recordId: param.id,
+         linkType: 'PICRequest__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removePicRequestNotes(noteId: string, picRequestIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of picRequestIds){
+     associationDtos.push({
+        entity: 'OrderModule:PICRequest',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getAddresss(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Address');
+   }
+        
+   public async addAddressNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeAddressNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCreditNotes(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'CreditNote');
+   }
+        
+   public async addCreditNoteNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeCreditNoteNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getPaymentMethods(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'PaymentMethod');
+   }
+        
+   public async addPaymentMethodNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removePaymentMethodNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCustomerDeviceOnts(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'CustomerDeviceOnt');
+   }
+        
+   public async addCustomerDeviceOntNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeCustomerDeviceOntNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getChangeReasons(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'ChangeReason');
+   }
+        
+   public async addChangeReasonNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeChangeReasonNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getPaymentMethodRefunds(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'PaymentMethodRefund');
+   }
+        
+   public async addPaymentMethodRefundNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removePaymentMethodRefundNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getServiceAppointments(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'ServiceAppointment');
+   }
+        
+   public async addServiceAppointmentNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeServiceAppointmentNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getActivitys(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Activity');
+   }
+        
+   public async addActivityNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeActivityNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getBillingRequests(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'BillingRequest');
+   }
+        
+   public async addBillingRequestNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeBillingRequestNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getSupportTasks(noteId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, noteId, 'SupportTask');
+    }
+        
+   public async addNoteSupportTasks(noteId: string, supportTaskIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of supportTaskIds){
+      associationDtos.push({
+          entity: 'SupportModule:SupportTask',
+          recordId: param.id,
+          linkType: 'Note_SupportTask',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+   }
+
+   public async removeNoteSupportTasks(noteId: string, supportTaskIds: string[]) {
+
+    const associationDtos = [];
+    for(const pk of supportTaskIds){
+      associationDtos.push({
+          entity: 'SupportModule:SupportTask',
+          recordId: pk,
+      });
+    }
+
+     return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getNetomniaInstallVerifications(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'NetomniaInstallVerification');
+   }
+        
+   public async addNetomniaInstallVerificationNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeNetomniaInstallVerificationNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getNetomniaFtthServiceVisitSheets(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'NetomniaFtthServiceVisitSheet');
+   }
+        
+   public async addNetomniaFtthServiceVisitSheetNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeNetomniaFtthServiceVisitSheetNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getNetomniaFtth1StageInstallAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'NetomniaFtth1StageInstallAudit');
+   }
+        
+   public async addNetomniaFtth1StageInstallAuditNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeNetomniaFtth1StageInstallAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCustomerDeviceRouters(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'CustomerDeviceRouter');
+   }
+        
+   public async addCustomerDeviceRouterNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeCustomerDeviceRouterNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getVisits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Visit');
+   }
+        
+   public async addVisitNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeVisitNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCrmDatasets(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'CrmDataset');
+   }
+        
+   public async addCrmDatasetNotes(noteId: string, crmDatasetIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of crmDatasetIds){
+     associationDtos.push({
+         entity: 'CrmModule:CrmDataset',
+         recordId: param.id,
+         linkType: 'CrmDataset__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeCrmDatasetNotes(noteId: string, crmDatasetIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of crmDatasetIds){
+     associationDtos.push({
+        entity: 'CrmModule:CrmDataset',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getYfEquipmentCollections(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'YfEquipmentCollection');
+   }
+        
+   public async addYfEquipmentCollectionNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeYfEquipmentCollectionNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getFingerprints(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Fingerprint');
+   }
+        
+   public async addFingerprintNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeFingerprintNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getYfFieldServiceVisits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'YfFieldServiceVisit');
+   }
+        
+   public async addYfFieldServiceVisitNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeYfFieldServiceVisitNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getRemediationRequiredReasons(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'RemediationRequiredReason');
+   }
+        
+   public async addRemediationRequiredReasonNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeRemediationRequiredReasonNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getDeactivationApprovals(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'DeactivationApproval');
+   }
+        
+   public async addDeactivationApprovalNotes(noteId: string, deactivationApprovalIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of deactivationApprovalIds){
+     associationDtos.push({
+         entity: 'OrderModule:DeactivationApproval',
+         recordId: param.id,
+         linkType: 'DeactivationApproval__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeDeactivationApprovalNotes(noteId: string, deactivationApprovalIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of deactivationApprovalIds){
+     associationDtos.push({
+        entity: 'OrderModule:DeactivationApproval',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrderRemediationTasks(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OrderRemediationTask');
+   }
+        
+   public async addOrderRemediationTaskNotes(noteId: string, orderRemediationTaskIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of orderRemediationTaskIds){
+     associationDtos.push({
+         entity: 'OrderModule:OrderRemediationTask',
+         recordId: param.id,
+         linkType: 'OrderRemediationTask__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOrderRemediationTaskNotes(noteId: string, orderRemediationTaskIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of orderRemediationTaskIds){
+     associationDtos.push({
+        entity: 'OrderModule:OrderRemediationTask',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCases(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'Case');
+   }
+        
+   public async addCaseNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeCaseNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getSmsMessages(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'SmsMessage');
+   }
+        
+   public async addSmsMessageNotes(noteId: string, smsMessageIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of smsMessageIds){
+     associationDtos.push({
+         entity: 'NotificationModule:SmsMessage',
+         recordId: param.id,
+         linkType: 'SmsMessage__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeSmsMessageNotes(noteId: string, smsMessageIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of smsMessageIds){
+     associationDtos.push({
+        entity: 'NotificationModule:SmsMessage',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getNotes(noteId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, noteId, 'Note');
+    }
+        
+   public async addNoteNotes(noteId: string, noteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: param.id,
+          linkType: 'Note__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+   }
+
+   public async removeNoteNotes(noteId: 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, noteId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getSweeperMaintenanceAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'SweeperMaintenanceAudit');
+   }
+        
+   public async addSweeperMaintenanceAuditNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeSweeperMaintenanceAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getBlockageReportA55s(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'BlockageReportA55');
+   }
+        
+   public async addBlockageReportA55Notes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeBlockageReportA55Notes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getUgInstallationAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'UgInstallationAudit');
+   }
+        
+   public async addUgInstallationAuditNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeUgInstallationAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhInstallationAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OhInstallationAudit');
+   }
+        
+   public async addOhInstallationAuditNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOhInstallationAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getServiceVisitAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'ServiceVisitAudit');
+   }
+        
+   public async addServiceVisitAuditNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeServiceVisitAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhAuditOfInstallations(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OhAuditOfInstallation');
+   }
+        
+   public async addOhAuditOfInstallationNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOhAuditOfInstallationNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getUgAuditOfInstallations(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'UgAuditOfInstallation');
+   }
+        
+   public async addUgAuditOfInstallationNotes(noteId: 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__Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeUgAuditOfInstallationNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getUgInProgressAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'UgInProgressAudit');
+   }
+        
+   public async addUgInProgressAuditNotes(noteId: 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_Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeUgInProgressAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhInProgressAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OhInProgressAudit');
+   }
+        
+   public async addOhInProgressAuditNotes(noteId: 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_Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOhInProgressAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOverlayRealA55s(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OverlayRealA55');
+   }
+        
+   public async addOverlayRealA55Notes(noteId: 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_Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOverlayRealA55Notes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOhExternalAudits(noteId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, noteId, 'OhExternalAudit');
+   }
+        
+   public async addOhExternalAuditNotes(noteId: 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_Note',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+  }
+
+  public async removeOhExternalAuditNotes(noteId: 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, noteId, associationDtos);
+  }
+
+      
+}