@d19n/youfibre-odin-sdk 1.0.1

package/src/api-sdk-v1/WorkOrderApi.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 WorkOrderApi extends ApiProvider {
+
+      private readonly moduleName: string = 'FieldServiceModule';
+      private readonly entityName: string = 'WorkOrder';
+
+      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(workOrderId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, workOrderId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(workOrderId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, workOrderId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(workOrderId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, workOrderId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(workOrderIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, workOrderIds);
+   }
+
+   // 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(workOrderIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, workOrderIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(workOrderIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, workOrderIds);
+   }
+
+  
+    // Use this function when you want to return a single record
+    public async getNotes(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Note');
+    }
+        
+   public async addWorkOrderNotes(workOrderId: string, noteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: param.id,
+          linkType: 'WorkOrder__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderNotes(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getUgAuditOfInstallations(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'UgAuditOfInstallation');
+    }
+        
+   public async addWorkOrderUgAuditOfInstallations(workOrderId: string, ugAuditOfInstallationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ugAuditOfInstallationIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:UgAuditOfInstallation',
+          recordId: param.id,
+          linkType: 'WorkOrder_UgAuditOfInstallation',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderUgAuditOfInstallations(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getContacts(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Contact');
+    }
+        
+   public async addWorkOrderContacts(workOrderId: string, contactIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of contactIds){
+      associationDtos.push({
+          entity: 'CrmModule:Contact',
+          recordId: param.id,
+          linkType: 'WorkOrder__Contact',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderContacts(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getAddresss(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Address');
+    }
+        
+   public async addWorkOrderAddresss(workOrderId: string, addressIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of addressIds){
+      associationDtos.push({
+          entity: 'CrmModule:Address',
+          recordId: param.id,
+          linkType: 'WorkOrder__Address',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderAddresss(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getUgExternalAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'UgExternalAudit');
+    }
+        
+   public async addWorkOrderUgExternalAudits(workOrderId: string, ugExternalAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ugExternalAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:UgExternalAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_UgExternalAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderUgExternalAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getOrderItems(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OrderItem');
+    }
+        
+   public async addWorkOrderOrderItems(workOrderId: string, orderItemIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of orderItemIds){
+      associationDtos.push({
+          entity: 'OrderModule:OrderItem',
+          recordId: param.id,
+          linkType: 'WorkOrder__OrderItem',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderOrderItems(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getAccounts(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Account');
+   }
+        
+   public async addAccountWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async removeAccountWorkOrders(workOrderId: 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, workOrderId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getChangeReasons(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'ChangeReason');
+    }
+        
+   public async addWorkOrderChangeReasons(workOrderId: string, changeReasonIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of changeReasonIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:ChangeReason',
+          recordId: param.id,
+          linkType: 'WorkOrder__ChangeReason',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderChangeReasons(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getFiles(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'File');
+    }
+        
+   public async addWorkOrderFiles(workOrderId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of fileIds){
+      associationDtos.push({
+          entity: 'SchemaModule:File',
+          recordId: param.id,
+          linkType: 'WorkOrder__File',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderFiles(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getInvoices(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Invoice');
+    }
+        
+   public async addWorkOrderInvoices(workOrderId: string, invoiceIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of invoiceIds){
+      associationDtos.push({
+          entity: 'BillingModule:Invoice',
+          recordId: param.id,
+          linkType: 'WorkOrder__Invoice',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderInvoices(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getActivitys(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Activity');
+    }
+        
+   public async addWorkOrderActivitys(workOrderId: string, activityIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of activityIds){
+      associationDtos.push({
+          entity: 'SchemaModule:Activity',
+          recordId: param.id,
+          linkType: 'WorkOrder__Activity',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderActivitys(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getSmsMessages(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'SmsMessage');
+    }
+        
+   public async addWorkOrderSmsMessages(workOrderId: string, smsMessageIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of smsMessageIds){
+      associationDtos.push({
+          entity: 'NotificationModule:SmsMessage',
+          recordId: param.id,
+          linkType: 'WorkOrder__SmsMessage',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderSmsMessages(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getInternalInstallAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'InternalInstallAudit');
+    }
+        
+   public async addWorkOrderInternalInstallAudits(workOrderId: string, internalInstallAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of internalInstallAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:InternalInstallAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_InternalInstallAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderInternalInstallAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getServiceAppointments(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'ServiceAppointment');
+    }
+        
+   public async addWorkOrderServiceAppointments(workOrderId: string, serviceAppointmentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of serviceAppointmentIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:ServiceAppointment',
+          recordId: param.id,
+          linkType: 'WorkOrder_ServiceAppointment',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderServiceAppointments(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getPaymentMethodRefunds(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'PaymentMethodRefund');
+   }
+        
+   public async addPaymentMethodRefundWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async removePaymentMethodRefundWorkOrders(workOrderId: 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, workOrderId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getLeads(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Lead');
+    }
+        
+   public async addWorkOrderLeads(workOrderId: string, leadIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of leadIds){
+      associationDtos.push({
+          entity: 'CrmModule:Lead',
+          recordId: param.id,
+          linkType: 'WorkOrder__Lead',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderLeads(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getNoinstall3AuditOfInstallationSheets(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Noinstall3AuditOfInstallationSheet');
+    }
+        
+   public async addWorkOrderNoinstall3AuditOfInstallationSheets(workOrderId: string, noinstall3AuditOfInstallationSheetIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of noinstall3AuditOfInstallationSheetIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:Noinstall3AuditOfInstallationSheet',
+          recordId: param.id,
+          linkType: 'WorkOrder__Noinstall3AuditOfInstallationSheet',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderNoinstall3AuditOfInstallationSheets(workOrderId: string, noinstall3AuditOfInstallationSheetIds: string[]) {
+
+    const associationDtos = [];
+    for(const pk of noinstall3AuditOfInstallationSheetIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:Noinstall3AuditOfInstallationSheet',
+          recordId: pk,
+      });
+    }
+
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getNetomniaFtth1StageInstallAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'NetomniaFtth1StageInstallAudit');
+    }
+        
+   public async addWorkOrderNetomniaFtth1StageInstallAudits(workOrderId: string, netomniaFtth1StageInstallAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of netomniaFtth1StageInstallAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:NetomniaFtth1StageInstallAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder__NetomniaFtth1StageInstallAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderNetomniaFtth1StageInstallAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getNetomniaInstallVerifications(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'NetomniaInstallVerification');
+    }
+        
+   public async addWorkOrderNetomniaInstallVerifications(workOrderId: string, netomniaInstallVerificationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of netomniaInstallVerificationIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:NetomniaInstallVerification',
+          recordId: param.id,
+          linkType: 'WorkOrder__NetomniaInstallVerification',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderNetomniaInstallVerifications(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getYfEquipmentCollections(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'YfEquipmentCollection');
+    }
+        
+   public async addWorkOrderYfEquipmentCollections(workOrderId: string, yfEquipmentCollectionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of yfEquipmentCollectionIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:YfEquipmentCollection',
+          recordId: param.id,
+          linkType: 'WorkOrder__YfEquipmentCollection',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderYfEquipmentCollections(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrders(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Order');
+   }
+        
+   public async addOrderWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async removeOrderWorkOrders(workOrderId: 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, workOrderId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getServiceAppointmentConfigs(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'ServiceAppointmentConfig');
+    }
+        
+   public async addWorkOrderServiceAppointmentConfigs(workOrderId: string, serviceAppointmentConfigIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of serviceAppointmentConfigIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:ServiceAppointmentConfig',
+          recordId: param.id,
+          linkType: 'WorkOrder__ServiceAppointmentConfig',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderServiceAppointmentConfigs(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getUsers(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'User');
+    }
+        
+   public async addWorkOrderEngineers(workOrderId: string, userIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of userIds){
+      associationDtos.push({
+          entity: 'IdentityModule:User',
+          recordId: param.id,
+          linkType: 'WorkOrderEngineer',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderEngineers(workOrderId: string, userIds: string[]) {
+
+    const associationDtos = [];
+    for(const pk of userIds){
+      associationDtos.push({
+          entity: 'IdentityModule:User',
+          recordId: pk,
+      });
+    }
+
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getRemediationRequiredReasons(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'RemediationRequiredReason');
+    }
+        
+   public async addWorkOrderRemediationRequiredReasons(workOrderId: string, remediationRequiredReasonIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of remediationRequiredReasonIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:RemediationRequiredReason',
+          recordId: param.id,
+          linkType: 'WorkOrder__RemediationRequiredReason',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderRemediationRequiredReasons(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrderRemediationTasks(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OrderRemediationTask');
+   }
+        
+   public async addOrderRemediationTaskWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async removeOrderRemediationTaskWorkOrders(workOrderId: 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, workOrderId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCases(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Case');
+   }
+        
+   public async addCaseWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async removeCaseWorkOrders(workOrderId: 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, workOrderId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCalls(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Call');
+   }
+        
+   public async addCallWorkOrders(workOrderId: string, callIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of callIds){
+     associationDtos.push({
+         entity: 'NotificationModule:Call',
+         recordId: param.id,
+         linkType: 'Call__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async removeCallWorkOrders(workOrderId: string, callIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of callIds){
+     associationDtos.push({
+        entity: 'NotificationModule:Call',
+        recordId: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getPermissionToFails(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'PermissionToFail');
+    }
+        
+   public async addWorkOrderPermissionToFails(workOrderId: string, permissionToFailIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of permissionToFailIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:PermissionToFail',
+          recordId: param.id,
+          linkType: 'WorkOrder__PermissionToFail',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderPermissionToFails(workOrderId: string, permissionToFailIds: string[]) {
+
+    const associationDtos = [];
+    for(const pk of permissionToFailIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:PermissionToFail',
+          recordId: pk,
+      });
+    }
+
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getSweeperMaintenanceAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'SweeperMaintenanceAudit');
+    }
+        
+   public async addWorkOrderSweeperMaintenanceAudits(workOrderId: string, sweeperMaintenanceAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of sweeperMaintenanceAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:SweeperMaintenanceAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder__SweeperMaintenanceAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderSweeperMaintenanceAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getBlockageReportA55s(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'BlockageReportA55');
+    }
+        
+   public async addWorkOrderBlockageReportA55s(workOrderId: string, blockageReportA55Ids: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of blockageReportA55Ids){
+      associationDtos.push({
+          entity: 'FieldServiceModule:BlockageReportA55',
+          recordId: param.id,
+          linkType: 'WorkOrder__BlockageReportA55',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderBlockageReportA55s(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getUgInstallationAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'UgInstallationAudit');
+    }
+        
+   public async addWorkOrderUgInstallationAudits(workOrderId: string, ugInstallationAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ugInstallationAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:UgInstallationAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder__UgInstallationAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderUgInstallationAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getOhInstallationAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhInstallationAudit');
+    }
+        
+   public async addWorkOrderOhInstallationAudits(workOrderId: string, ohInstallationAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ohInstallationAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:OhInstallationAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_OhInstallationAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderOhInstallationAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getWorkOrders(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'WorkOrder');
+    }
+        
+   public async addWorkOrderWorkOrders(workOrderId: 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__WorkOrder',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderWorkOrders(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getOhAuditOfInstallations(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhAuditOfInstallation');
+    }
+        
+   public async addWorkOrderOhAuditOfInstallations(workOrderId: string, ohAuditOfInstallationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ohAuditOfInstallationIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:OhAuditOfInstallation',
+          recordId: param.id,
+          linkType: 'WorkOrder_OhAuditOfInstallation',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderOhAuditOfInstallations(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getTeams(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Team');
+    }
+        
+   public async addWorkOrderTeams(workOrderId: string, teamIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of teamIds){
+      associationDtos.push({
+          entity: 'IdentityModule:Team',
+          recordId: param.id,
+          linkType: 'WorkOrder_Team',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderTeams(workOrderId: string, teamIds: string[]) {
+
+    const associationDtos = [];
+    for(const pk of teamIds){
+      associationDtos.push({
+          entity: 'IdentityModule:Team',
+          recordId: pk,
+      });
+    }
+
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getNetomniaFtthServiceVisitSheets(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'NetomniaFtthServiceVisitSheet');
+    }
+        
+   public async addWorkOrderNetomniaFtthServiceVisitSheets(workOrderId: string, netomniaFtthServiceVisitSheetIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of netomniaFtthServiceVisitSheetIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:NetomniaFtthServiceVisitSheet',
+          recordId: param.id,
+          linkType: 'WorkOrder_NetomniaFtthServiceVisitSheet',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderNetomniaFtthServiceVisitSheets(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getServiceVisitAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'ServiceVisitAudit');
+    }
+        
+   public async addWorkOrderServiceVisitAudits(workOrderId: string, serviceVisitAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of serviceVisitAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:ServiceVisitAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_ServiceVisitAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderServiceVisitAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getYfFieldServiceVisits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'YfFieldServiceVisit');
+    }
+        
+   public async addWorkOrderYfFieldServiceVisits(workOrderId: string, yfFieldServiceVisitIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of yfFieldServiceVisitIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:YfFieldServiceVisit',
+          recordId: param.id,
+          linkType: 'WorkOrder_YfFieldServiceVisit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderYfFieldServiceVisits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getUgInProgressAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'UgInProgressAudit');
+    }
+        
+   public async addWorkOrderUgInProgressAudits(workOrderId: string, ugInProgressAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ugInProgressAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:UgInProgressAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_UgInProgressAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderUgInProgressAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getOhInProgressAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhInProgressAudit');
+    }
+        
+   public async addWorkOrderOhInProgressAudits(workOrderId: string, ohInProgressAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ohInProgressAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:OhInProgressAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_OhInProgressAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderOhInProgressAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getOverlayRealA55s(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OverlayRealA55');
+    }
+        
+   public async addWorkOrderOverlayRealA55s(workOrderId: string, overlayRealA55Ids: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of overlayRealA55Ids){
+      associationDtos.push({
+          entity: 'FieldServiceModule:OverlayRealA55',
+          recordId: param.id,
+          linkType: 'WorkOrder_OverlayRealA55',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderOverlayRealA55s(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getOhExternalAudits(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhExternalAudit');
+    }
+        
+   public async addWorkOrderOhExternalAudits(workOrderId: string, ohExternalAuditIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of ohExternalAuditIds){
+      associationDtos.push({
+          entity: 'FieldServiceModule:OhExternalAudit',
+          recordId: param.id,
+          linkType: 'WorkOrder_OhExternalAudit',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async removeWorkOrderOhExternalAudits(workOrderId: 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, workOrderId, associationDtos);
+   }
+
+      
+}