@d19n/youfibre-odin-sdk 1.0.1

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

@@ -0,0 +1,277 @@
+
+  import { DbProvider } from '@d19n/odin-sdk-generator/dist/db.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 CustomerDeviceRouterDb extends DbProvider {
+  
+      private readonly moduleName: string = 'ServiceModule';
+      private readonly entityName: string = 'CustomerDeviceRouter';
+
+    	constructor(protected readonly principal: any, protected readonly dbService: any) {
+    			super(principal, dbService);
+    	}
+
+  
+   // 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 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(customerDeviceRouterId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, customerDeviceRouterId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(customerDeviceRouterId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, customerDeviceRouterId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(customerDeviceRouterId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, customerDeviceRouterId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(customerDeviceRouterIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, customerDeviceRouterIds);
+   }
+
+   // 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(customerDeviceRouterIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, customerDeviceRouterIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(customerDeviceRouterIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, customerDeviceRouterIds);
+   }
+
+  
+   // Use this function when you want to return a single record
+   public async getCustomerDeviceOnts(customerDeviceRouterId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, customerDeviceRouterId, 'CustomerDeviceOnt');
+   }
+        
+   public async addCustomerDeviceOntCustomerDeviceRouters(customerDeviceRouterId: 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__CustomerDeviceRouter',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, customerDeviceRouterId, associationDtos);
+  }
+
+  public async removeCustomerDeviceOntCustomerDeviceRouters(customerDeviceRouterId: 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, customerDeviceRouterId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrderItems(customerDeviceRouterId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, customerDeviceRouterId, 'OrderItem');
+   }
+        
+   public async addOrderItemCustomerDeviceRouters(customerDeviceRouterId: 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__CustomerDeviceRouter',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, customerDeviceRouterId, associationDtos);
+  }
+
+  public async removeOrderItemCustomerDeviceRouters(customerDeviceRouterId: 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, customerDeviceRouterId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getAddresss(customerDeviceRouterId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, customerDeviceRouterId, 'Address');
+   }
+        
+   public async addAddressCustomerDeviceRouters(customerDeviceRouterId: 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__CustomerDeviceRouter',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, customerDeviceRouterId, associationDtos);
+  }
+
+  public async removeAddressCustomerDeviceRouters(customerDeviceRouterId: 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, customerDeviceRouterId, associationDtos);
+  }
+
+      
+    // Use this function when you want to return a single record
+    public async getNotes(customerDeviceRouterId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, customerDeviceRouterId, 'Note');
+    }
+        
+   public async addCustomerDeviceRouterNotes(customerDeviceRouterId: string, noteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: param.id,
+          linkType: 'CustomerDeviceRouter__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, customerDeviceRouterId, associationDtos);
+   }
+
+   public async removeCustomerDeviceRouterNotes(customerDeviceRouterId: 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, customerDeviceRouterId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getFiles(customerDeviceRouterId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, customerDeviceRouterId, 'File');
+    }
+        
+   public async addCustomerDeviceRouterFiles(customerDeviceRouterId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of fileIds){
+      associationDtos.push({
+          entity: 'SchemaModule:File',
+          recordId: param.id,
+          linkType: 'CustomerDeviceRouter__File',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, customerDeviceRouterId, associationDtos);
+   }
+
+   public async removeCustomerDeviceRouterFiles(customerDeviceRouterId: 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, customerDeviceRouterId, associationDtos);
+   }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrders(customerDeviceRouterId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, customerDeviceRouterId, 'Order');
+   }
+        
+   public async addOrderCustomerDeviceRouters(customerDeviceRouterId: 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__CustomerDeviceRouter',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, customerDeviceRouterId, associationDtos);
+  }
+
+  public async removeOrderCustomerDeviceRouters(customerDeviceRouterId: 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, customerDeviceRouterId, associationDtos);
+  }
+
+      
+}

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

@@ -0,0 +1,102 @@
+
+  import { DbProvider } from '@d19n/odin-sdk-generator/dist/db.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 CustomerPhonePortingDb extends DbProvider {
+  
+      private readonly moduleName: string = 'ServiceModule';
+      private readonly entityName: string = 'CustomerPhonePorting';
+
+    	constructor(protected readonly principal: any, protected readonly dbService: any) {
+    			super(principal, dbService);
+    	}
+
+  
+   // 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 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(customerPhonePortingId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, customerPhonePortingId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(customerPhonePortingId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, customerPhonePortingId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(customerPhonePortingId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, customerPhonePortingId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(customerPhonePortingIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, customerPhonePortingIds);
+   }
+
+   // 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(customerPhonePortingIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, customerPhonePortingIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(customerPhonePortingIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, customerPhonePortingIds);
+   }
+
+  
+   // Use this function when you want to return a single record
+   public async getOrderItems(customerPhonePortingId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, customerPhonePortingId, 'OrderItem');
+   }
+        
+   public async addOrderItemCustomerPhonePortings(customerPhonePortingId: 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__CustomerPhonePorting',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, customerPhonePortingId, associationDtos);
+  }
+
+  public async removeOrderItemCustomerPhonePortings(customerPhonePortingId: 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, customerPhonePortingId, associationDtos);
+  }
+
+      
+}

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

@@ -0,0 +1,67 @@
+
+  import { DbProvider } from '@d19n/odin-sdk-generator/dist/db.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 DashboardDb extends DbProvider {
+  
+      private readonly moduleName: string = 'CrmModule';
+      private readonly entityName: string = 'Dashboard';
+
+    	constructor(protected readonly principal: any, protected readonly dbService: any) {
+    			super(principal, dbService);
+    	}
+
+  
+   // 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 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(dashboardId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, dashboardId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(dashboardId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, dashboardId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(dashboardId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, dashboardId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(dashboardIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, dashboardIds);
+   }
+
+   // 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(dashboardIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, dashboardIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(dashboardIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, dashboardIds);
+   }
+
+  
+}

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

@@ -0,0 +1,172 @@
+
+  import { DbProvider } from '@d19n/odin-sdk-generator/dist/db.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 DeactivationApprovalDb extends DbProvider {
+  
+      private readonly moduleName: string = 'OrderModule';
+      private readonly entityName: string = 'DeactivationApproval';
+
+    	constructor(protected readonly principal: any, protected readonly dbService: any) {
+    			super(principal, dbService);
+    	}
+
+  
+   // 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 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(deactivationApprovalId: string) {
+      return await this._getByPrimaryKey(this.moduleName, this.entityName, deactivationApprovalId);
+   }
+
+   // Use this function when you want to return the versions for a single record
+   public async getVersions(deactivationApprovalId: string) {
+      return await this._getVersions(this.moduleName, this.entityName, deactivationApprovalId);
+   }
+
+   // Use this function when you want to return the change history for a single record
+   public async getRevisionTimeline(deactivationApprovalId: string) {
+      return await this._getRevisionTimeline(this.moduleName, this.entityName, deactivationApprovalId);
+   }
+
+   // Use this function when you want to return many records by primaryKeys
+   public async getManyByPrimaryKey(deactivationApprovalIds: string[]) {
+      return await this._getManyByPrimaryKey(this.moduleName, this.entityName, deactivationApprovalIds);
+   }
+
+   // 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(deactivationApprovalIds: string[]) {
+      return await this._delete(this.moduleName, this.entityName, deactivationApprovalIds);
+   }
+
+   // Use this function when you want to restore one or many records
+   public async restore(deactivationApprovalIds: string[]) {
+      return await this._restore(this.moduleName, this.entityName, deactivationApprovalIds);
+   }
+
+  
+    // Use this function when you want to return a single record
+    public async getOrders(deactivationApprovalId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, deactivationApprovalId, 'Order');
+    }
+        
+   public async addDeactivationApprovalOrders(deactivationApprovalId: string, orderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of orderIds){
+      associationDtos.push({
+          entity: 'OrderModule:Order',
+          recordId: param.id,
+          linkType: 'DeactivationApproval__Order',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, deactivationApprovalId, associationDtos);
+   }
+
+   public async removeDeactivationApprovalOrders(deactivationApprovalId: 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, deactivationApprovalId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getContacts(deactivationApprovalId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, deactivationApprovalId, 'Contact');
+    }
+        
+   public async addDeactivationApprovalContacts(deactivationApprovalId: string, contactIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of contactIds){
+      associationDtos.push({
+          entity: 'CrmModule:Contact',
+          recordId: param.id,
+          linkType: 'DeactivationApproval__Contact',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, deactivationApprovalId, associationDtos);
+   }
+
+   public async removeDeactivationApprovalContacts(deactivationApprovalId: 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, deactivationApprovalId, associationDtos);
+   }
+
+      
+    // Use this function when you want to return a single record
+    public async getNotes(deactivationApprovalId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, deactivationApprovalId, 'Note');
+    }
+        
+   public async addDeactivationApprovalNotes(deactivationApprovalId: string, noteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: param.id,
+          linkType: 'DeactivationApproval__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, deactivationApprovalId, associationDtos);
+   }
+
+   public async removeDeactivationApprovalNotes(deactivationApprovalId: 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, deactivationApprovalId, associationDtos);
+   }
+
+      
+}