diff --git a/cypress/e2e/fixtures/api/eventlog.ts b/cypress/e2e/fixtures/api/eventlog.ts
index 77eafb2bf..b46854a55 100644
--- a/cypress/e2e/fixtures/api/eventlog.ts
+++ b/cypress/e2e/fixtures/api/eventlog.ts
@@ -167,6 +167,73 @@ const eventLogs = {
         IDER: false
       }
     }
+  },
+  remotePlatformErase: {
+    notSupported: {
+      response: {
+        userConsent: 'none',
+        optInState: 0,
+        redirection: true,
+        KVM: true,
+        SOL: true,
+        IDER: false,
+        kvmAvailable: false,
+        ocr: false,
+        httpsBootSupported: false,
+        winREBootSupported: false,
+        localPBABootSupported: false,
+        rpe: false,
+        rpeSupported: false,
+        pbaBootFilesPath: [],
+        winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
+      }
+    },
+    supportedDisabled: {
+      response: {
+        userConsent: 'none',
+        optInState: 0,
+        redirection: true,
+        KVM: true,
+        SOL: true,
+        IDER: false,
+        kvmAvailable: false,
+        ocr: false,
+        httpsBootSupported: false,
+        winREBootSupported: false,
+        localPBABootSupported: false,
+        rpe: false,
+        rpeSupported: true,
+        pbaBootFilesPath: [],
+        winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
+      }
+    },
+    supportedEnabled: {
+      response: {
+        userConsent: 'none',
+        optInState: 0,
+        redirection: true,
+        KVM: true,
+        SOL: true,
+        IDER: false,
+        kvmAvailable: false,
+        ocr: false,
+        httpsBootSupported: false,
+        winREBootSupported: false,
+        localPBABootSupported: false,
+        rpe: true,
+        rpeSupported: true,
+        pbaBootFilesPath: [],
+        winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
+      }
+    },
+    capabilities: {
+      response: {
+        secureEraseAllSSDs: true,
+        tpmClear: false,
+        restoreBIOSToEOM: true,
+        unconfigureCSME: false
+      }
+    }
   }
 }
 
diff --git a/cypress/e2e/integration/device/remote-platform-erase.spec.ts b/cypress/e2e/integration/device/remote-platform-erase.spec.ts
new file mode 100644
index 000000000..8e0d386ee
--- /dev/null
+++ b/cypress/e2e/integration/device/remote-platform-erase.spec.ts
@@ -0,0 +1,258 @@
+/*********************************************************************
+ * Copyright (c) Intel Corporation 2022
+ * SPDX-License-Identifier: Apache-2.0
+ **********************************************************************/
+
+import { httpCodes } from '../../fixtures/api/httpCodes'
+import { eventLogs } from '../../fixtures/api/eventlog'
+
+const describeWhenNotCloud = Cypress.env('CLOUD') ? describe.skip : describe
+
+const navigateToRemotePlatformErase = (
+  featuresBody: object = eventLogs.remotePlatformErase.supportedDisabled.response
+): void => {
+  cy.myIntercept('GET', /.*amt\/features.*/, {
+    statusCode: httpCodes.SUCCESS,
+    body: featuresBody
+  }).as('get-features')
+
+  cy.myIntercept('GET', 'devices?$top=25&$skip=0&$count=true', {
+    statusCode: httpCodes.SUCCESS,
+    body: eventLogs.devices.success.response
+  }).as('get-devices')
+
+  cy.myIntercept('GET', /devices\/.*$/, {
+    statusCode: httpCodes.SUCCESS,
+    body: eventLogs.devices.success.response
+  }).as('get-device-by-id')
+
+  cy.myIntercept('GET', /devices\/tags/, {
+    statusCode: httpCodes.SUCCESS,
+    body: []
+  }).as('get-tags')
+
+  cy.myIntercept('GET', /.*power.*/, {
+    statusCode: httpCodes.SUCCESS,
+    body: { powerstate: 2 }
+  }).as('get-powerstate')
+
+  cy.myIntercept('GET', /.*general.*/, {
+    statusCode: httpCodes.SUCCESS,
+    body: eventLogs.general.success.response
+  }).as('get-general')
+
+  cy.myIntercept('GET', /.*version.*/, {
+    statusCode: httpCodes.SUCCESS,
+    body: eventLogs.version.success.response
+  }).as('get-version')
+
+  cy.myIntercept('GET', /.*amt\/boot\/remoteErase.*/, {
+    statusCode: httpCodes.SUCCESS,
+    body: eventLogs.remotePlatformErase.capabilities.response
+  }).as('get-capabilities')
+
+  cy.myIntercept('GET', /.*alarmOccurrences.*/, {
+    statusCode: httpCodes.SUCCESS,
+    body: eventLogs.alarmOccurrences.success.response
+  }).as('get-alarms')
+
+  cy.goToPage('Devices')
+  cy.wait('@get-devices').its('response.statusCode').should('eq', 200)
+
+  cy.get('mat-row').first().click()
+  cy.wait('@get-device-by-id').its('response.statusCode').should('eq', 200)
+
+  cy.get('.mat-mdc-list-item-title').contains('Remote Platform Erase').click()
+  cy.wait('@get-capabilities')
+  // Wait for Angular to finish loading (isLoading signal → mat-progress-bar disappears)
+  cy.get('mat-progress-bar').should('not.exist')
+}
+
+describeWhenNotCloud('Remote Platform Erase', () => {
+  beforeEach(() => {
+    cy.setup()
+  })
+
+  it('should show "not supported" message when remoteEraseSupported is false', () => {
+    navigateToRemotePlatformErase(eventLogs.remotePlatformErase.notSupported.response)
+    cy.wait('@get-features')
+
+    cy.get('[data-cy="remoteEraseCheckbox"]').should('not.exist')
+    cy.get('mat-icon').contains('info').should('exist')
+  })
+
+  it('should show checkbox when supported but not enabled', () => {
+    navigateToRemotePlatformErase(eventLogs.remotePlatformErase.supportedDisabled.response)
+    cy.wait('@get-features')
+
+    cy.get('[data-cy="remoteEraseCheckbox"]').should('exist')
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]').should('have.attr', 'aria-checked', 'false')
+    cy.get('[data-cy="initiateEraseButton"]').should('not.exist')
+  })
+
+  it('should show checkbox checked when rpe is true in API response', () => {
+    navigateToRemotePlatformErase(eventLogs.remotePlatformErase.supportedEnabled.response)
+    cy.wait('@get-features')
+
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]').should('have.attr', 'aria-checked', 'true')
+    cy.get('[data-cy="initiateEraseButton"]').should('be.visible')
+  })
+
+  it('should enable the feature and show initiate erase button after toggling on', () => {
+    cy.myIntercept('POST', /.*amt\/features.*/, {
+      statusCode: httpCodes.SUCCESS,
+      body: eventLogs.remotePlatformErase.supportedEnabled.response
+    }).as('post-features')
+
+    navigateToRemotePlatformErase()
+    cy.wait('@get-features')
+
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features').its('request.body.rpe').should('eq', true)
+
+    cy.get('[data-cy="initiateEraseButton"]').should('be.visible')
+  })
+
+  it('should disable the feature after toggling off', () => {
+    // Register disable handler first (LIFO: last registered = first matched)
+    // so the second POST (disable click) hits the disable response
+    cy.intercept(
+      { method: 'POST', url: /.*amt\/features.*/, times: 1 },
+      {
+        statusCode: httpCodes.SUCCESS,
+        body: eventLogs.remotePlatformErase.supportedDisabled.response
+      }
+    ).as('post-features-disable')
+
+    // Register enable handler second so it matches the first POST (enable click)
+    cy.intercept(
+      { method: 'POST', url: /.*amt\/features.*/, times: 1 },
+      {
+        statusCode: httpCodes.SUCCESS,
+        body: eventLogs.remotePlatformErase.supportedEnabled.response
+      }
+    ).as('post-features-enable')
+
+    navigateToRemotePlatformErase()
+    cy.wait('@get-features')
+
+    // Enable first
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features-enable').its('request.body.rpe').should('eq', true)
+
+    // Then disable
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features-disable').its('request.body.rpe').should('eq', false)
+
+    cy.get('[data-cy="initiateEraseButton"]').should('not.exist')
+  })
+
+  it('should call the remoteErase API when erase is confirmed in the dialog', () => {
+    cy.myIntercept('POST', /.*amt\/features.*/, {
+      statusCode: httpCodes.SUCCESS,
+      body: eventLogs.remotePlatformErase.supportedEnabled.response
+    }).as('post-features')
+
+    cy.myIntercept('POST', /.*amt\/boot\/remoteErase.*/, {
+      statusCode: httpCodes.SUCCESS,
+      body: {}
+    }).as('post-erase')
+
+    navigateToRemotePlatformErase()
+    cy.wait('@get-features')
+
+    // Enable the feature first
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features')
+
+    cy.get('[data-cy="eraseCapCheckbox"]').first().find('input[type="checkbox"]').check({ force: true })
+    cy.get('[data-cy="initiateEraseButton"]').click()
+
+    cy.get('mat-dialog-container').should('be.visible')
+    cy.get('mat-dialog-container').contains('button', 'Yes').click()
+
+    cy.wait('@post-erase').its('response.statusCode').should('eq', 200)
+  })
+
+  it('should not call the remoteErase API when erase is cancelled', () => {
+    cy.myIntercept('POST', /.*amt\/features.*/, {
+      statusCode: httpCodes.SUCCESS,
+      body: eventLogs.remotePlatformErase.supportedEnabled.response
+    }).as('post-features')
+
+    cy.myIntercept('POST', /.*amt\/boot\/remoteErase.*/, {
+      statusCode: httpCodes.SUCCESS,
+      body: {}
+    }).as('post-erase')
+
+    navigateToRemotePlatformErase()
+    cy.wait('@get-features')
+
+    // Enable the feature first
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features')
+
+    cy.get('[data-cy="eraseCapCheckbox"]').first().find('input[type="checkbox"]').check({ force: true })
+    cy.get('[data-cy="initiateEraseButton"]').click()
+
+    cy.get('mat-dialog-container').should('be.visible')
+    cy.get('mat-dialog-container').contains('button', 'No').click()
+
+    cy.get('@post-erase.all').should('have.length', 0)
+  })
+
+  it('should show error snackbar when toggling feature fails', () => {
+    cy.myIntercept('POST', /.*amt\/features.*/, {
+      statusCode: httpCodes.INTERNAL_SERVER_ERROR,
+      body: {}
+    }).as('post-features-error')
+
+    navigateToRemotePlatformErase()
+    cy.wait('@get-features')
+
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features-error')
+
+    cy.get('mat-snack-bar-container').should('be.visible')
+  })
+
+  it('should show error snackbar when erase API fails', () => {
+    cy.myIntercept('POST', /.*amt\/features.*/, {
+      statusCode: httpCodes.SUCCESS,
+      body: eventLogs.remotePlatformErase.supportedEnabled.response
+    }).as('post-features')
+
+    cy.myIntercept('POST', /.*amt\/boot\/remoteErase.*/, {
+      statusCode: httpCodes.INTERNAL_SERVER_ERROR,
+      body: {}
+    }).as('post-erase-error')
+
+    navigateToRemotePlatformErase()
+    cy.wait('@get-features')
+
+    // Enable the feature first
+    cy.get('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+      .should('not.have.attr', 'aria-disabled', 'true')
+      .click()
+    cy.wait('@post-features')
+
+    cy.get('[data-cy="eraseCapCheckbox"]').first().find('input[type="checkbox"]').check({ force: true })
+    cy.get('[data-cy="initiateEraseButton"]').click()
+    cy.get('mat-dialog-container').contains('button', 'Yes').click()
+
+    cy.wait('@post-erase-error')
+    cy.get('mat-snack-bar-container').should('be.visible')
+  })
+})
diff --git a/src/app/devices/device-detail/device-detail.component.html b/src/app/devices/device-detail/device-detail.component.html
index 28f60dbad..4670936b8 100644
--- a/src/app/devices/device-detail/device-detail.component.html
+++ b/src/app/devices/device-detail/device-detail.component.html
@@ -68,6 +68,9 @@ <h3 matListItemTitle>{{ item.name | translate }}</h3>
       @case ('tls') {
         <app-tls [deviceId]="deviceId"></app-tls>
       }
+      @case ('remote-platform-erase') {
+        <app-remote-platform-erase [deviceId]="deviceId"></app-remote-platform-erase>
+      }
     }
   </mat-sidenav-content>
 </mat-sidenav-container>
diff --git a/src/app/devices/device-detail/device-detail.component.ts b/src/app/devices/device-detail/device-detail.component.ts
index c1a605f45..bb94b971e 100644
--- a/src/app/devices/device-detail/device-detail.component.ts
+++ b/src/app/devices/device-detail/device-detail.component.ts
@@ -25,6 +25,7 @@ import { GeneralComponent } from '../general/general.component'
 import { NetworkSettingsComponent } from '../network-settings/network-settings.component'
 import { environment } from '../../../environments/environment'
 import { TLSComponent } from '../tls/tls.component'
+import { RemotePlatformEraseComponent } from '../remote-platform-erase/remote-platform-erase.component'
 import { TranslatePipe } from '@ngx-translate/core'
 
 @Component({
@@ -58,6 +59,7 @@ import { TranslatePipe } from '@ngx-translate/core'
     RouterLinkActive,
     NetworkSettingsComponent,
     TLSComponent,
+    RemotePlatformEraseComponent,
     TranslatePipe
   ]
 })
@@ -117,6 +119,12 @@ export class DeviceDetailComponent implements OnInit, OnDestroy {
       description: 'deviceDetail.certificatesDescription.value',
       component: 'certificates',
       icon: 'verified'
+    },
+    {
+      name: 'deviceDetail.remotePlatformErase.value',
+      description: 'deviceDetail.remotePlatformEraseDescription.value',
+      component: 'remote-platform-erase',
+      icon: 'computer_cancel'
     }
   ]
 
diff --git a/src/app/devices/device-toolbar/device-toolbar.component.spec.ts b/src/app/devices/device-toolbar/device-toolbar.component.spec.ts
index 714f3c95d..6642e6582 100644
--- a/src/app/devices/device-toolbar/device-toolbar.component.spec.ts
+++ b/src/app/devices/device-toolbar/device-toolbar.component.spec.ts
@@ -69,7 +69,8 @@ describe('DeviceToolbarComponent', () => {
       kvmAvailable: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpe: true,
+      rpeSupported: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
diff --git a/src/app/devices/devices.service.spec.ts b/src/app/devices/devices.service.spec.ts
index e903849ab..8592eb2fa 100644
--- a/src/app/devices/devices.service.spec.ts
+++ b/src/app/devices/devices.service.spec.ts
@@ -92,7 +92,8 @@ describe('DevicesService', () => {
       httpsBootSupported: false,
       winREBootSupported: false,
       localPBABootSupported: false,
-      remoteErase: false,
+      rpe: false,
+      rpeSupported: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -559,7 +560,8 @@ describe('DevicesService', () => {
         httpsBootSupported: false,
         winREBootSupported: false,
         localPBABootSupported: false,
-        remoteErase: false,
+        rpe: true,
+        rpeSupported: true,
         pbaBootFilesPath: [],
         winREBootFilesPath: {
           instanceID: '',
@@ -576,7 +578,7 @@ describe('DevicesService', () => {
         ocr: true,
         winREBootSupported: true,
         localPBABootSupported: true,
-        remoteErase: true
+        rpe: true
       }
 
       service.setAmtFeatures('device1', payload).subscribe((response) => {
@@ -585,11 +587,18 @@ describe('DevicesService', () => {
 
       const req = httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`)
       expect(req.request.method).toBe('POST')
-      expect(req.request.body).toEqual(payload)
+      expect(req.request.body).toEqual({
+        userConsent: 'none',
+        enableKVM: true,
+        enableSOL: true,
+        enableIDER: true,
+        ocr: true,
+        platformEraseEnabled: true
+      })
       req.flush(mockResponse)
     })
 
-    it('reflects the chosen settings in the featuresChanges stream without caching the POST response', () => {
+    it('merges server response onto the cached features after setAmtFeatures', () => {
       const seeded: AMTFeaturesResponse = {
         userConsent: 'none',
         optInState: 0,
@@ -602,7 +611,8 @@ describe('DevicesService', () => {
         httpsBootSupported: true,
         winREBootSupported: true,
         localPBABootSupported: true,
-        remoteErase: false,
+        rpe: false,
+        rpeSupported: true,
         pbaBootFilesPath: [],
         winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
       }
@@ -620,11 +630,19 @@ describe('DevicesService', () => {
         enableSOL: true,
         enableIDER: true,
         ocr: true,
-        remoteErase: true
+        rpe: true
       }
       service.setAmtFeatures('device1', payload).subscribe()
-      // cloud-style POST response: a status object, not a full features payload
-      httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({ status: 'SUCCESS' } as any)
+      // server returns the full applied features
+      httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({
+        userConsent: 'all',
+        KVM: false,
+        SOL: true,
+        IDER: true,
+        ocr: true,
+        rpe: true,
+        redirection: true
+      } as any)
       // no refetch is triggered
       httpMock.expectNone(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`)
 
@@ -634,13 +652,63 @@ describe('DevicesService', () => {
       expect(latest.IDER).toBe(true)
       expect(latest.ocr).toBe(true)
       expect(latest.userConsent).toBe('all')
-      expect(latest.remoteErase).toBe(true)
+      expect(latest.rpe).toBe(true)
       // untouched fields are preserved from the cached features
       expect(latest.kvmAvailable).toBe(true)
       expect(latest.httpsBootSupported).toBe(true)
       expect((latest as any).status).toBeUndefined()
     })
 
+    it('keeps the cached rpe value when a stale GET response arrives after a save', () => {
+      const seeded: AMTFeaturesResponse = {
+        userConsent: 'none',
+        optInState: 0,
+        redirection: true,
+        kvmAvailable: true,
+        KVM: true,
+        SOL: false,
+        IDER: false,
+        ocr: false,
+        httpsBootSupported: true,
+        winREBootSupported: true,
+        localPBABootSupported: true,
+        rpe: true,
+        rpeSupported: true,
+        pbaBootFilesPath: [],
+        winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
+      }
+      const emitted: AMTFeaturesResponse[] = []
+      service.featuresChanges('device1').subscribe((v) => {
+        if (v) emitted.push(v)
+      })
+      service.getAMTFeatures('device1').subscribe()
+      httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush(seeded)
+
+      service
+        .setAmtFeatures('device1', {
+          userConsent: 'all',
+          enableKVM: true,
+          enableSOL: true,
+          enableIDER: true,
+          ocr: true,
+          rpe: false
+        })
+        .subscribe()
+      httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({ status: 'SUCCESS' } as any)
+
+      let latestGet: AMTFeaturesResponse | undefined
+      service.getAMTFeatures('device1').subscribe((r) => {
+        latestGet = r
+      })
+      httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({
+        ...seeded,
+        rpe: true
+      })
+
+      expect(emitted[emitted.length - 1].rpe).toBe(false)
+      expect(latestGet?.rpe).toBe(false)
+    })
+
     it('derives redirection from the chosen features rather than keeping the stale cached value', () => {
       const seeded: AMTFeaturesResponse = {
         userConsent: 'none',
@@ -654,7 +722,8 @@ describe('DevicesService', () => {
         httpsBootSupported: false,
         winREBootSupported: false,
         localPBABootSupported: false,
-        remoteErase: false,
+        rpeSupported: false,
+        rpe: false,
         pbaBootFilesPath: [],
         winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
       }
@@ -673,7 +742,7 @@ describe('DevicesService', () => {
           enableSOL: false,
           enableIDER: false,
           ocr: false,
-          remoteErase: false
+          rpe: false
         })
         .subscribe()
       httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({ status: 'SUCCESS' } as any)
@@ -694,7 +763,8 @@ describe('DevicesService', () => {
         httpsBootSupported: false,
         winREBootSupported: false,
         localPBABootSupported: false,
-        remoteErase: false,
+        rpeSupported: false,
+        rpe: false,
         pbaBootFilesPath: [],
         winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
       }
@@ -712,7 +782,7 @@ describe('DevicesService', () => {
           enableSOL: false,
           enableIDER: false,
           ocr: false,
-          remoteErase: false
+          rpe: false
         })
         .subscribe()
       httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({ status: 'SUCCESS' } as any)
@@ -730,7 +800,7 @@ describe('DevicesService', () => {
           enableSOL: true,
           enableIDER: true,
           ocr: true,
-          remoteErase: true
+          rpe: true
         })
         .subscribe()
       httpMock.expectOne(`${mockEnvironment.mpsServer}/api/v1/amt/features/device1`).flush({ status: 'SUCCESS' } as any)
diff --git a/src/app/devices/devices.service.ts b/src/app/devices/devices.service.ts
index cf29ee363..815f12a52 100644
--- a/src/app/devices/devices.service.ts
+++ b/src/app/devices/devices.service.ts
@@ -31,7 +31,9 @@ import {
   BootDetails,
   BootSource,
   DisplaySelectionResponse,
-  DisplaySelectionRequest
+  DisplaySelectionRequest,
+  RemoteEraseRequest,
+  BootCapabilities
 } from '../../models/models'
 import { caseInsensitiveCompare } from '../../utils'
 import { TranslateService } from '@ngx-translate/core'
@@ -43,6 +45,9 @@ export class DevicesService {
   private readonly http = inject(HttpClient)
   private readonly amtFeaturesStreams = new Map<string, BehaviorSubject<AMTFeaturesResponse | null>>()
   private readonly powerStateStreams = new Map<string, BehaviorSubject<PowerState | null>>()
+  // After successful platform erase we may temporarily get stale feature payloads
+  // while the device reboots. Keep RPE forced off until a user explicitly re-enables it.
+  private readonly rpeDisabledAfterErase = new Set<string>()
   // In-flight HTTP requests, shared so simultaneous callers (e.g. toolbar and
   // general components whose ngOnInit fires together) hit the same response.
   private readonly featuresInflight = new Map<string, Observable<AMTFeaturesResponse>>()
@@ -278,7 +283,14 @@ export class DevicesService {
 
   getAMTFeatures(guid: string): Observable<AMTFeaturesResponse> {
     return this.http.get<AMTFeaturesResponse>(`${environment.mpsServer}/api/v1/amt/features/${guid}`).pipe(
-      tap((features) => this.getOrCreateFeaturesStream(guid).next(features)),
+      map((features) => {
+        const stream = this.getOrCreateFeaturesStream(guid)
+        const current = stream.value
+        const merged = current === null ? features : { ...features, rpe: current.rpe }
+        const nextFeatures = this.applyRpeOverride(guid, merged)
+        stream.next(nextFeatures)
+        return nextFeatures
+      }),
       catchError((err) => {
         throw err
       })
@@ -375,6 +387,22 @@ export class DevicesService {
     }
   }
 
+  setRemoteEraseOptions(deviceId: string, req: RemoteEraseRequest): Observable<any> {
+    return this.http.post<any>(`${environment.mpsServer}/api/v1/amt/boot/remoteErase/${deviceId}`, req).pipe(
+      catchError((err) => {
+        throw err
+      })
+    )
+  }
+
+  getRemoteEraseCapabilities(deviceId: string): Observable<BootCapabilities> {
+    return this.http.get<BootCapabilities>(`${environment.mpsServer}/api/v1/amt/boot/remoteErase/${deviceId}`).pipe(
+      catchError((err) => {
+        throw err
+      })
+    )
+  }
+
   getTags(): Observable<string[]> {
     return this.http.get<string[]>(`${environment.mpsServer}/api/v1/devices/tags`).pipe(
       map((tags) => tags.sort(caseInsensitiveCompare)),
@@ -439,11 +467,22 @@ export class DevicesService {
       enableSOL: true,
       enableIDER: true,
       ocr: true,
-      remoteErase: true
+      rpe: true
     }
   ): Observable<AMTFeaturesResponse> {
+    if (payload.rpe) {
+      this.rpeDisabledAfterErase.delete(deviceId)
+    }
+    const requestBody = {
+      userConsent: payload.userConsent,
+      enableKVM: payload.enableKVM,
+      enableSOL: payload.enableSOL,
+      enableIDER: payload.enableIDER,
+      ocr: payload.ocr,
+      platformEraseEnabled: payload.rpe
+    }
     return this.http
-      .post<AMTFeaturesResponse>(`${environment.mpsServer}/api/v1/amt/features/${deviceId}`, payload)
+      .post<AMTFeaturesResponse>(`${environment.mpsServer}/api/v1/amt/features/${deviceId}`, requestBody)
       .pipe(
         tap(() => this.applyFeaturesSelection(deviceId, payload)),
         catchError((err) => {
@@ -459,16 +498,42 @@ export class DevicesService {
     if (current === null) {
       return
     }
-    stream.next({
-      ...current,
-      userConsent: payload.userConsent,
-      KVM: payload.enableKVM,
-      SOL: payload.enableSOL,
-      IDER: payload.enableIDER,
-      redirection: payload.enableKVM || payload.enableSOL || payload.enableIDER,
-      ocr: payload.ocr,
-      remoteErase: payload.remoteErase
-    })
+    stream.next(
+      this.applyRpeOverride(deviceId, {
+        ...current,
+        userConsent: payload.userConsent,
+        KVM: payload.enableKVM,
+        SOL: payload.enableSOL,
+        IDER: payload.enableIDER,
+        redirection: payload.enableKVM || payload.enableSOL || payload.enableIDER,
+        ocr: payload.ocr,
+        rpe: payload.rpe
+      })
+    )
+  }
+
+  updateAmtFeaturesCache(deviceId: string, patch: Partial<AMTFeaturesResponse>): void {
+    const stream = this.getOrCreateFeaturesStream(deviceId)
+    const current = stream.value
+    if (current === null) {
+      return
+    }
+    stream.next(
+      this.applyRpeOverride(deviceId, {
+        ...current,
+        ...patch
+      })
+    )
+  }
+
+  private applyRpeOverride(deviceId: string, features: AMTFeaturesResponse): AMTFeaturesResponse {
+    if (!this.rpeDisabledAfterErase.has(deviceId)) {
+      return features
+    }
+    return {
+      ...features,
+      rpe: false
+    }
   }
 
   getPowerState(deviceId: string): Observable<PowerState> {
diff --git a/src/app/devices/general/general.component.html b/src/app/devices/general/general.component.html
index 5f67c3613..bb467d9a9 100644
--- a/src/app/devices/general/general.component.html
+++ b/src/app/devices/general/general.component.html
@@ -156,6 +156,16 @@
             }}
           </div>
         }
+        <div class="flex flex-50 items-end">
+          <p>{{ 'general.remotePlatformErase.value' | translate }}</p>
+        </div>
+        <div
+          class="flex flex-50 justify-end items-start"
+          [matTooltip]="'general.remotePlatformEraseNotSupported.value' | translate"
+          [matTooltipDisabled]="!amtEnabledFeatures.get('rpe')?.disabled"
+          matTooltipPosition="after">
+          <mat-checkbox formControlName="rpe" (change)="setAmtFeatures({ rpe: $event.checked })"></mat-checkbox>
+        </div>
         <div class="flex flex-50 items-end">
           <p>{{ 'general.ideRedirection.value' | translate }}</p>
         </div>
diff --git a/src/app/devices/general/general.component.spec.ts b/src/app/devices/general/general.component.spec.ts
index 1a051a6b4..008fac883 100644
--- a/src/app/devices/general/general.component.spec.ts
+++ b/src/app/devices/general/general.component.spec.ts
@@ -32,7 +32,8 @@ describe('GeneralComponent', () => {
       'bulkPowerAction',
       'sendDeactivate',
       'sendBulkDeactivate',
-      'getWsmanOperations'
+      'getWsmanOperations',
+      'featuresChanges'
     ])
     const amtFeaturesResponse = {
       userConsent: 'ALL',
@@ -46,7 +47,8 @@ describe('GeneralComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpe: true,
+      rpeSupported: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -56,6 +58,7 @@ describe('GeneralComponent', () => {
     }
     devicesServiceSpy.getAMTFeatures.and.returnValue(of(amtFeaturesResponse))
     devicesServiceSpy.getAMTFeaturesCached.and.returnValue(of(amtFeaturesResponse))
+    devicesServiceSpy.featuresChanges.and.returnValue(of(null))
     devicesServiceSpy.getGeneralSettings.and.returnValue(of({}))
     devicesServiceSpy.getAMTVersion.and.returnValue(of(['']))
     TestBed.configureTestingModule({
@@ -135,12 +138,12 @@ describe('GeneralComponent', () => {
     expect(devicesServiceSpy.setAmtFeatures).toHaveBeenCalled()
   })
 
-  it('sends remoteErase from the loaded features, not the default', () => {
+  it('sends rpe from the loaded features, not the default', () => {
     devicesServiceSpy.setAmtFeatures = jasmine.createSpy().and.returnValue(of({}))
     component.setAmtFeatures()
     expect(devicesServiceSpy.setAmtFeatures).toHaveBeenCalledWith(
       jasmine.any(String),
-      jasmine.objectContaining({ remoteErase: true })
+      jasmine.objectContaining({ rpe: true })
     )
   })
 })
diff --git a/src/app/devices/general/general.component.ts b/src/app/devices/general/general.component.ts
index d175ee048..75d492525 100644
--- a/src/app/devices/general/general.component.ts
+++ b/src/app/devices/general/general.component.ts
@@ -57,7 +57,8 @@ export class GeneralComponent implements OnInit, OnDestroy {
     httpsBootSupported: false,
     winREBootSupported: false,
     localPBABootSupported: false,
-    remoteErase: false,
+    rpeSupported: false,
+    rpe: false,
     pbaBootFilesPath: [],
     winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
   }
@@ -74,10 +75,13 @@ export class GeneralComponent implements OnInit, OnDestroy {
     httpsBootSupported: false,
     winREBootSupported: false,
     localPBABootSupported: false,
-    ocr: false
+    ocr: false,
+    rpe: false,
+    rpeSupported: false
   })
 
   public isLoading = signal(true)
+  public isDataLoaded = signal(false)
   public amtDHCPDNSSuffix: string | null = null
   public amtTrustedDNSSuffix: string | null = null
   public amtVersion: string | null = null
@@ -159,10 +163,16 @@ export class GeneralComponent implements OnInit, OnDestroy {
                 !results.amtFeatures.localPBABootSupported
             }
           ],
+
           httpsBootSupported: [{ value: results.amtFeatures.httpsBootSupported, disabled: true }],
           winREBootSupported: [{ value: results.amtFeatures.winREBootSupported, disabled: true }],
-          localPBABootSupported: [{ value: results.amtFeatures.localPBABootSupported, disabled: true }]
+          localPBABootSupported: [{ value: results.amtFeatures.localPBABootSupported, disabled: true }],
+          rpe: [
+            { value: results.amtFeatures.rpe, disabled: !(results.amtFeatures.rpeSupported ?? false) }
+          ],
+          rpeSupported: [{ value: results.amtFeatures.rpeSupported ?? false, disabled: true }]
         })
+        this.isDataLoaded.set(true)
       })
   }
 
@@ -179,13 +189,14 @@ export class GeneralComponent implements OnInit, OnDestroy {
     return !!(enableKVM || enableSOL || enableIDER)
   }
 
-  setAmtFeatures(): void {
+  setAmtFeatures(override: Partial<AMTFeaturesRequest> = {}): void {
     this.isLoading.set(true)
+    const payload = {
+      ...this.amtEnabledFeatures.getRawValue(),
+      ...override
+    } as AMTFeaturesRequest
     this.devicesService
-      .setAmtFeatures(this.deviceId(), {
-        ...this.amtEnabledFeatures.getRawValue(),
-        remoteErase: this.amtFeatures.remoteErase
-      } as AMTFeaturesRequest)
+      .setAmtFeatures(this.deviceId(), payload)
       .pipe(
         finalize(() => {
           this.isLoading.set(false)
diff --git a/src/app/devices/hardware-information/hardware-information.component.spec.ts b/src/app/devices/hardware-information/hardware-information.component.spec.ts
index d7f58727b..4884924d3 100644
--- a/src/app/devices/hardware-information/hardware-information.component.spec.ts
+++ b/src/app/devices/hardware-information/hardware-information.component.spec.ts
@@ -46,7 +46,8 @@ describe('HardwareInformationComponent', () => {
         ocr: true,
         winREBootSupported: true,
         localPBABootSupported: true,
-        remoteErase: true,
+        rpeSupported: true,
+        rpe: true,
         pbaBootFilesPath: [],
         winREBootFilesPath: {
           instanceID: '',
diff --git a/src/app/devices/kvm/kvm.component.spec.ts b/src/app/devices/kvm/kvm.component.spec.ts
index 70e1c5069..61c8f4958 100644
--- a/src/app/devices/kvm/kvm.component.spec.ts
+++ b/src/app/devices/kvm/kvm.component.spec.ts
@@ -74,7 +74,54 @@ describe('KvmComponent', () => {
         ocr: true,
         winREBootSupported: true,
         localPBABootSupported: true,
-        remoteErase: true,
+        rpeSupported: true,
+        rpe: true,
+        pbaBootFilesPath: [],
+        winREBootFilesPath: {
+          instanceID: '',
+          biosBootString: '',
+          bootString: ''
+        }
+      })
+    )
+    getAMTFeaturesSpy = devicesService.getAMTFeatures.and.returnValue(
+      of({
+        userConsent: 'none',
+        KVM: true,
+        SOL: true,
+        IDER: true,
+        redirection: true,
+        kvmAvailable: true,
+        optInState: 0,
+        httpsBootSupported: true,
+        ocr: true,
+        winREBootSupported: true,
+        localPBABootSupported: true,
+        rpeSupported: true,
+        rpe: true,
+        pbaBootFilesPath: [],
+        winREBootFilesPath: {
+          instanceID: '',
+          biosBootString: '',
+          bootString: ''
+        }
+      })
+    )
+    getAMTFeaturesCachedSpy = devicesService.getAMTFeaturesCached.and.returnValue(
+      of({
+        userConsent: 'none',
+        KVM: true,
+        SOL: true,
+        IDER: true,
+        redirection: true,
+        kvmAvailable: true,
+        optInState: 0,
+        httpsBootSupported: true,
+        ocr: true,
+        winREBootSupported: true,
+        localPBABootSupported: true,
+        rpeSupported: true,
+        rpe: true,
         pbaBootFilesPath: [],
         winREBootFilesPath: {
           instanceID: '',
@@ -83,28 +130,6 @@ describe('KvmComponent', () => {
         }
       })
     )
-    const amtFeaturesResponse = {
-      userConsent: 'none',
-      KVM: true,
-      SOL: true,
-      IDER: true,
-      redirection: true,
-      kvmAvailable: true,
-      optInState: 0,
-      httpsBootSupported: true,
-      ocr: true,
-      winREBootSupported: true,
-      localPBABootSupported: true,
-      remoteErase: true,
-      pbaBootFilesPath: [],
-      winREBootFilesPath: {
-        instanceID: '',
-        biosBootString: '',
-        bootString: ''
-      }
-    }
-    getAMTFeaturesSpy = devicesService.getAMTFeatures.and.returnValue(of(amtFeaturesResponse))
-    getAMTFeaturesCachedSpy = devicesService.getAMTFeaturesCached.and.returnValue(of(amtFeaturesResponse))
     devicesService.getDevice.and.returnValue(
       of({
         hostname: 'test-hostname',
@@ -423,7 +448,8 @@ describe('KvmComponent', () => {
           ocr: true,
           winREBootSupported: true,
           localPBABootSupported: true,
-          remoteErase: true,
+          rpeSupported: true,
+          rpe: true,
           pbaBootFilesPath: [],
           winREBootFilesPath: {
             instanceID: '',
@@ -524,7 +550,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -553,7 +580,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -598,7 +626,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -626,7 +655,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -656,7 +686,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -685,7 +716,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -714,7 +746,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -743,7 +776,8 @@ describe('KvmComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
diff --git a/src/app/devices/kvm/kvm.component.ts b/src/app/devices/kvm/kvm.component.ts
index 9b2741d1c..06f1a8e89 100644
--- a/src/app/devices/kvm/kvm.component.ts
+++ b/src/app/devices/kvm/kvm.component.ts
@@ -476,7 +476,7 @@ export class KvmComponent implements OnInit, OnDestroy {
             enableSOL: this.amtFeatures()?.SOL ?? false,
             enableIDER: this.amtFeatures()?.IDER ?? false,
             ocr: this.amtFeatures()?.ocr ?? false,
-            remoteErase: this.amtFeatures()?.remoteErase ?? false
+            rpe: this.amtFeatures()?.rpe ?? false
           }
           return this.devicesService.setAmtFeatures(this.deviceId(), payload)
         }
diff --git a/src/app/devices/remote-platform-erase/remote-platform-erase.component.html b/src/app/devices/remote-platform-erase/remote-platform-erase.component.html
new file mode 100644
index 000000000..ba569cce0
--- /dev/null
+++ b/src/app/devices/remote-platform-erase/remote-platform-erase.component.html
@@ -0,0 +1,126 @@
+@if (isLoading()) {
+  <mat-progress-bar mode="indeterminate"></mat-progress-bar>
+}
+<mat-card>
+  <mat-card-header style="justify-content: space-between">
+    <mat-card-title>{{ 'remotePlatformErase.title.value' | translate }}</mat-card-title>
+    @if (isPlatformEraseSupported() && platformEraseEnabled()) {
+      <button
+        mat-flat-button
+        color="warn"
+        data-cy="initiateEraseButton"
+        [disabled]="!hasSelectedCaps()"
+        [matTooltip]="!hasSelectedCaps() ? ('remotePlatformErase.initiateNoCapsTooltip.value' | translate) : ''"
+        (click)="initiateErase()">
+        <mat-icon>delete_forever</mat-icon>
+        {{ 'remotePlatformErase.initiateButton.value' | translate }}
+      </button>
+    }
+  </mat-card-header>
+  <mat-card-content>
+    <p>{{ 'remotePlatformErase.description.value' | translate }}</p>
+    @if (isPlatformEraseSupported()) {
+      <div role="status" style="padding: 12px 0">
+        <mat-icon color="warn" aria-hidden="true" style="vertical-align: middle; margin-right: 8px">warning</mat-icon>
+        <span>{{ 'remotePlatformErase.initiateWarning.value' | translate }}</span>
+      </div>
+
+      <div style="padding: 8px 0">
+        <mat-slide-toggle
+          color="primary"
+          data-cy="remoteEraseCheckbox"
+          [checked]="platformEraseEnabled()"
+          [disabled]="isLoading()"
+          (change)="toggleFeature($event.checked)">
+          {{ 'remotePlatformErase.featureEnabled.value' | translate }}
+        </mat-slide-toggle>
+        <div style="padding-top: 4px">
+          <small>{{ 'remotePlatformErase.featureEnabledHint.value' | translate }}</small>
+        </div>
+      </div>
+
+      @if (platformEraseEnabled()) {
+        <mat-divider style="margin: 16px 0"></mat-divider>
+
+        <h3>
+          <mat-icon color="primary" aria-hidden="true" style="vertical-align: middle; margin-right: 8px"
+            >checklist</mat-icon
+          >
+          <span>{{ 'remotePlatformErase.caps.title.value' | translate }}</span>
+        </h3>
+        <p>{{ 'remotePlatformErase.caps.description.value' | translate }}</p>
+
+        @for (cap of eraseCaps(); track cap.key; let i = $index) {
+          <!-- Hide the CSME unconfigure option for now until we have a better way to control the power of this option. -->
+          @if (cap.key !== 'csmeUnconfigure') {
+            <div data-cy="eraseCapItem" style="padding: 4px 0">
+              <mat-checkbox
+                [formControl]="eraseCapControl(i)"
+                (change)="onCapChange()"
+                [attr.aria-describedby]="'rpe-cap-desc-' + cap.key"
+                data-cy="eraseCapCheckbox">
+                <div>
+                  <div>{{ 'remotePlatformErase.cap.' + cap.key + '.label.value' | translate }}</div>
+                  <small [id]="'rpe-cap-desc-' + cap.key">
+                    {{ 'remotePlatformErase.cap.' + cap.key + '.desc.value' | translate }}
+                  </small>
+                  @if (!cap.supported) {
+                    <div>
+                      <small
+                        ><em>{{ 'remotePlatformErase.capUnsupported.value' | translate }}</em></small
+                      >
+                    </div>
+                  }
+                </div>
+              </mat-checkbox>
+              @if (cap.key === 'secureEraseSsds' && isSsdSelected()) {
+                <div style="padding-left: 40px; padding-top: 8px">
+                  <mat-checkbox
+                    [formControl]="ssdEncryptedControl"
+                    (change)="onSsdEncryptedChange($event.checked)"
+                    data-cy="ssdEncryptedCheckbox">
+                    {{ 'remotePlatformErase.ssdEncrypted.label.value' | translate }}
+                  </mat-checkbox>
+                  @if (isSsdEncrypted()) {
+                    <mat-form-field style="display: block; padding-top: 8px">
+                      <mat-label>{{ 'remotePlatformErase.ssdPassword.label.value' | translate }}</mat-label>
+                      <input
+                        matInput
+                        type="password"
+                        [formControl]="ssdPasswordControl"
+                        data-cy="ssdPasswordInput"
+                        autocomplete="off" />
+                    </mat-form-field>
+                  }
+                </div>
+              }
+            </div>
+          }
+        }
+
+        @if (isCsmeExclusiveSelected()) {
+          <div role="status" data-cy="csmeExclusiveNote" style="padding: 8px 0">
+            <mat-icon color="primary" aria-hidden="true" style="vertical-align: middle; margin-right: 8px"
+              >info</mat-icon
+            >
+            <span>{{ 'remotePlatformErase.csmeUnconfigureExclusive.value' | translate }}</span>
+          </div>
+        }
+
+        <p data-cy="selectionCount" style="margin: 8px 0 0">
+          <small>
+            {{
+              'remotePlatformErase.selectionCount.value'
+                | translate: { selected: selectedCapsCount(), total: supportedCapsCount() }
+            }}
+          </small>
+        </p>
+      }
+    } @else if (!isLoading()) {
+      <div data-cy="notSupportedMessage" style="padding: 8px 0">
+        <mat-icon color="accent" aria-hidden="true" style="vertical-align: middle; margin-right: 8px">info</mat-icon>
+        <span>{{ 'remotePlatformErase.notSupported.value' | translate }}</span>
+      </div>
+    }
+  </mat-card-content>
+</mat-card>
diff --git a/src/app/devices/remote-platform-erase/remote-platform-erase.component.scss b/src/app/devices/remote-platform-erase/remote-platform-erase.component.scss
new file mode 100644
index 000000000..5d4e87f30
--- /dev/null
+++ b/src/app/devices/remote-platform-erase/remote-platform-erase.component.scss
@@ -0,0 +1,3 @@
+:host {
+  display: block;
+}
diff --git a/src/app/devices/remote-platform-erase/remote-platform-erase.component.spec.ts b/src/app/devices/remote-platform-erase/remote-platform-erase.component.spec.ts
new file mode 100644
index 000000000..244dca8e5
--- /dev/null
+++ b/src/app/devices/remote-platform-erase/remote-platform-erase.component.spec.ts
@@ -0,0 +1,1021 @@
+/*********************************************************************
+ * Copyright (c) Intel Corporation 2022
+ * SPDX-License-Identifier: Apache-2.0
+ **********************************************************************/
+
+import { ComponentFixture, TestBed } from '@angular/core/testing'
+import { RemotePlatformEraseComponent } from './remote-platform-erase.component'
+import { DevicesService } from '../devices.service'
+import { MatDialog } from '@angular/material/dialog'
+import { MatSnackBar } from '@angular/material/snack-bar'
+import { of, throwError } from 'rxjs'
+import { provideTranslateService } from '@ngx-translate/core'
+import { AMTFeaturesResponse } from '../../../models/models'
+import { AreYouSureDialogComponent } from '../../shared/are-you-sure/are-you-sure.component'
+import { HttpErrorResponse } from '@angular/common/http'
+import { Router } from '@angular/router'
+import { UserConsentService } from '../user-consent.service'
+
+// Temporary set to 3 until CSME unconfigure is supported in the UI. The 4th capability is hidden in the template and not tested here.
+const VISIBLE_PLATFORM_ERASE_CAPABILITIES = 3 //PLATFORM_ERASE_CAPABILITIES.filter((cap) => cap.key !== 'csmeUnconfigure')
+
+const mockAMTFeatures: AMTFeaturesResponse = {
+  userConsent: 'none',
+  KVM: true,
+  SOL: true,
+  IDER: true,
+  redirection: true,
+  optInState: 1,
+  kvmAvailable: true,
+  httpsBootSupported: false,
+  ocr: false,
+  winREBootSupported: false,
+  localPBABootSupported: false,
+  rpe: false,
+  rpeSupported: true,
+  pbaBootFilesPath: [],
+  winREBootFilesPath: { instanceID: '', biosBootString: '', bootString: '' }
+}
+
+describe('RemotePlatformEraseComponent', () => {
+  let component: RemotePlatformEraseComponent
+  let fixture: ComponentFixture<RemotePlatformEraseComponent>
+  let devicesServiceSpy: jasmine.SpyObj<DevicesService>
+  let matDialogSpy: jasmine.SpyObj<MatDialog>
+  let snackBarSpy: jasmine.SpyObj<MatSnackBar>
+  let routerSpy: jasmine.SpyObj<Router>
+  let userConsentServiceSpy: jasmine.SpyObj<UserConsentService>
+
+  beforeEach(async () => {
+    devicesServiceSpy = jasmine.createSpyObj('DevicesService', [
+      'getAMTFeatures',
+      'getAMTFeaturesCached',
+      'featuresChanges',
+      'updateAmtFeaturesCache',
+      'markRpeDisabledAfterErase',
+      'setAmtFeatures',
+      'getDevice',
+      'getRemoteEraseCapabilities',
+      'setRemoteEraseOptions',
+      'sendDeactivate'
+    ])
+    devicesServiceSpy.getDevice.and.returnValue(of({ guid: '', hostname: 'host-1', friendlyName: 'my-laptop' } as any))
+    devicesServiceSpy.getRemoteEraseCapabilities.and.returnValue(
+      of({ secureEraseAllSSDs: true, tpmClear: false, restoreBIOSToEOM: true, unconfigureCSME: false })
+    )
+    matDialogSpy = jasmine.createSpyObj('MatDialog', ['open'])
+    snackBarSpy = jasmine.createSpyObj('MatSnackBar', ['open'])
+    routerSpy = jasmine.createSpyObj('Router', ['navigate'])
+    routerSpy.navigate.and.returnValue(Promise.resolve(true))
+    userConsentServiceSpy = jasmine.createSpyObj('UserConsentService', [
+      'handleUserConsentDecision',
+      'handleUserConsentResponse'
+    ])
+    userConsentServiceSpy.handleUserConsentDecision.and.returnValue(of(null))
+    userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(null))
+
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures }))
+    // Delegate getAMTFeaturesCached to getAMTFeatures so per-test returnValue configs apply to both
+    devicesServiceSpy.getAMTFeaturesCached.and.callFake((guid: string) => devicesServiceSpy.getAMTFeatures(guid))
+    devicesServiceSpy.featuresChanges.and.returnValue(of(null))
+    devicesServiceSpy.setAmtFeatures.and.returnValue(of({ ...mockAMTFeatures }))
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(of({}))
+    devicesServiceSpy.sendDeactivate.and.returnValue(of({}))
+
+    await TestBed.configureTestingModule({
+      imports: [RemotePlatformEraseComponent],
+      providers: [
+        provideTranslateService(),
+        { provide: DevicesService, useValue: devicesServiceSpy },
+        { provide: MatDialog, useValue: matDialogSpy },
+        { provide: MatSnackBar, useValue: snackBarSpy },
+        { provide: Router, useValue: routerSpy },
+        { provide: UserConsentService, useValue: userConsentServiceSpy }
+      ]
+    }).compileComponents()
+
+    fixture = TestBed.createComponent(RemotePlatformEraseComponent)
+    component = fixture.componentInstance
+    fixture.detectChanges()
+  })
+
+  it('should create', () => {
+    expect(component).toBeTruthy()
+  })
+
+  it('should call getAMTFeatures on init', () => {
+    expect(devicesServiceSpy.getAMTFeatures).toHaveBeenCalled()
+  })
+
+  it('should set isLoading to false after init completes', () => {
+    expect(component.isLoading()).toBeFalse()
+  })
+
+  it('should show toggle as checked on init when rpe is true', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    fixture.detectChanges()
+    const toggle = fixture.nativeElement.querySelector('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+    expect(toggle).not.toBeNull()
+    expect(toggle.getAttribute('aria-checked')).toBe('true')
+  })
+
+  it('should show feature-disabled status when remoteEraseEnabled is false', () => {
+    fixture.detectChanges()
+    const toggle = fixture.nativeElement.querySelector('[data-cy="remoteEraseCheckbox"] button[role="switch"]')
+    expect(toggle).not.toBeNull()
+    expect(toggle.getAttribute('aria-checked')).toBe('false')
+  })
+
+  it('should show error snackbar when getAMTFeatures fails', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(throwError(() => new Error('error')))
+    component.ngOnInit()
+    expect(snackBarSpy.open).toHaveBeenCalled()
+  })
+
+  it('should show server message in snackbar when setRemoteEraseOptions fails with it', () => {
+    const serverError = new HttpErrorResponse({ error: { message: 'AMT device unreachable' }, status: 500 })
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(throwError(() => serverError))
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(snackBarSpy.open).toHaveBeenCalledWith('AMT device unreachable', undefined, jasmine.any(Object))
+  })
+
+  it('should show OS erase success message when secureEraseAllSSDs is selected', () => {
+    component.eraseCaps.set([
+      { key: 'secureEraseSsds', supported: true },
+      { key: 'tpmClear', supported: false },
+      { key: 'biosRestore', supported: false },
+      { key: 'csmeUnconfigure', supported: false }
+    ])
+    component.eraseCapsArray.at(0).enable()
+    component.eraseCapsArray.at(0).setValue(true)
+    component.selectedCapsCount.set(1)
+    component.platformEraseEnabled.set(true)
+
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(of({}))
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+
+    component.initiateErase()
+
+    expect(snackBarSpy.open).toHaveBeenCalledWith(
+      'remotePlatformErase.osEraseSuccess.value',
+      undefined,
+      jasmine.anything()
+    )
+  })
+
+  it('should show fallback message in snackbar when setRemoteEraseOptions fails without message', () => {
+    const serverError = new HttpErrorResponse({ error: {}, status: 500 })
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(throwError(() => serverError))
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(snackBarSpy.open).toHaveBeenCalledWith(
+      'remotePlatformErase.eraseError.value',
+      undefined,
+      jasmine.any(Object)
+    )
+  })
+
+  it('should open AreYouSureDialog with the erase confirmation message', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+    component.initiateErase()
+    expect(matDialogSpy.open).toHaveBeenCalledWith(AreYouSureDialogComponent, jasmine.any(Object))
+    const config = matDialogSpy.open.calls.mostRecent().args[1] as any
+    expect(config.data.message).toBe('remotePlatformErase.confirmMessage')
+    expect(config.data.params.operations).toBeDefined()
+    expect(config.data.params.device).toBeDefined()
+  })
+
+  it('should pass selected capability labels in the dialog params', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(
+      of({
+        ...mockAMTFeatures,
+        rpe: true
+      })
+    )
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.eraseCapControl(2).setValue(true)
+    component.onCapChange()
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+    component.initiateErase()
+    const config = matDialogSpy.open.calls.mostRecent().args[1] as any
+    expect(config.data.params.operations.split(', ').length).toBe(2)
+  })
+
+  it('should not open confirmation dialog when feature is disabled', () => {
+    // mockAMTFeatures has rpe: false
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+    component.initiateErase()
+    expect(matDialogSpy.open).not.toHaveBeenCalled()
+  })
+
+  it('should not open confirmation dialog when no caps are selected', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(false)
+    component.eraseCapControl(2).setValue(false)
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+    component.initiateErase()
+    expect(matDialogSpy.open).not.toHaveBeenCalled()
+  })
+
+  it('should call sendRemotePlatformErase when erase is confirmed', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    // check secureEraseSsds (0x04, bit 2) and biosRestore (0x4000000, bit 26) → mask 0x4000004
+    component.eraseCapControl(0).setValue(true)
+    component.eraseCapControl(2).setValue(true)
+    component.onCapChange()
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalledWith('', {
+      secureEraseAllSSDs: true,
+      tpmClear: false,
+      restoreBIOSToEOM: true,
+      unconfigureCSME: false
+    })
+  })
+
+  it('should not call setRemoteEraseOptions when erase is cancelled', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+    component.initiateErase()
+    expect(devicesServiceSpy.setRemoteEraseOptions).not.toHaveBeenCalled()
+  })
+
+  it('should pass deselected capability bitmask to setRemoteEraseOptions', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    // check only biosRestore (index 2, bit 26 = 0x4000000) — secureEraseSsds left unchecked
+    component.eraseCapControl(2).setValue(true)
+    component.onCapChange()
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalledWith('', {
+      secureEraseAllSSDs: false,
+      tpmClear: false,
+      restoreBIOSToEOM: true,
+      unconfigureCSME: false
+    })
+  })
+
+  it('should show success snackbar after erase succeeds', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(snackBarSpy.open).toHaveBeenCalled()
+  })
+
+  it('should show error snackbar when sendRemotePlatformErase fails', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(throwError(() => new Error('error')))
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(snackBarSpy.open).toHaveBeenCalled()
+  })
+
+  it('should set isRemoteEraseSupported to true when remoteEraseSupported is true', () => {
+    expect(component.isPlatformEraseSupported()).toBeTrue()
+  })
+
+  it('should set isRemoteEraseSupported to false when remoteEraseSupported is false', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpeSupported: false }))
+    component.ngOnInit()
+    fixture.detectChanges()
+    expect(component.isPlatformEraseSupported()).toBeFalse()
+  })
+
+  it('should set isRemoteEraseSupported to false when remoteEraseSupported is absent', () => {
+    const featuresWithoutSupported = { ...mockAMTFeatures } as Partial<AMTFeaturesResponse>
+    delete featuresWithoutSupported.rpeSupported
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of(featuresWithoutSupported as AMTFeaturesResponse))
+    component.ngOnInit()
+    fixture.detectChanges()
+    expect(component.isPlatformEraseSupported()).toBeFalse()
+  })
+
+  it('should set isLoading to true during initiateErase', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(of({}))
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    // isLoading is set true before the observable completes
+    expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalled()
+  })
+
+  it('should set isLoading to false after initiateErase fails', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    devicesServiceSpy.setRemoteEraseOptions.and.returnValue(throwError(() => new Error('erase failed')))
+    matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    component.initiateErase()
+    expect(component.isLoading()).toBeFalse()
+  })
+
+  it('should show initiate erase button when feature is enabled', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    fixture.detectChanges()
+    const button = fixture.nativeElement.querySelector('[data-cy="initiateEraseButton"]')
+    expect(button).not.toBeNull()
+    expect(button.disabled).toBeFalse()
+  })
+
+  it('should not show initiate erase button when feature is disabled', () => {
+    // mockAMTFeatures has rpe: false but rpeSupported: true
+    fixture.detectChanges()
+    const button = fixture.nativeElement.querySelector('[data-cy="initiateEraseButton"]')
+    expect(button).toBeNull()
+  })
+
+  it('should disable initiate erase button when all selected caps are unchecked', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    fixture.detectChanges()
+    // Uncheck all supported caps (secureEraseSsds index 0, biosRestore index 2)
+    component.eraseCapControl(0).setValue(false)
+    component.eraseCapControl(2).setValue(false)
+    component.onCapChange()
+    fixture.detectChanges()
+    const button = fixture.nativeElement.querySelector('[data-cy="initiateEraseButton"]')
+    expect(button).not.toBeNull()
+    expect(button.disabled).toBeTrue()
+  })
+
+  it('should enable initiate erase button when feature is enabled and at least one cap is checked', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    fixture.detectChanges()
+    // Caps start unchecked — check a supported one first
+    component.eraseCapControl(0).setValue(true)
+    component.onCapChange()
+    fixture.detectChanges()
+    const button = fixture.nativeElement.querySelector('[data-cy="initiateEraseButton"]')
+    expect(button).not.toBeNull()
+    expect(button.disabled).toBeFalse()
+  })
+
+  it('should show capabilities card when remoteEraseSupported is true', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    fixture.detectChanges()
+    const capItems = fixture.nativeElement.querySelectorAll('[data-cy="eraseCapItem"]')
+    // Only 3 capabilities visible (CSME unconfigure is hidden in template)
+    expect(capItems.length).toBe(VISIBLE_PLATFORM_ERASE_CAPABILITIES)
+  })
+
+  it('should show a checkbox for each capability, disabled for unsupported ones', () => {
+    devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+    component.ngOnInit()
+    component.toggleFeature(true)
+    fixture.detectChanges()
+    const checkboxes = fixture.nativeElement.querySelectorAll('[data-cy="eraseCapCheckbox"]')
+    // Only 3 capabilities visible (CSME unconfigure is hidden in template)
+    expect(checkboxes.length).toBe(VISIBLE_PLATFORM_ERASE_CAPABILITIES)
+    // tpmClear (index 1) and csmeUnconfigure (index 3) not supported — always disabled
+    expect(component.eraseCapControl(1).disabled).toBeTrue()
+    expect(component.eraseCapControl(3).disabled).toBeTrue()
+    // secureEraseSsds (index 0) and biosRestore (index 2) supported — always enabled
+    expect(component.eraseCapControl(0).disabled).toBeFalse()
+    expect(component.eraseCapControl(2).disabled).toBeFalse()
+  })
+
+  it('should disable all capability checkboxes when featureEnabled is false', () => {
+    // mockAMTFeatures: rpe=false — all caps disabled regardless of support
+    fixture.detectChanges()
+    expect(component.eraseCapControl(0).disabled).toBeTrue() // supported but feature off → disabled
+    expect(component.eraseCapControl(1).disabled).toBeTrue() // not supported → disabled
+    expect(component.eraseCapControl(2).disabled).toBeTrue() // supported but feature off → disabled
+    expect(component.eraseCapControl(3).disabled).toBeTrue() // not supported → disabled
+  })
+
+  it('should keep supported capability checkboxes enabled when featureEnabled becomes true', () => {
+    component.toggleFeature(true)
+    // 0x05: secureErase(0) + storageDrives(2) supported → always enabled
+    expect(component.eraseCapControl(0).disabled).toBeFalse()
+    expect(component.eraseCapControl(1).disabled).toBeTrue() // tpmClear not supported
+    expect(component.eraseCapControl(2).disabled).toBeFalse()
+    expect(component.eraseCapControl(3).disabled).toBeTrue() // meRegion not supported
+  })
+
+  it('should default eraseCaps to all-supported when getRemoteEraseCapabilities returns all supported', () => {
+    devicesServiceSpy.getRemoteEraseCapabilities.and.returnValue(
+      of({ secureEraseAllSSDs: true, tpmClear: true, restoreBIOSToEOM: true, unconfigureCSME: true })
+    )
+    component.ngOnInit()
+    expect(component.eraseCaps().every((c) => c.supported)).toBeTrue()
+  })
+
+  it('should default eraseCaps to all-unsupported when getRemoteEraseCapabilities returns all unsupported', () => {
+    devicesServiceSpy.getRemoteEraseCapabilities.and.returnValue(
+      of({ secureEraseAllSSDs: false, tpmClear: false, restoreBIOSToEOM: false, unconfigureCSME: false })
+    )
+    component.ngOnInit()
+    expect(component.eraseCaps().every((c) => !c.supported)).toBeTrue()
+  })
+
+  describe('toggleFeature', () => {
+    it('should call setAmtFeatures with rpe: true when toggling on', () => {
+      component.toggleFeature(true)
+      expect(devicesServiceSpy.setAmtFeatures).toHaveBeenCalledWith('', jasmine.objectContaining({ rpe: true }))
+    })
+
+    it('should call setAmtFeatures with rpe: false when toggling off', () => {
+      component.toggleFeature(false)
+      expect(devicesServiceSpy.setAmtFeatures).toHaveBeenCalledWith('', jasmine.objectContaining({ rpe: false }))
+    })
+
+    it('should set rpe immediately before API call completes', () => {
+      devicesServiceSpy.setAmtFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+      expect(component.platformEraseEnabled()).toBeFalse()
+      component.toggleFeature(true)
+      expect(component.platformEraseEnabled()).toBeTrue()
+    })
+
+    it('should revert platformEraseEnabled when setAmtFeatures fails', () => {
+      devicesServiceSpy.setAmtFeatures.and.returnValue(throwError(() => new Error('error')))
+      component.toggleFeature(true)
+      expect(component.platformEraseEnabled()).toBeFalse()
+    })
+
+    it('should show error snackbar when setAmtFeatures fails', () => {
+      devicesServiceSpy.setAmtFeatures.and.returnValue(throwError(() => new Error('error')))
+      component.toggleFeature(true)
+      expect(snackBarSpy.open).toHaveBeenCalled()
+    })
+
+    it('should disable caps immediately when toggling off', () => {
+      component.toggleFeature(true)
+      // caps should be enabled for supported ones with feature on
+      expect(component.eraseCapControl(0).disabled).toBeFalse()
+      component.toggleFeature(false)
+      // caps should be disabled immediately
+      expect(component.eraseCapControl(0).disabled).toBeTrue()
+    })
+
+    it('should enable supported caps immediately when toggling on', () => {
+      // feature starts off (mockAMTFeatures.rpe = false) — caps disabled
+      expect(component.eraseCapControl(0).disabled).toBeTrue()
+      component.toggleFeature(true)
+      expect(component.eraseCapControl(0).disabled).toBeFalse()
+    })
+
+    it('should not corrupt amtFeatures after successful toggle', () => {
+      // The API returns { status: '...' }, not a full AMTFeaturesResponse.
+      // Verify that amtFeatures fields are preserved so subsequent toggles send valid payloads.
+      devicesServiceSpy.setAmtFeatures.and.returnValue(of({ status: 'SUCCESS' } as any))
+      component.toggleFeature(true)
+      component.toggleFeature(false)
+      const calls = devicesServiceSpy.setAmtFeatures.calls.all()
+      const secondPayload = calls[1]?.args[1]
+      expect(secondPayload?.userConsent).toBe(mockAMTFeatures.userConsent)
+      expect(secondPayload?.enableKVM).toBe(mockAMTFeatures.KVM)
+      expect(secondPayload?.enableSOL).toBe(mockAMTFeatures.SOL)
+      expect(secondPayload?.enableIDER).toBe(mockAMTFeatures.IDER)
+      expect(secondPayload?.rpe).toBe(mockAMTFeatures.rpe)
+    })
+  })
+
+  describe('after successful erase', () => {
+    beforeEach(() => {
+      devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+      devicesServiceSpy.setAmtFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: false }))
+      devicesServiceSpy.setRemoteEraseOptions.and.returnValue(of({}))
+      devicesServiceSpy.sendDeactivate.and.returnValue(of({}))
+      userConsentServiceSpy.handleUserConsentDecision.and.returnValue(of(null))
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(null))
+      component.ngOnInit()
+      component.toggleFeature(true)
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+    })
+
+    it('should complete without errors', () => {
+      component.initiateErase()
+      expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalled()
+    })
+  })
+
+  describe('CSME exclusivity', () => {
+    beforeEach(() => {
+      devicesServiceSpy.getAMTFeatures.and.returnValue(
+        of({
+          ...mockAMTFeatures,
+          rpe: true
+        })
+      )
+      devicesServiceSpy.getRemoteEraseCapabilities.and.returnValue(
+        of({ secureEraseAllSSDs: true, tpmClear: false, restoreBIOSToEOM: true, unconfigureCSME: true })
+      )
+      component.ngOnInit()
+      component.toggleFeature(true)
+    })
+
+    it('should call sendDeactivate after CSME erase succeeds', () => {
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.initiateErase()
+      expect(devicesServiceSpy.sendDeactivate).toHaveBeenCalledWith('')
+    })
+
+    it('should navigate to /devices after CSME erase succeeds', () => {
+      const router = TestBed.inject(Router)
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.initiateErase()
+      expect(router.navigate).toHaveBeenCalledWith(['/devices'])
+    })
+
+    it('should signal isCsmeExclusiveSelected when CSME is checked', () => {
+      expect(component.isCsmeExclusiveSelected()).toBeFalse()
+      component.eraseCapControl(3).setValue(true) // csmeUnconfigure
+      component.onCapChange()
+      expect(component.isCsmeExclusiveSelected()).toBeTrue()
+    })
+
+    it('should uncheck other caps when CSME is checked', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.eraseCapControl(2).setValue(true)
+      component.onCapChange()
+      expect(component.selectedCapsCount()).toBe(2)
+
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      expect(component.eraseCapControl(0).value).toBeFalse()
+      expect(component.eraseCapControl(2).value).toBeFalse()
+      expect(component.selectedCapsCount()).toBe(1)
+    })
+
+    it('should disable other caps while CSME is selected', () => {
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      expect(component.eraseCapControl(0).disabled).toBeTrue()
+      expect(component.eraseCapControl(2).disabled).toBeTrue()
+      expect(component.eraseCapControl(3).disabled).toBeFalse()
+    })
+
+    it('should re-enable other caps when CSME is unchecked', () => {
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      component.eraseCapControl(3).setValue(false)
+      component.onCapChange()
+      expect(component.eraseCapControl(0).disabled).toBeFalse()
+      expect(component.eraseCapControl(2).disabled).toBeFalse()
+      expect(component.isCsmeExclusiveSelected()).toBeFalse()
+    })
+
+    it('should send only the CSME bit in the erase mask', () => {
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.initiateErase()
+      expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalledWith('', {
+        secureEraseAllSSDs: false,
+        tpmClear: false,
+        restoreBIOSToEOM: false,
+        unconfigureCSME: true
+      })
+    })
+  })
+  describe('SSD encrypted password', () => {
+    beforeEach(() => {
+      devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+      component.ngOnInit()
+      component.toggleFeature(true)
+    })
+
+    it('should show encrypted checkbox when SSD cap is selected', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      expect(component.isSsdSelected()).toBeTrue()
+    })
+
+    it('should hide encrypted checkbox when SSD cap is deselected', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.eraseCapControl(0).setValue(false)
+      component.onCapChange()
+      expect(component.isSsdSelected()).toBeFalse()
+    })
+
+    it('should show password input when encrypted checkbox is checked', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.onSsdEncryptedChange(true)
+      expect(component.isSsdEncrypted()).toBeTrue()
+    })
+
+    it('should hide password input and clear it when encrypted checkbox is unchecked', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.onSsdEncryptedChange(true)
+      component.ssdPasswordControl.setValue('secret')
+      component.onSsdEncryptedChange(false)
+      expect(component.isSsdEncrypted()).toBeFalse()
+      expect(component.ssdPasswordControl.value).toBe('')
+    })
+
+    it('should include ssdPassword in request when encrypted and SSD selected', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.onSsdEncryptedChange(true)
+      component.ssdPasswordControl.setValue('mypassword')
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.initiateErase()
+      expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalledWith(
+        '',
+        jasmine.objectContaining({ secureEraseAllSSDs: true, ssdPassword: 'mypassword' })
+      )
+    })
+
+    it('should not include ssdPassword when encrypted checkbox is not checked', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.initiateErase()
+      const call = devicesServiceSpy.setRemoteEraseOptions.calls.mostRecent()
+      expect(call.args[1].ssdPassword).toBeUndefined()
+    })
+
+    it('should reset SSD controls when feature is toggled off', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.onSsdEncryptedChange(true)
+      component.ssdPasswordControl.setValue('secret')
+      component.toggleFeature(false)
+      expect(component.isSsdSelected()).toBeFalse()
+      expect(component.isSsdEncrypted()).toBeFalse()
+      expect(component.ssdPasswordControl.value).toBe('')
+    })
+
+    it('should keep SSD controls as they are after successful erase', () => {
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.onSsdEncryptedChange(true)
+      component.ssdPasswordControl.setValue('secret')
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.initiateErase()
+      // State is preserved after erase
+      expect(component.isSsdSelected()).toBeTrue()
+      expect(component.isSsdEncrypted()).toBeTrue()
+      expect(component.ssdPasswordControl.value).toBe('secret')
+    })
+
+    it('should reset SSD controls when CSME is selected', () => {
+      devicesServiceSpy.getRemoteEraseCapabilities.and.returnValue(
+        of({ secureEraseAllSSDs: true, tpmClear: false, restoreBIOSToEOM: true, unconfigureCSME: true })
+      )
+      component.ngOnInit()
+      component.toggleFeature(true)
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+      component.onSsdEncryptedChange(true)
+      // Now select CSME (index 3) — deselects SSD
+      component.eraseCapControl(3).setValue(true)
+      component.onCapChange()
+      expect(component.isSsdSelected()).toBeFalse()
+      expect(component.isSsdEncrypted()).toBeFalse()
+    })
+  })
+
+  describe('supportedCapsCount', () => {
+    it('should count only supported capabilities', () => {
+      expect(component.supportedCapsCount()).toBe(2)
+    })
+  })
+
+  describe('template visibility', () => {
+    it('should hide not-supported message while loading', () => {
+      component.isLoading.set(true)
+      component.isPlatformEraseSupported.set(false)
+      fixture.detectChanges()
+      const notSupported = fixture.nativeElement.querySelector('[data-cy="notSupportedMessage"]')
+      expect(notSupported).toBeNull()
+    })
+
+    it('should show not-supported message after loading completes when not supported', () => {
+      component.isLoading.set(false)
+      component.isPlatformEraseSupported.set(false)
+      fixture.detectChanges()
+      const info = fixture.nativeElement.querySelector('mat-icon[color="accent"]')
+      expect(info).not.toBeNull()
+    })
+
+    it('should show warning when isPlatformEraseSupported is true', () => {
+      fixture.detectChanges()
+      const warn = fixture.nativeElement.querySelector('mat-icon[color="warn"]')
+      expect(warn).not.toBeNull()
+    })
+
+    it('should not show warning when isPlatformEraseSupported is false', () => {
+      devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpeSupported: false }))
+      component.ngOnInit()
+      fixture.detectChanges()
+      const warn = fixture.nativeElement.querySelector('mat-icon[color="warn"]')
+      expect(warn).toBeNull()
+    })
+
+    it('should show selectHint when platformEraseEnabled is true', () => {
+      component.toggleFeature(true)
+      fixture.detectChanges()
+      const hint = fixture.nativeElement.querySelector('mat-icon[color="primary"]')
+      expect(hint).not.toBeNull()
+    })
+
+    it('should hide selectHint when platformEraseEnabled is false', () => {
+      fixture.detectChanges()
+      const hint = fixture.nativeElement.querySelector('mat-icon[color="primary"]')
+      expect(hint).toBeNull()
+    })
+  })
+
+  describe('checkUserConsent', () => {
+    it('should return true and set readyToErase when userConsent is none', (done) => {
+      component.amtFeatures.set({ ...mockAMTFeatures, userConsent: 'none' })
+      component.checkUserConsent().subscribe((result) => {
+        expect(result).toBeTrue()
+        expect(component.readyToErase).toBeTrue()
+        done()
+      })
+    })
+
+    it('should return true and set readyToErase when optInState is 3', (done) => {
+      component.amtFeatures.set({ ...mockAMTFeatures, userConsent: 'all', optInState: 3 })
+      component.checkUserConsent().subscribe((result) => {
+        expect(result).toBeTrue()
+        expect(component.readyToErase).toBeTrue()
+        done()
+      })
+    })
+
+    it('should return true and set readyToErase when optInState is 4', (done) => {
+      component.amtFeatures.set({ ...mockAMTFeatures, userConsent: 'all', optInState: 4 })
+      component.checkUserConsent().subscribe((result) => {
+        expect(result).toBeTrue()
+        expect(component.readyToErase).toBeTrue()
+        done()
+      })
+    })
+
+    it('should return false and not set readyToErase when userConsent is all and consent is required', (done) => {
+      component.amtFeatures.set({ ...mockAMTFeatures, userConsent: 'all', optInState: 1 })
+      component.checkUserConsent().subscribe((result) => {
+        expect(result).toBeFalse()
+        expect(component.readyToErase).toBeFalse()
+        done()
+      })
+    })
+  })
+
+  describe('postUserConsentDecision', () => {
+    const operations = 'SSD Erase'
+
+    it('should open AreYouSureDialog when result is null (consent not required)', () => {
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.postUserConsentDecision(null, operations).subscribe()
+      expect(matDialogSpy.open).toHaveBeenCalledWith(AreYouSureDialogComponent, jasmine.any(Object))
+    })
+
+    it('should open AreYouSureDialog when result is true (consent granted)', () => {
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.postUserConsentDecision(true, operations).subscribe()
+      expect(matDialogSpy.open).toHaveBeenCalledWith(AreYouSureDialogComponent, jasmine.any(Object))
+    })
+
+    it('should not open AreYouSureDialog when result is false (consent denied)', () => {
+      component.postUserConsentDecision(false, operations).subscribe()
+      expect(matDialogSpy.open).not.toHaveBeenCalled()
+    })
+
+    it('should call executeErase when AreYouSure dialog is confirmed', () => {
+      component.platformEraseEnabled.set(true)
+      component.eraseCaps.set([
+        { key: 'secureEraseSsds', supported: true },
+        { key: 'tpmClear', supported: false },
+        { key: 'biosRestore', supported: false },
+        { key: 'csmeUnconfigure', supported: false }
+      ])
+      component.eraseCapsArray.at(0).enable()
+      component.eraseCapsArray.at(0).setValue(true)
+      component.selectedCapsCount.set(1)
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      component.postUserConsentDecision(null, operations).subscribe()
+      expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalled()
+    })
+
+    it('should not call executeErase when AreYouSure dialog is cancelled', () => {
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.postUserConsentDecision(null, operations).subscribe()
+      expect(devicesServiceSpy.setRemoteEraseOptions).not.toHaveBeenCalled()
+    })
+
+    it('should pass device label and operations in the dialog data', () => {
+      component.deviceLabel.set('my-device')
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.postUserConsentDecision(null, operations).subscribe()
+      const config = matDialogSpy.open.calls.mostRecent().args[1] as any
+      expect(config.data.params.device).toBe('my-device')
+      expect(config.data.params.operations).toBe(operations)
+    })
+  })
+
+  describe('initiateErase user consent flow', () => {
+    beforeEach(() => {
+      devicesServiceSpy.getAMTFeatures.and.returnValue(of({ ...mockAMTFeatures, rpe: true }))
+      component.ngOnInit()
+      component.toggleFeature(true)
+      component.eraseCapControl(0).setValue(true)
+      component.onCapChange()
+    })
+
+    it('should call handleUserConsentDecision via UserConsentService', () => {
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.initiateErase()
+      expect(userConsentServiceSpy.handleUserConsentDecision).toHaveBeenCalled()
+    })
+
+    it('should call handleUserConsentDecision with deviceId and amtFeatures', () => {
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.initiateErase()
+      expect(userConsentServiceSpy.handleUserConsentDecision).toHaveBeenCalledWith(
+        jasmine.anything(),
+        '',
+        component.amtFeatures() ?? undefined
+      )
+    })
+
+    it('should call handleUserConsentResponse with RPE as feature name', () => {
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.initiateErase()
+      expect(userConsentServiceSpy.handleUserConsentResponse).toHaveBeenCalledWith('', null, 'RPE')
+    })
+
+    it('should open AreYouSure dialog when handleUserConsentResponse returns null (consent not required)', () => {
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(null))
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.initiateErase()
+      expect(matDialogSpy.open).toHaveBeenCalledWith(AreYouSureDialogComponent, jasmine.any(Object))
+    })
+
+    it('should open AreYouSure dialog when handleUserConsentResponse returns true (consent granted)', () => {
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(true))
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(false) } as any)
+      component.initiateErase()
+      expect(matDialogSpy.open).toHaveBeenCalledWith(AreYouSureDialogComponent, jasmine.any(Object))
+    })
+
+    it('should not open AreYouSure dialog when consent is denied', () => {
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(false))
+      component.initiateErase()
+      expect(matDialogSpy.open).not.toHaveBeenCalled()
+    })
+
+    it('should not call setRemoteEraseOptions when consent is denied', () => {
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(false))
+      component.initiateErase()
+      expect(devicesServiceSpy.setRemoteEraseOptions).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('SSD Password Validation', () => {
+    it('should validate SSD password is within 64-byte limit', () => {
+      const validPassword = 'password123'
+      component.ssdPasswordControl.setValue(validPassword)
+      expect(component.ssdPasswordControl.valid).toBe(true)
+    })
+
+    it('should reject SSD password exceeding 64 bytes', () => {
+      // Create a password that is 65 bytes (65 ASCII characters)
+      const tooLongPassword = 'a'.repeat(65)
+      component.ssdPasswordControl.setValue(tooLongPassword)
+      expect(component.ssdPasswordControl.valid).toBe(false)
+      expect(component.ssdPasswordControl.errors?.['ssdPasswordTooLong']).toBeDefined()
+    })
+
+    it('should allow SSD password exactly 64 bytes', () => {
+      // Exactly 64 bytes
+      const maxPassword = 'a'.repeat(64)
+      component.ssdPasswordControl.setValue(maxPassword)
+      expect(component.ssdPasswordControl.valid).toBe(true)
+      expect(component.ssdPasswordControl.errors).toBeNull()
+    })
+
+    it('should accept empty SSD password', () => {
+      component.ssdPasswordControl.setValue('')
+      expect(component.ssdPasswordControl.valid).toBe(true)
+    })
+
+    it('should reject SSD password with multibyte UTF-8 characters exceeding 64 bytes', () => {
+      // Chinese characters take 3 bytes each in UTF-8
+      // 22 characters × 3 bytes = 66 bytes (exceeds limit)
+      const multibytePassword = '中'.repeat(22)
+      component.ssdPasswordControl.setValue(multibytePassword)
+      expect(component.ssdPasswordControl.valid).toBe(false)
+      expect(component.ssdPasswordControl.errors?.['ssdPasswordTooLong']).toBeDefined()
+    })
+
+    it('should allow SSD password with multibyte UTF-8 characters within 64 bytes', () => {
+      // 21 Chinese characters × 3 bytes each = 63 bytes (within limit)
+      const multibytePassword = '中'.repeat(21)
+      component.ssdPasswordControl.setValue(multibytePassword)
+      expect(component.ssdPasswordControl.valid).toBe(true)
+    })
+
+    it('initiateErase should prevent submission if SSD password exceeds 64 bytes', () => {
+      component.platformEraseEnabled.set(true)
+      component.selectedCapsCount.set(1)
+      component.isSsdSelected.set(true)
+      component.isSsdEncrypted.set(true)
+      component.ssdPasswordControl.setValue('a'.repeat(65))
+
+      component.initiateErase()
+
+      expect(snackBarSpy.open).toHaveBeenCalledWith(
+        jasmine.stringContaining('remotePlatformErase.ssdPasswordTooLong'),
+        undefined,
+        jasmine.any(Object)
+      )
+      expect(devicesServiceSpy.setRemoteEraseOptions).not.toHaveBeenCalled()
+    })
+
+    it('initiateErase should allow submission if SSD password is within limit', () => {
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(null))
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      devicesServiceSpy.setRemoteEraseOptions.and.returnValue(of({}))
+
+      component.platformEraseEnabled.set(true)
+      component.selectedCapsCount.set(1)
+      component.isSsdSelected.set(true)
+      component.isSsdEncrypted.set(true)
+      component.ssdPasswordControl.setValue('a'.repeat(32))
+
+      component.initiateErase()
+
+      expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalled()
+    })
+
+    it('initiateErase should allow submission if SSD is selected but not encrypted', () => {
+      userConsentServiceSpy.handleUserConsentResponse.and.returnValue(of(null))
+      matDialogSpy.open.and.returnValue({ afterClosed: () => of(true) } as any)
+      devicesServiceSpy.setRemoteEraseOptions.and.returnValue(of({}))
+
+      component.platformEraseEnabled.set(true)
+      component.selectedCapsCount.set(1)
+      component.isSsdSelected.set(true)
+      component.isSsdEncrypted.set(false)
+
+      component.initiateErase()
+
+      expect(devicesServiceSpy.setRemoteEraseOptions).toHaveBeenCalled()
+    })
+  })
+})
diff --git a/src/app/devices/remote-platform-erase/remote-platform-erase.component.ts b/src/app/devices/remote-platform-erase/remote-platform-erase.component.ts
new file mode 100644
index 000000000..f79248d27
--- /dev/null
+++ b/src/app/devices/remote-platform-erase/remote-platform-erase.component.ts
@@ -0,0 +1,435 @@
+/*********************************************************************
+ * Copyright (c) Intel Corporation 2022
+ * SPDX-License-Identifier: Apache-2.0
+ **********************************************************************/
+
+import { Component, DestroyRef, OnInit, inject, signal, input, computed } from '@angular/core'
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop'
+import { Router } from '@angular/router'
+import { catchError, switchMap } from 'rxjs/operators'
+import {
+  FormArray,
+  FormBuilder,
+  FormControl,
+  ReactiveFormsModule,
+  AbstractControl,
+  ValidationErrors
+} from '@angular/forms'
+import { MatCardModule } from '@angular/material/card'
+import { MatCheckboxModule } from '@angular/material/checkbox'
+import { MatDivider } from '@angular/material/divider'
+import { MatProgressBar } from '@angular/material/progress-bar'
+import { MatIcon } from '@angular/material/icon'
+import { MatButton } from '@angular/material/button'
+import { MatSlideToggleModule } from '@angular/material/slide-toggle'
+import { MatFormFieldModule } from '@angular/material/form-field'
+import { MatInputModule } from '@angular/material/input'
+import { MatTooltipModule } from '@angular/material/tooltip'
+import { MatDialog } from '@angular/material/dialog'
+import { MatSnackBar } from '@angular/material/snack-bar'
+import { filter, finalize, forkJoin, Observable, of, EMPTY } from 'rxjs'
+import { DevicesService } from '../devices.service'
+import {
+  AMTFeaturesRequest,
+  AMTFeaturesResponse,
+  PowerState,
+  BootCapabilities,
+  RemoteEraseRequest,
+  UserConsentResponse
+} from '../../../models/models'
+import { ParsedPlatformEraseCapability } from './remote-platform-erase.constants'
+import SnackbarDefaults from '../../shared/config/snackBarDefault'
+import { AreYouSureDialogComponent } from '../../shared/are-you-sure/are-you-sure.component'
+import { TranslatePipe, TranslateService } from '@ngx-translate/core'
+import { PowerUpAlertComponent } from '../../shared/power-up-alert/power-up-alert.component'
+import { UserConsentService } from '../user-consent.service'
+
+const CSME_UNCONFIGURE_KEY = 'csmeUnconfigure'
+const SSD_ERASE_KEY = 'secureEraseSsds'
+const SSD_PASSWORD_MAX_BYTES = 64
+
+@Component({
+  selector: 'app-remote-platform-erase',
+  templateUrl: './remote-platform-erase.component.html',
+  styleUrl: './remote-platform-erase.component.scss',
+  imports: [
+    MatProgressBar,
+    MatCardModule,
+    MatCheckboxModule,
+    MatDivider,
+    MatSlideToggleModule,
+    ReactiveFormsModule,
+    MatIcon,
+    MatButton,
+    MatTooltipModule,
+    MatFormFieldModule,
+    MatInputModule,
+    TranslatePipe
+  ]
+})
+export class RemotePlatformEraseComponent implements OnInit {
+  private readonly devicesService = inject(DevicesService)
+  private readonly snackBar = inject(MatSnackBar)
+  private readonly destroyRef = inject(DestroyRef)
+  private readonly matDialog = inject(MatDialog)
+  private readonly fb = inject(FormBuilder)
+  private readonly translate = inject(TranslateService)
+  private readonly router = inject(Router)
+  private readonly userConsentService = inject(UserConsentService)
+
+  public deviceConnection = signal(false)
+
+  public readonly deviceId = input('')
+  public deviceLabel = signal('')
+  public isLoading = signal(false)
+  public powerState: PowerState = { powerstate: 0 }
+  public isPlatformEraseSupported = signal(false)
+  public platformEraseEnabled = signal(false)
+  public eraseCaps = signal<ParsedPlatformEraseCapability[]>([])
+  public eraseCapsArray: FormArray<FormControl<boolean | null>> = this.fb.array<boolean>([])
+  public selectedCapsCount = signal(0)
+  public isCsmeExclusiveSelected = signal(false)
+  public hasSelectedCaps = computed(() => this.selectedCapsCount() > 0)
+  public supportedCapsCount = computed(() => this.eraseCaps().filter((c) => c.supported).length)
+  public amtFeatures = signal<AMTFeaturesResponse | null>(null)
+  private csmeIndex = -1
+  private ssdIndex = -1
+  public isSsdSelected = signal(false)
+  public readyToErase = false
+  public isSsdEncrypted = signal(false)
+  public ssdEncryptedControl = this.fb.control<boolean | null>(false)
+  public ssdPasswordControl = this.fb.control<string | null>('', [this.validateSsdPasswordBytes.bind(this)])
+
+  ngOnInit(): void {
+    this.devicesService.getDevice(this.deviceId()).subscribe({
+      next: (device) => {
+        this.deviceLabel.set(device.friendlyName || device.hostname || this.deviceId())
+      }
+    })
+    forkJoin({
+      features: this.devicesService.getAMTFeatures(this.deviceId()),
+      capabilities: this.devicesService.getRemoteEraseCapabilities(this.deviceId())
+    })
+      .pipe(
+        finalize(() => this.isLoading.set(false)),
+        catchError((err) => {
+          const msg: string = err.error?.message || this.t('remotePlatformErase.errorLoad')
+          this.displayError(msg)
+          return EMPTY
+        })
+      )
+      .subscribe({
+        next: ({ features, capabilities }) => this.applyFeatures(features, capabilities)
+      })
+
+    // Reactively update the slider whenever features change (e.g. after General tab saves)
+    this.devicesService
+      .featuresChanges(this.deviceId())
+      .pipe(filter(Boolean), takeUntilDestroyed(this.destroyRef))
+      .subscribe((features) => {
+        this.isPlatformEraseSupported.set(features.rpeSupported ?? false)
+        this.platformEraseEnabled.set(features.rpe ?? false)
+        this.amtFeatures.set(features)
+        this.updateCapControlStates()
+      })
+  }
+
+  init(): void {
+    this.isLoading.set(true)
+    // device needs to be powered on in order to perform RPE
+    this.getPowerState(this.deviceId())
+      .pipe(switchMap((powerState) => this.handlePowerState(powerState)))
+      .subscribe()
+      .add(() => this.isLoading.set(false))
+  }
+
+  handlePowerState(powerState: PowerState): Observable<any> {
+    this.powerState = powerState
+    // If device is not powered on, shows alert to power up device
+    if (this.powerState.powerstate !== 2) {
+      return this.showPowerUpAlert().pipe(
+        switchMap((result) => {
+          // if they said yes, power on the device
+          if (result) {
+            return this.devicesService.sendPowerAction(this.deviceId(), 2)
+          }
+          return of(null)
+        })
+      )
+    }
+    return of(true)
+  }
+
+  getPowerState(guid: string): Observable<any> {
+    return this.devicesService.getPowerState(guid).pipe(
+      catchError((err) => {
+        this.isLoading.set(false)
+        const msg: string = err.error?.message || this.t('remotePlatformErase.errorRetrievingPower')
+        this.displayError(msg)
+        return EMPTY
+      })
+    )
+  }
+
+  showPowerUpAlert(): Observable<boolean> {
+    const dialog = this.matDialog.open(PowerUpAlertComponent)
+    return dialog.afterClosed()
+  }
+
+  onCapChange(): void {
+    const csmeSelected = this.csmeIndex >= 0 && this.eraseCapsArray.at(this.csmeIndex)?.value === true
+    if (csmeSelected) {
+      this.eraseCapsArray.controls.forEach((ctrl, i) => {
+        if (i !== this.csmeIndex && ctrl.value) {
+          ctrl.setValue(false, { emitEvent: false })
+        }
+      })
+    }
+    this.isCsmeExclusiveSelected.set(csmeSelected)
+    this.selectedCapsCount.set(this.eraseCapsArray.getRawValue().filter((v) => v === true).length)
+    const ssdSelected = this.ssdIndex >= 0 && this.eraseCapsArray.at(this.ssdIndex)?.value === true
+    this.isSsdSelected.set(ssdSelected)
+    if (!ssdSelected) {
+      this.resetSsdControls()
+    }
+    this.updateCapControlStates()
+  }
+
+  onSsdEncryptedChange(checked: boolean): void {
+    this.isSsdEncrypted.set(checked)
+    if (!checked) {
+      this.ssdPasswordControl.setValue('')
+    }
+  }
+
+  eraseCapControl(index: number): FormControl<boolean | null> {
+    return this.eraseCapsArray.at(index) as FormControl<boolean | null>
+  }
+
+  toggleFeature(enabled: boolean): void {
+    this.platformEraseEnabled.set(enabled)
+    this.updateCapControlStates()
+    const payload: AMTFeaturesRequest = {
+      userConsent: this.amtFeatures()?.userConsent ?? '',
+      enableKVM: this.amtFeatures()?.KVM ?? false,
+      enableSOL: this.amtFeatures()?.SOL ?? false,
+      enableIDER: this.amtFeatures()?.IDER ?? false,
+      ocr: this.amtFeatures()?.ocr ?? false,
+      rpe: enabled
+    }
+    this.isLoading.set(true)
+    this.devicesService
+      .setAmtFeatures(this.deviceId(), payload)
+      .pipe(
+        finalize(() => this.isLoading.set(false)),
+        catchError((err) => {
+          this.platformEraseEnabled.set(!enabled)
+          this.updateCapControlStates()
+          const msg: string = err.error?.message || this.t('remotePlatformErase.toggleFeatureError')
+          this.displayError(msg)
+          return EMPTY
+        })
+      )
+      .subscribe({
+        next: () => {
+          this.amtFeatures.update((f) => (f ? { ...f, rpe: enabled } : f))
+          this.updateCapControlStates()
+        }
+      })
+  }
+
+  initiateErase(): void {
+    if (!this.platformEraseEnabled() || !this.hasSelectedCaps()) {
+      return
+    }
+    // Validate SSD password if encrypted SSD erase is selected
+    if (this.isSsdSelected() && this.isSsdEncrypted() && this.ssdPasswordControl.invalid) {
+      const msg: string = this.t('remotePlatformErase.ssdPasswordTooLong')
+      this.displayError(msg)
+      return
+    }
+    const operations = this.eraseCaps()
+      .filter((_, i) => this.eraseCapsArray.at(i)?.value === true)
+      .map((cap) => this.t(`remotePlatformErase.cap.${cap.key}.label`))
+      .join(', ')
+
+    this.checkUserConsent()
+      .pipe(
+        switchMap((result: any) =>
+          // safely convert null to undefined for type compatibility
+          this.userConsentService.handleUserConsentDecision(result, this.deviceId(), this.amtFeatures() ?? undefined)
+        ),
+        switchMap((result: any | UserConsentResponse) =>
+          this.userConsentService.handleUserConsentResponse(this.deviceId(), result, 'RPE')
+        ),
+        switchMap((result: any) => this.postUserConsentDecision(result, operations))
+      )
+      .subscribe()
+  }
+
+  postUserConsentDecision(result: any, operations: string): Observable<any> {
+    if (result === false) {
+      return of(null)
+    }
+    return this.matDialog
+      .open(AreYouSureDialogComponent, {
+        data: {
+          message: 'remotePlatformErase.confirmMessage',
+          params: { device: this.deviceLabel() || this.deviceId(), operations }
+        }
+      })
+      .afterClosed()
+      .pipe(
+        switchMap((confirmed: boolean) => {
+          if (confirmed === true) {
+            this.executeErase()
+          }
+          return of(null)
+        })
+      )
+  }
+
+  private applyFeatures(features: AMTFeaturesResponse, capabilities: BootCapabilities): void {
+    this.amtFeatures.update((f) => (f ? { ...f, ...features } : features))
+    const supported = features.rpeSupported ?? false
+    this.isPlatformEraseSupported.set(supported)
+    this.platformEraseEnabled.set(features.rpe ?? false)
+    const caps: ParsedPlatformEraseCapability[] = [
+      { key: 'secureEraseSsds', supported: capabilities.secureEraseAllSSDs },
+      { key: 'tpmClear', supported: capabilities.tpmClear },
+      { key: 'biosRestore', supported: capabilities.restoreBIOSToEOM },
+      { key: 'csmeUnconfigure', supported: capabilities.unconfigureCSME }
+    ]
+    this.eraseCaps.set(caps)
+    this.csmeIndex = caps.findIndex((c) => c.key === CSME_UNCONFIGURE_KEY)
+    this.ssdIndex = caps.findIndex((c) => c.key === SSD_ERASE_KEY)
+    this.eraseCapsArray = this.fb.array(
+      caps.map((cap) => this.fb.control<boolean | null>({ value: false, disabled: !cap.supported }))
+    )
+    this.selectedCapsCount.set(0)
+    this.isCsmeExclusiveSelected.set(false)
+    this.resetSsdControls()
+    this.updateCapControlStates()
+  }
+
+  private executeErase(): void {
+    const caps = this.eraseCaps()
+    const req: RemoteEraseRequest = {
+      secureEraseAllSSDs: caps.some((c, i) => c.key === 'secureEraseSsds' && this.eraseCapsArray.at(i)?.value === true),
+      tpmClear: caps.some((c, i) => c.key === 'tpmClear' && this.eraseCapsArray.at(i)?.value === true),
+      restoreBIOSToEOM: caps.some((c, i) => c.key === 'biosRestore' && this.eraseCapsArray.at(i)?.value === true),
+      unconfigureCSME: caps.some((c, i) => c.key === 'csmeUnconfigure' && this.eraseCapsArray.at(i)?.value === true)
+    }
+    if (req.secureEraseAllSSDs && this.isSsdEncrypted()) {
+      req.ssdPassword = this.ssdPasswordControl.value ?? ''
+    }
+    this.isLoading.set(true)
+    this.devicesService
+      .setRemoteEraseOptions(this.deviceId(), req)
+      .pipe(
+        finalize(() => this.isLoading.set(false)),
+        catchError((err) => {
+          const msg: string = err.error?.message || this.t('remotePlatformErase.eraseError')
+          this.displayError(msg)
+          return EMPTY
+        })
+      )
+      .subscribe({
+        next: () => {
+          if (req.unconfigureCSME) {
+            this.devicesService
+              .sendDeactivate(this.deviceId())
+              .pipe(catchError(() => EMPTY))
+              .subscribe(() => {
+                this.snackBar.open(
+                  this.t('remotePlatformErase.csmeEraseSuccess'),
+                  undefined,
+                  SnackbarDefaults.defaultSuccess
+                )
+                void this.router.navigate(['/devices'])
+              })
+          } else {
+            const successMsg = req.secureEraseAllSSDs
+              ? this.t('remotePlatformErase.osEraseSuccess')
+              : this.t('remotePlatformErase.eraseSuccess')
+            this.snackBar.open(successMsg, undefined, SnackbarDefaults.defaultSuccess)
+            const payload: AMTFeaturesRequest = {
+              userConsent: this.amtFeatures()?.userConsent ?? '',
+              enableKVM: this.amtFeatures()?.KVM ?? false,
+              enableSOL: this.amtFeatures()?.SOL ?? false,
+              enableIDER: this.amtFeatures()?.IDER ?? false,
+              ocr: this.amtFeatures()?.ocr ?? false,
+              rpe: true
+            }
+            this.devicesService
+              .setAmtFeatures(this.deviceId(), payload)
+              .pipe(catchError(() => EMPTY))
+              .subscribe()
+
+            // Preserve selected operations after completion and refresh computed UI state.
+            this.onCapChange()
+          }
+        }
+      })
+  }
+
+  private updateCapControlStates(): void {
+    const featureEnabled = this.platformEraseEnabled()
+    const csmeSelected = this.isCsmeExclusiveSelected()
+    this.eraseCaps().forEach((cap, i) => {
+      const ctrl = this.eraseCapsArray.at(i)
+      const blockedByCsme = csmeSelected && i !== this.csmeIndex
+      const shouldEnable = cap.supported && featureEnabled && !blockedByCsme
+      if (shouldEnable) {
+        ctrl.enable({ emitEvent: false })
+      } else {
+        ctrl.disable({ emitEvent: false })
+      }
+    })
+    if (!featureEnabled && this.isSsdSelected()) {
+      this.resetSsdControls()
+    }
+  }
+
+  checkUserConsent(): Observable<any> {
+    if (
+      this.amtFeatures()?.userConsent === 'none' ||
+      this.amtFeatures()?.optInState === 3 ||
+      this.amtFeatures()?.optInState === 4
+    ) {
+      this.readyToErase = true
+      // Auto-connect when user consent is not required
+      this.deviceConnection.set(true)
+      return of(true)
+    }
+    this.readyToErase = false
+    return of(false)
+  }
+
+  private resetSsdControls(): void {
+    this.isSsdSelected.set(false)
+    this.isSsdEncrypted.set(false)
+    this.ssdEncryptedControl.setValue(false)
+    this.ssdPasswordControl.setValue('')
+  }
+
+  private validateSsdPasswordBytes(control: AbstractControl): ValidationErrors | null {
+    const value = control.value as string | null
+    if (!value) {
+      return null
+    }
+    const byteLength = new TextEncoder().encode(value).length
+    if (byteLength > SSD_PASSWORD_MAX_BYTES) {
+      return { ssdPasswordTooLong: { maxBytes: SSD_PASSWORD_MAX_BYTES, actualBytes: byteLength } }
+    }
+    return null
+  }
+
+  displayError(message: string): void {
+    this.snackBar.open(message, undefined, SnackbarDefaults.defaultError)
+  }
+
+  private t(key: string): string {
+    return this.translate.instant(`${key}.value`) as string
+  }
+}
diff --git a/src/app/devices/remote-platform-erase/remote-platform-erase.constants.ts b/src/app/devices/remote-platform-erase/remote-platform-erase.constants.ts
new file mode 100644
index 000000000..affd2ff3a
--- /dev/null
+++ b/src/app/devices/remote-platform-erase/remote-platform-erase.constants.ts
@@ -0,0 +1,26 @@
+/*********************************************************************
+ * Copyright (c) Intel Corporation 2022
+ * SPDX-License-Identifier: Apache-2.0
+ **********************************************************************/
+
+/**
+ * Bitmask definitions for AMT_BootCapabilities.PlatformErase.
+ * Capabilities vary by AMT/CSME version.
+ * Reference: https://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide/
+ *   default.htm?turl=HTMLDocuments%2FWS-Management_Class_Reference%2FAMT_BootCapabilities.htm%23PlatformErase
+ */
+export interface PlatformEraseCapability {
+  key: string
+}
+
+export const PLATFORM_ERASE_CAPABILITIES: PlatformEraseCapability[] = [
+  { key: 'secureEraseSsds' },
+  { key: 'tpmClear' },
+  { key: 'biosRestore' },
+  { key: 'csmeUnconfigure' }
+]
+
+export interface ParsedPlatformEraseCapability {
+  key: string
+  supported: boolean
+}
diff --git a/src/app/devices/sol/sol.component.spec.ts b/src/app/devices/sol/sol.component.spec.ts
index 8f1c3cc9c..4cd642a4f 100644
--- a/src/app/devices/sol/sol.component.spec.ts
+++ b/src/app/devices/sol/sol.component.spec.ts
@@ -63,7 +63,8 @@ describe('SolComponent', () => {
         ocr: true,
         winREBootSupported: true,
         localPBABootSupported: true,
-        remoteErase: true,
+        rpeSupported: true,
+        rpe: true,
         pbaBootFilesPath: [],
         winREBootFilesPath: {
           instanceID: '',
@@ -85,7 +86,8 @@ describe('SolComponent', () => {
         ocr: true,
         winREBootSupported: true,
         localPBABootSupported: true,
-        remoteErase: true,
+        rpeSupported: true,
+        rpe: true,
         pbaBootFilesPath: [],
         winREBootFilesPath: {
           instanceID: '',
@@ -273,7 +275,8 @@ describe('SolComponent', () => {
           ocr: true,
           winREBootSupported: true,
           localPBABootSupported: true,
-          remoteErase: true,
+          rpeSupported: true,
+          rpe: true,
           pbaBootFilesPath: [],
           winREBootFilesPath: {
             instanceID: '',
@@ -320,7 +323,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -361,7 +365,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -388,7 +393,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -417,7 +423,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -447,7 +454,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -476,7 +484,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
@@ -505,7 +514,8 @@ describe('SolComponent', () => {
       ocr: true,
       winREBootSupported: true,
       localPBABootSupported: true,
-      remoteErase: true,
+      rpeSupported: true,
+      rpe: true,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
diff --git a/src/app/devices/sol/sol.component.ts b/src/app/devices/sol/sol.component.ts
index 22921b929..76c1eac02 100644
--- a/src/app/devices/sol/sol.component.ts
+++ b/src/app/devices/sol/sol.component.ts
@@ -202,7 +202,7 @@ export class SolComponent implements OnInit, OnDestroy {
             enableSOL: true,
             enableIDER: this.amtFeatures()?.IDER ?? false,
             ocr: this.amtFeatures()?.ocr ?? false,
-            remoteErase: this.amtFeatures()?.remoteErase ?? false
+            rpe: this.amtFeatures()?.rpe ?? false
           }
           return this.devicesService.setAmtFeatures(this.deviceId(), payload)
         }
diff --git a/src/app/devices/user-consent.service.spec.ts b/src/app/devices/user-consent.service.spec.ts
index f876dd030..0a58b19c6 100644
--- a/src/app/devices/user-consent.service.spec.ts
+++ b/src/app/devices/user-consent.service.spec.ts
@@ -80,7 +80,8 @@ describe('UserConsentService', () => {
       httpsBootSupported: false,
       winREBootSupported: false,
       localPBABootSupported: false,
-      remoteErase: false,
+      rpeSupported: true,
+      rpe: false,
       pbaBootFilesPath: [],
       winREBootFilesPath: {
         instanceID: '',
diff --git a/src/app/shared/are-you-sure/are-you-sure.component.html b/src/app/shared/are-you-sure/are-you-sure.component.html
index 4b7f176df..6f17d47cf 100644
--- a/src/app/shared/are-you-sure/are-you-sure.component.html
+++ b/src/app/shared/are-you-sure/are-you-sure.component.html
@@ -1,5 +1,7 @@
 <h2 mat-dialog-title>{{ 'delete.question.value' | translate }}</h2>
-<mat-dialog-content class="mat-typography"> {{ 'delete.questionRecord.value' | translate }} </mat-dialog-content>
+<mat-dialog-content class="mat-typography">
+  {{ (data?.message ?? 'delete.questionRecord') + '.value' | translate: data?.params }}
+</mat-dialog-content>
 <mat-dialog-actions align="end">
   <button mat-button data-cy="no" mat-dialog-close>{{ 'common.no.value' | translate }}</button>
   <button mat-button data-cy="yes" [mat-dialog-close]="true" cdkFocusInitial>
diff --git a/src/app/shared/are-you-sure/are-you-sure.component.ts b/src/app/shared/are-you-sure/are-you-sure.component.ts
index d1bd7557a..2d95aad28 100644
--- a/src/app/shared/are-you-sure/are-you-sure.component.ts
+++ b/src/app/shared/are-you-sure/are-you-sure.component.ts
@@ -3,10 +3,16 @@
  * SPDX-License-Identifier: Apache-2.0
  **********************************************************************/
 
-import { Component } from '@angular/core'
+import { Component, inject } from '@angular/core'
 import { MatButton } from '@angular/material/button'
 import { CdkScrollable } from '@angular/cdk/scrolling'
-import { MatDialogTitle, MatDialogContent, MatDialogActions, MatDialogClose } from '@angular/material/dialog'
+import {
+  MAT_DIALOG_DATA,
+  MatDialogTitle,
+  MatDialogContent,
+  MatDialogActions,
+  MatDialogClose
+} from '@angular/material/dialog'
 import { TranslatePipe } from '@ngx-translate/core'
 @Component({
   selector: 'app-are-you-sure',
@@ -22,4 +28,8 @@ import { TranslatePipe } from '@ngx-translate/core'
     TranslatePipe
   ]
 })
-export class AreYouSureDialogComponent {}
+export class AreYouSureDialogComponent {
+  protected readonly data = inject<{ message?: string; params?: Record<string, unknown> } | null>(MAT_DIALOG_DATA, {
+    optional: true
+  })
+}
diff --git a/src/assets/i18n/ar.json b/src/assets/i18n/ar.json
index 52439cf57..f980275e6 100644
--- a/src/assets/i18n/ar.json
+++ b/src/assets/i18n/ar.json
@@ -1427,6 +1427,10 @@
     "description": "تسمية لـ HTTPS تشغيل الشبكة",
     "value": "HTTPS تشغيل الشبكة:"
   },
+  "general.remotePlatformErase": {
+    "description": "تسمية لمسح المنصة عن بُعد",
+    "value": "مسح المنصة عن بُعد:"
+  },
   "general.ideRedirection": {
     "description": "تسمية لإعادة توجيه IDE",
     "value": "إعادة توجيه IDE:"
@@ -1447,6 +1451,10 @@
     "description": "أداة التلميح لـ One Click Recovery غير مدعومة",
     "value": "لا يتم دعم الاسترداد بنقرة واحدة"
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "أداة التلميح لمسح النظام الأساسي عن بُعد غير مدعومة",
+    "value": "مسح النظام الأساسي عن بُعد غير مدعوم"
+  },
   "general.pbaBootShort": {
     "description": "تسمية لتمهيد PBA",
     "value": "تشغيل PBA:"
@@ -2401,6 +2409,10 @@
     "description": "عنوان مربع الحوار لتحذير كلمة المرور العشوائية",
     "value": "استخدام كلمات مرور عشوائية"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "رسالة خطأ عند تجاوز كلمة مرور SSD 32 بايت",
+    "value": "يجب أن لا تتجاوز كلمة مرور SSD 32 بايت"
+  },
   "sol.connect": {
     "description": "زر للاتصال بـ SOL",
     "value": "ربط SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "لا توجد بيانات متاحة",
     "description": "رسالة عند عدم توفر بيانات"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "اسم الفئة لمسح المنصة عن بُعد",
+    "value": "مسح المنصة عن بُعد"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "وصف لمسح المنصة عن بُعد",
+    "value": "مسح بيانات المنصة بشكل آمن"
+  },
+  "remotePlatformErase.title": {
+    "description": "عنوان بطاقة ميزة مسح المنصة عن بُعد",
+    "value": "مسح المنصة عن بُعد"
+  },
+  "remotePlatformErase.description": {
+    "description": "عنوان فرعي لبطاقة ميزة مسح المنصة عن بُعد",
+    "value": "تشغيل محو آمن عن بُعد للأقراص و TPM و BIOS على هذا الجهاز. لا يمكن استرداد البيانات الممحوة.",
+    "_value_old": "تشغيل محو آمن عن بُعد للأقراص و TPM و BIOS أو Intel CSME على هذا الجهاز. لا يمكن استرداد البيانات الممحوة."
+  },
+  "remotePlatformErase.warning": {
+    "description": "رسالة تحذير حول تمكين مسح المنصة عن بُعد",
+    "value": "تمكين هذه الميزة يسمح بمسح بيانات المنصة عن بُعد. استخدمها بحذر."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "تسمية مفتاح تبديل تمكين مسح المنصة عن بُعد",
+    "value": "تمكين مسح المنصة عن بُعد على هذا الجهاز"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "نص تعليمات أسفل مفتاح التبديل",
+    "value": "مطلوب قبل بدء أي عملية محو."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "عنوان بطاقة إجراء بدء المسح",
+    "value": "بدء المسح عن بُعد"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "عنوان فرعي لبطاقة إجراء بدء المسح",
+    "value": "مسح جميع البيانات المخزنة على هذه المنصة نهائيًا"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "تحذير قبل بدء مسح المنصة عن بُعد",
+    "value": "هذا الإجراء لا يمكن التراجع عنه. سيتم مسح جميع بيانات المنصة نهائيًا."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "تسمية زر بدء مسح المنصة عن بُعد",
+    "value": "بدء المسح عن بُعد"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "رسالة النجاح عند تبديل ميزة مسح المنصة عن بُعد",
+    "value": "تم تحديث ميزة مسح المنصة عن بُعد بنجاح"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "رسالة خطأ عند فشل تحديث ميزة مسح المنصة عن بُعد",
+    "value": "فشل تحديث ميزة مسح المنصة عن بُعد"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "رسالة نجاح بعد بدء مسح المنصة عن بُعد",
+    "value": "تم بدء مسح المنصة عن بُعد بنجاح"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "رسالة نجاح بعد مسح محرك نظام التشغيل – تطلب إعادة التثبيت",
+    "value": "تم مسح محرك نظام التشغيل بنجاح. يرجى إعادة تثبيت نظام تشغيل قبل استخدام هذا الجهاز."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "رسالة خطأ عند فشل بدء مسح المنصة عن بُعد",
+    "value": "فشل بدء مسح المنصة عن بُعد"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "رسالة خطأ عند فشل تحميل حالة ميزة مسح المنصة عن بُعد",
+    "value": "فشل تحميل حالة ميزة مسح المنصة عن بُعد"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "رسالة خطأ عند استرداد حالة الطاقة أثناء المسح البعيد",
+    "value": "خطأ في استرداد حالة الطاقة"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "الرسالة المعروضة عندما لا يدعم الجهاز مسح المنصة عن بُعد",
+    "value": "مسح المنصة عن بُعد غير مدعوم"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "وصف عنوان بطاقة إمكانيات المسح",
+    "value": "إمكانيات المسح"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "وصف بطاقة إمكانيات المسح",
+    "value": "اختر الإمكانيات المراد تضمينها في عملية المسح. لا يمكن تحديد الإمكانيات غير المدعومة."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "تلميح يظهر عند تفعيل الميزة، يطلب من المستخدم تحديد الإمكانيات المراد مسحها",
+    "value": "حدد الإمكانيات التي تريد مسحها، ثم انقر فوق بدء المسح عن بُعد."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "تسمية إمكانية المسح الآمن لجميع أقراص SSD",
+    "value": "المسح الآمن لجميع أقراص SSD"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "وصف إمكانية المسح الآمن لجميع أقراص SSD",
+    "value": "إزالة جميع المحتويات من محركات ATA وNVM من خلال مزيج من مسح الوسائط ومسح التشفير"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "تسمية خانة الاختيار التي تشير إلى أن محرك SSD يتطلب مفتاح تشفير القرص",
+    "value": "يتطلب SSD مفتاح تشفير القرص"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "تسمية حقل إدخال كلمة مرور تشفير محرك SSD",
+    "value": "كلمة مرور محرك الأقراص"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "تسمية إمكانية مسح TPM",
+    "value": "مسح TPM"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "وصف إمكانية مسح TPM",
+    "value": "حذف جميع المفاتيح المرتبطة بـTPM والبيانات المحمية بها، مثل البطاقة الذكية الافتراضية أو رقم PIN لتسجيل الدخول"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "تسمية إمكانية استعادة إعدادات BIOS إلى حالة EOM",
+    "value": "استعادة BIOS إلى حالة EOM"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "وصف إمكانية استعادة إعدادات BIOS إلى حالة EOM",
+    "value": "استعادة BIOS إلى التهيئة الذهبية لنهاية التصنيع (EOM) المحددة من قبل مصمم النظام"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "تسمية إمكانية إلغاء تهيئة برنامج Intel CSME الثابت",
+    "value": "إلغاء تهيئة برنامج Intel CSME الثابت"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "تلميح أداة على زر بدء المسح عند عدم تحديد أي إمكانية",
+    "value": "حدد إمكانية مسح واحدة على الأقل"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "رسالة مربع حوار التأكيد قبل بدء مسح المنصة عن بُعد. {{device}} هو الاسم الودي أو اسم المضيف؛ {{operations}} قائمة مفصولة بفواصل لعمليات المحو المحددة.",
+    "value": "محو وإعادة تشغيل {{device}}؟ سيتم تنفيذ: {{operations}}. لا يمكن التراجع عن هذا الإجراء."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "وصف إمكانية إلغاء تهيئة برنامج Intel CSME الثابت",
+    "value": "إلغاء توفير Intel AMT بالكامل، وإعادته إلى الحالة الافتراضية وتعطيل ميزات Intel AMT"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "رسالة معلومات تظهر عند تحديد إلغاء تهيئة CSME، تشرح سبب عدم إمكانية دمجه مع خيارات أخرى",
+    "value": "يؤدي إلغاء تهيئة CSME إلى إلغاء توفير Intel AMT بالكامل ولا يمكن دمجه مع عمليات المسح الأخرى."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "رسالة نجاح بعد إلغاء تهيئة CSME – تطلب إعادة التهيئة وتُعلم بأن الجهاز سيُزال من وحدة التحكم",
+    "value": "تم إلغاء تهيئة CSME بنجاح. يرجى إعادة تهيئة CSME. سيتم إزالة هذا الجهاز من وحدة التحكم."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "تسمية توضح عدد عمليات المحو المحددة حاليًا",
+    "value": "تم تحديد {{selected}} من أصل 3 عمليات",
+    "_value_old": "تم تحديد {{selected}} من أصل {{total}} عمليات"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "تسمية تظهر في صف القدرة عندما لا يدعمها الجهاز",
+    "value": "غير مدعوم على هذا الجهاز"
   }
 }
diff --git a/src/assets/i18n/de.json b/src/assets/i18n/de.json
index 2ff8670c5..237455432 100644
--- a/src/assets/i18n/de.json
+++ b/src/assets/i18n/de.json
@@ -1427,6 +1427,10 @@
     "description": "Bezeichnung für HTTPS-Netzwerkstart",
     "value": "HTTPS-Netzwerkstart:"
   },
+  "general.remotePlatformErase": {
+    "description": "Bezeichnung für Remote-Plattformlöschung",
+    "value": "Remote-Plattformlöschung:"
+  },
   "general.ideRedirection": {
     "description": "Bezeichnung für IDE-Umleitung",
     "value": "IDE-Umleitung:"
@@ -1447,6 +1451,10 @@
     "description": "Tooltip für „One Click Recovery” wird nicht unterstützt.",
     "value": "Die Wiederherstellung mit einem Klick wird nicht unterstützt."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Tooltip für Remote Platform Erase wird nicht unterstützt",
+    "value": "Remote Platform Erase wird nicht unterstützt."
+  },
   "general.pbaBootShort": {
     "description": "Bezeichnung für PBA-Boot",
     "value": "PBA-Boot:"
@@ -2401,6 +2409,10 @@
     "description": "Dialog-Titel für Warnung zu zufälligen Passwörtern",
     "value": "Verwendung zufällig generierter Passwörter"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Fehlermeldung wenn SSD-Passwort 32 Bytes überschreitet",
+    "value": "Das SSD-Passwort darf 32 Bytes nicht überschreiten"
+  },
   "sol.connect": {
     "description": "Schaltfläche für die Verbindung mit SOL",
     "value": "Verbinden Sie SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Keine Daten verfügbar",
     "description": "Meldung, wenn keine Daten verfügbar sind"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Kategoriename für Remote-Plattformlöschung",
+    "value": "Remote-Plattformlöschung"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Beschreibung für Remote-Plattformlöschung",
+    "value": "Plattformdaten sicher löschen"
+  },
+  "remotePlatformErase.title": {
+    "description": "Titel der Funktionskarte für Remote-Plattformlöschung",
+    "value": "Remote-Plattformlöschung"
+  },
+  "remotePlatformErase.description": {
+    "description": "Untertitel der Funktionskarte für Remote-Plattformlöschung",
+    "value": "Löst aus der Ferne ein sicheres Löschen von Laufwerken, TPM und BIOS auf diesem Gerät aus. Gelöschte Daten können nicht wiederhergestellt werden.",
+    "_value_old": "Löst aus der Ferne ein sicheres Löschen von Laufwerken, TPM, BIOS oder Intel CSME auf diesem Gerät aus. Gelöschte Daten können nicht wiederhergestellt werden."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Warnmeldung zur Aktivierung der Remote-Plattformlöschung",
+    "value": "Das Aktivieren dieser Funktion ermöglicht die Remote-Löschung von Plattformdaten. Mit Vorsicht verwenden."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Bezeichnung des Umschalters zur Aktivierung der Remote-Plattformlöschung",
+    "value": "Remote-Plattformlöschung auf diesem Gerät aktivieren"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Hilfetext unter dem Aktivierungsumschalter",
+    "value": "Erforderlich, bevor ein Löschvorgang eingeleitet werden kann."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Titel der Aktionskarte zum Einleiten der Löschung",
+    "value": "Remote-Löschung einleiten"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Untertitel der Aktionskarte zum Einleiten der Löschung",
+    "value": "Alle auf dieser Plattform gespeicherten Daten dauerhaft löschen"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Warnung vor dem Einleiten der Remote-Plattformlöschung",
+    "value": "Diese Aktion ist unwiderruflich. Alle Plattformdaten werden dauerhaft gelöscht."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Schaltflächenbeschriftung zum Einleiten der Remote-Plattformlöschung",
+    "value": "Remote-Löschung einleiten"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Erfolgsmeldung beim Umschalten der Remote-Plattformlöschungsfunktion",
+    "value": "Remote-Plattformlöschungsfunktion erfolgreich aktualisiert"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Fehlermeldung wenn die Aktualisierung der Remote-Plattformlöschungsfunktion fehlschlägt",
+    "value": "Fehler beim Aktualisieren der Remote-Plattformlöschungsfunktion"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Erfolgsmeldung nach dem Einleiten der Remote-Plattformlöschung",
+    "value": "Remote-Plattformlöschung erfolgreich eingeleitet"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Erfolgsmeldung nach dem Löschen des OS-Laufwerks – fordert zur Neuinstallation auf",
+    "value": "OS-Laufwerk erfolgreich gelöscht. Bitte installieren Sie ein Betriebssystem neu, bevor Sie dieses Gerät verwenden."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Fehlermeldung wenn die Remote-Plattformlöschung nicht eingeleitet werden kann",
+    "value": "Fehler beim Einleiten der Remote-Plattformlöschung"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Fehlermeldung beim Laden des Status der Remote-Plattformlöschungsfunktion",
+    "value": "Fehler beim Laden des Status der Remote-Plattformlöschungsfunktion"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Fehlermeldung beim Abrufen des Stromstatus während der Remote-Plattformlöschung",
+    "value": "Fehler beim Abrufen des Stromstatus"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Meldung wenn Remote-Plattformlöschung auf dem Gerät nicht unterstützt wird",
+    "value": "Remote-Plattformlöschung wird nicht unterstützt"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Titel der Löschfähigkeiten-Karte",
+    "value": "Löschfähigkeiten"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Untertitel der Löschfähigkeiten-Karte",
+    "value": "Wählen Sie die Fähigkeiten aus, die in den Löschvorgang einbezogen werden sollen. Nicht unterstützte Fähigkeiten können nicht ausgewählt werden."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Hinweis, der angezeigt wird, wenn die Funktion aktiviert ist, und den Benutzer auffordert, zu löschende Fähigkeiten auszuwählen",
+    "value": "Wählen Sie die Fähigkeiten aus, die Sie löschen möchten, und klicken Sie dann auf Remote-Löschung einleiten."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Bezeichnung für Sicheres Löschen aller SSDs",
+    "value": "Sicheres Löschen aller SSDs"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Beschreibung für Sicheres Löschen aller SSDs",
+    "value": "Entfernung aller Inhalte von ATA- und NVM-Laufwerken durch eine Kombination aus Medien- und Kryptolöschung"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Beschriftung für das Kontrollkästchen, das angibt, dass das SSD-Laufwerk einen Festplattenverschlüsselungsschlüssel benötigt",
+    "value": "SSD erfordert Festplattenverschlüsselungsschlüssel"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Beschriftung für das Eingabefeld des Verschlüsselungspassworts des SSD-Laufwerks",
+    "value": "Laufwerk-Passwort"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Bezeichnung für TPM löschen",
+    "value": "TPM löschen"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Beschreibung für TPM löschen",
+    "value": "Alle mit dem TPM verknüpften Schlüssel und damit geschützte Daten wie virtuelle Smartcards oder Anmelde-PINs löschen"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Bezeichnung für BIOS auf EOM-Zustand zurücksetzen",
+    "value": "BIOS auf EOM-Zustand zurücksetzen"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Beschreibung für BIOS auf EOM-Zustand zurücksetzen",
+    "value": "Das BIOS auf die vom Systemdesigner festgelegte EOM-Goldkonfiguration (End of Manufacture) zurücksetzen"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Bezeichnung für Intel CSME-Firmware dekonfigurieren",
+    "value": "Intel CSME-Firmware dekonfigurieren"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Beschreibung für Intel CSME-Firmware dekonfigurieren",
+    "value": "Vollständige Aufhebung der Bereitstellung von Intel AMT, Rückkehr zum Standardzustand und Deaktivierung der Intel AMT-Funktionen"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Informationsmeldung, wenn CSME-Dekonfiguration ausgewählt ist, erklärt, dass sie nicht mit anderen Optionen kombiniert werden kann",
+    "value": "Die CSME-Dekonfiguration führt eine vollständige Deprovisionierung von Intel AMT durch und kann nicht mit anderen Löschvorgängen kombiniert werden."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Erfolgsmeldung nach CSME-Dekonfiguration – fordert zur Neukonfiguration auf und teilt mit, dass das Gerät aus der Konsole entfernt wird",
+    "value": "CSME erfolgreich dekonfiguriert. Bitte konfigurieren Sie CSME neu. Dieses Gerät wird von der Konsole entfernt."
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Tooltip am Schaltfläche 'Löschen starten', wenn keine Funktion ausgewählt ist",
+    "value": "Mindestens eine Löschfunktion auswählen"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Bestätigungsdialog-Nachricht vor dem Einleiten der Remote-Plattformlöschung. {{device}} ist der Anzeigename oder Hostname; {{operations}} ist eine durch Komma getrennte Liste der ausgewählten Löschvorgänge.",
+    "value": "{{device}} löschen und neu starten? Folgendes wird ausgeführt: {{operations}}. Diese Aktion ist unwiderruflich."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Beschriftung, die anzeigt, wie viele Löschvorgänge derzeit ausgewählt sind",
+    "value": "{{selected}} von 3 Vorgängen ausgewählt",
+    "_value_old": "{{selected}} von {{total}} Vorgängen ausgewählt"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Beschriftung in einer Fähigkeitszeile, wenn das Gerät diese nicht unterstützt",
+    "value": "Auf diesem Gerät nicht unterstützt"
   }
 }
diff --git a/src/assets/i18n/en.json b/src/assets/i18n/en.json
index ff102fbb5..fecf63a84 100644
--- a/src/assets/i18n/en.json
+++ b/src/assets/i18n/en.json
@@ -1049,6 +1049,168 @@
     "description": "Description for TLS settings",
     "value": "View TLS configuration"
   },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Category name for Remote Platform Erase",
+    "value": "Remote Platform Erase"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Description for Remote Platform Erase",
+    "value": "Securely erase platform data"
+  },
+  "remotePlatformErase.title": {
+    "description": "Title for the Remote Platform Erase feature card",
+    "value": "Remote Platform Erase"
+  },
+  "remotePlatformErase.description": {
+    "description": "Subtitle for the Remote Platform Erase feature card",
+    "value": "Remotely trigger a secure erase of drives, TPM, or BIOS on this device. Erased data cannot be recovered.",
+    "_value_old": "Remotely trigger a secure erase of drives, TPM, BIOS, or Intel CSME on this device. Erased data cannot be recovered."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Warning message about enabling Remote Platform Erase",
+    "value": "Enabling this feature allows remote erasure of platform data. Use with caution."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Label for the Remote Platform Erase enable toggle",
+    "value": "Enable Remote Platform Erase on this device"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Helper text under the Remote Platform Erase enable toggle",
+    "value": "Required before any erase operation can be initiated."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Caption showing how many erase capabilities are currently selected",
+    "value": "{{selected}} of 3 operations selected",
+    "_value_old": "{{selected}} of {{total}} operations selected"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Caption shown on a capability row when the device does not support it",
+    "value": "Not supported on this device"
+  },
+  "remotePlatformErase.featureDisabled": {
+    "description": "Status message shown when Remote Platform Erase is disabled",
+    "value": "Feature is disabled. Enable it on the AMT Features tab."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Title for the initiate erase action card",
+    "value": "Initiate Remote Erase"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Subtitle for the initiate erase action card",
+    "value": "Permanently erase all data stored on this platform"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Warning before initiating a remote platform erase",
+    "value": "This action is irreversible. All platform data will be permanently erased."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Button label to initiate Remote Platform Erase",
+    "value": "Initiate Remote Erase"
+  },
+  "remotePlatformErase.initiateDisabledTooltip": {
+    "description": "Tooltip shown on the initiate erase button when the feature is disabled",
+    "value": "Enable Remote Platform Erase on the AMT Features tab first"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Tooltip shown on the initiate erase button when no capabilities are selected",
+    "value": "Select at least one erase capability"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Confirmation dialog message before initiating remote platform erase. {{device}} is the friendly name or hostname; {{operations}} is a comma-separated list of selected erase operations.",
+    "value": "Erase and restart {{device}}? This will perform: {{operations}}. This action is irreversible."
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Success message when Remote Platform Erase feature is toggled",
+    "value": "Remote Platform Erase feature updated successfully"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Error message when Remote Platform Erase feature update fails",
+    "value": "Failed to update Remote Platform Erase feature"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Success message after initiating Remote Platform Erase",
+    "value": "Remote Platform Erase initiated successfully"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Success message after OS drive erase — prompts user to reinstall",
+    "value": "OS drive erased successfully. Please reinstall an operating system before using this device."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Error message when Remote Platform Erase fails to initiate",
+    "value": "Failed to initiate Remote Platform Erase"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Error message when loading Remote Platform Erase feature status fails",
+    "value": "Failed to load Remote Platform Erase feature status"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Error message when retrieving power status fails during Remote Platform Erase",
+    "value": "Error retrieving power status"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Message shown when Remote Platform Erase is not supported on the device",
+    "value": "Remote Platform Erase is not supported"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Title for the platform erase capabilities card",
+    "value": "Erase Capabilities"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Subtitle for the platform erase capabilities card",
+    "value": "Select which capabilities to include in the erase operation. Unsupported capabilities cannot be selected."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Hint shown when feature is enabled, prompting user to select capabilities to erase",
+    "value": "Select the capabilities you want to erase, then click Initiate Remote Erase."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Label for the Secure Erase of All SSDs capability",
+    "value": "Secure Erase of All SSDs"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Description for the Secure Erase of All SSDs capability",
+    "value": "Removal of all content from ATA and NVM drives through a combination of media erase and crypto erase"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Label for the checkbox indicating the SSD drive requires a disk encryption key",
+    "value": "SSD requires disk encryption key"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Label for the SSD drive encryption password input field",
+    "value": "Drive Password"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Label for the TPM Clear capability",
+    "value": "TPM Clear"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Description for the TPM Clear capability",
+    "value": "Delete all created keys associated with the TPM and data protected by those keys, such as a virtual smart card or a login PIN"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Label for the Restore BIOS to EOM State capability",
+    "value": "Restore BIOS to EOM State"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Description for the Restore BIOS to EOM State capability",
+    "value": "Restore the BIOS to the End of Manufacture (EOM) golden configuration specified by the system designer"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Label for the Unconfigure Intel CSME Firmware capability",
+    "value": "Unconfigure Intel CSME Firmware"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Description for the Unconfigure Intel CSME Firmware capability",
+    "value": "Full unprovisioning of Intel AMT, returning to the default state and disabling Intel AMT features"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Info message shown when Unconfigure CSME is selected, explaining it cannot be combined with other options",
+    "value": "Unconfigure CSME performs a full unprovision of Intel AMT and cannot be combined with other erase operations."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Success message when CSME unconfigure is performed",
+    "value": "CSME unconfigured successfully. Please reconfigure CSME. This device will be removed from console."
+  },
   "devices.actions.deactivate": {
     "description": "Tooltip for deactivating/removing a device",
     "value": "Deactivate the device"
@@ -1591,6 +1753,10 @@
     "description": "Label for HTTPS Network boot",
     "value": "HTTPS Network boot:"
   },
+  "general.remotePlatformErase": {
+    "description": "Label for Remote Platform Erase",
+    "value": "Remote Platform Erase:"
+  },
   "general.ideRedirection": {
     "description": "Label for IDE Redirection",
     "value": "IDE Redirection:"
@@ -1611,6 +1777,10 @@
     "description": "Tooltip for One Click Recovery not supported",
     "value": "One Click Recovery is not supported"
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Tooltip for Remote Platform Erase not supported",
+    "value": "Remote Platform Erase is not supported"
+  },
   "general.pbaBootShort": {
     "description": "Label for PBA boot",
     "value": "PBA boot:"
@@ -2603,6 +2773,10 @@
     "description": "Dialog title for random password warning",
     "value": "Using Random Generated Passwords"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Error message when SSD password exceeds 32 bytes",
+    "value": "SSD password must not exceed 32 bytes"
+  },
   "sol.connect": {
     "description": "Button for connecting to SOL",
     "value": "Connect SOL"
diff --git a/src/assets/i18n/es.json b/src/assets/i18n/es.json
index e43e956a5..418d2de8f 100644
--- a/src/assets/i18n/es.json
+++ b/src/assets/i18n/es.json
@@ -1427,6 +1427,10 @@
     "description": "Etiqueta para HTTPS Arranque de red",
     "value": "HTTPS Arranque de red:"
   },
+  "general.remotePlatformErase": {
+    "description": "Etiqueta para el borrado remoto de plataforma",
+    "value": "Borrado remoto de plataforma:"
+  },
   "general.ideRedirection": {
     "description": "Etiqueta para la redirección IDE",
     "value": "Redirección IDE:"
@@ -1447,6 +1451,10 @@
     "description": "No se admite la información sobre herramientas para la recuperación con un solo clic.",
     "value": "No se admite la recuperación con un solo clic."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "No se admite la información sobre herramientas para Remote Platform Erase.",
+    "value": "Remote Platform Erase no es compatible."
+  },
   "general.pbaBootShort": {
     "description": "Etiqueta para el arranque de PBA",
     "value": "Arranque de PBA:"
@@ -2401,6 +2409,10 @@
     "description": "Título del cuadro de diálogo para la advertencia de contraseña aleatoria",
     "value": "Uso de contraseñas generadas aleatoriamente"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Mensaje de error cuando la contraseña SSD excede 32 bytes",
+    "value": "La contraseña SSD no debe exceder 32 bytes"
+  },
   "sol.connect": {
     "description": "Botón para conectarse a SOL.",
     "value": "Conecte SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "No hay datos disponibles",
     "description": "Mensaje cuando no hay datos disponibles"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Nombre de categoría para el borrado remoto de plataforma",
+    "value": "Borrado remoto de plataforma"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Descripción para el borrado remoto de plataforma",
+    "value": "Borrar datos de plataforma de forma segura"
+  },
+  "remotePlatformErase.title": {
+    "description": "Título para la tarjeta de función de borrado remoto de plataforma",
+    "value": "Borrado remoto de plataforma"
+  },
+  "remotePlatformErase.description": {
+    "description": "Subtítulo para la tarjeta de función de borrado remoto de plataforma",
+    "value": "Activa de forma remota un borrado seguro de unidades, TPM y BIOS en este dispositivo. Los datos borrados no se pueden recuperar.",
+    "_value_old": "Activa de forma remota un borrado seguro de unidades, TPM, BIOS o Intel CSME en este dispositivo. Los datos borrados no se pueden recuperar."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Mensaje de advertencia sobre la habilitación del borrado remoto de plataforma",
+    "value": "Habilitar esta función permite el borrado remoto de datos de la plataforma. Úsela con precaución."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Etiqueta del interruptor para habilitar el borrado remoto de plataforma",
+    "value": "Habilitar borrado remoto de plataforma en este dispositivo"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Texto de ayuda debajo del interruptor de habilitación",
+    "value": "Requerido antes de iniciar cualquier operación de borrado."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Título de la tarjeta de acción para iniciar el borrado",
+    "value": "Iniciar borrado remoto"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Subtítulo de la tarjeta de acción para iniciar el borrado",
+    "value": "Borrar permanentemente todos los datos almacenados en esta plataforma"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Advertencia antes de iniciar un borrado remoto de plataforma",
+    "value": "Esta acción es irreversible. Todos los datos de la plataforma se borrarán permanentemente."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Etiqueta del botón para iniciar el borrado remoto de plataforma",
+    "value": "Iniciar borrado remoto"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Mensaje de éxito al activar o desactivar la función de borrado remoto de plataforma",
+    "value": "Función de borrado remoto de plataforma actualizada correctamente"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Mensaje de error cuando falla la actualización de la función de borrado remoto de plataforma",
+    "value": "Error al actualizar la función de borrado remoto de plataforma"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Mensaje de éxito tras iniciar el borrado remoto de plataforma",
+    "value": "Borrado remoto de plataforma iniciado correctamente"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Mensaje de éxito tras borrar la unidad del SO – solicita reinstalación",
+    "value": "Unidad del sistema operativo borrada correctamente. Reinstale un sistema operativo antes de usar este dispositivo."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Mensaje de error cuando el borrado remoto de plataforma no puede iniciarse",
+    "value": "Error al iniciar el borrado remoto de plataforma"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Mensaje de error cuando falla la carga del estado de la función de borrado remoto de plataforma",
+    "value": "Error al cargar el estado de la función de borrado remoto de plataforma"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Mensaje de error al recuperar el estado de alimentación durante el borrado remoto",
+    "value": "Error al recuperar el estado de alimentación"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Mensaje que se muestra cuando el borrado remoto de plataforma no es compatible con el dispositivo",
+    "value": "El borrado remoto de plataforma no es compatible"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Título de la tarjeta de capacidades de borrado",
+    "value": "Capacidades de borrado"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Subtítulo de la tarjeta de capacidades de borrado",
+    "value": "Seleccione las capacidades a incluir en la operación de borrado. Las capacidades no compatibles no pueden seleccionarse."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Sugerencia mostrada cuando la función está habilitada, que solicita al usuario seleccionar las capacidades a borrar",
+    "value": "Seleccione las funcionalidades que desea borrar y luego haga clic en Iniciar borrado remoto."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Etiqueta para borrado seguro de todos los SSD",
+    "value": "Borrado seguro de todos los SSD"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Descripción para borrado seguro de todos los SSD",
+    "value": "Eliminación de todo el contenido de las unidades ATA y NVM mediante una combinación de borrado de medios y borrado criptográfico"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Etiqueta para la casilla de verificación que indica que la unidad SSD requiere una clave de cifrado de disco",
+    "value": "El SSD requiere clave de cifrado de disco"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Etiqueta para el campo de entrada de la contraseña de cifrado de la unidad SSD",
+    "value": "Contraseña de la unidad"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Etiqueta para borrar TPM",
+    "value": "Borrar TPM"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Descripción para borrar TPM",
+    "value": "Eliminar todas las claves creadas asociadas al TPM y los datos protegidos por ellas, como una tarjeta inteligente virtual o un PIN de inicio de sesión"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Etiqueta para restaurar BIOS al estado EOM",
+    "value": "Restaurar BIOS al estado EOM"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Descripción para restaurar BIOS al estado EOM",
+    "value": "Restaurar el BIOS a la configuración dorada de fin de fabricación (EOM) especificada por el diseñador del sistema"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Etiqueta para desconfigura el firmware Intel CSME",
+    "value": "Desconfigura el firmware Intel CSME"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Información sobre herramienta en el botón de borrado cuando no hay capacidades seleccionadas",
+    "value": "Seleccione al menos una capacidad de borrado"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Mensaje del cuadro de diálogo de confirmación antes de iniciar el borrado remoto de plataforma. {{device}} es el nombre descriptivo o nombre de host; {{operations}} es una lista separada por comas de las operaciones de borrado seleccionadas.",
+    "value": "¿Borrar y reiniciar {{device}}? Esto realizará: {{operations}}. Esta acción es irreversible."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Descripción para desconfigura el firmware Intel CSME",
+    "value": "Desaprovisionamiento completo de Intel AMT, retorno al estado predeterminado y desactivación de las funciones de Intel AMT"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Mensaje informativo mostrado cuando se selecciona Desconfigurar CSME, explicando que no se puede combinar con otras opciones",
+    "value": "La desconfiguración de CSME realiza un desaprovisionamiento completo de Intel AMT y no puede combinarse con otras operaciones de borrado."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Mensaje de éxito tras desconfigurar CSME – solicita reconfiguración e informa de que el dispositivo se eliminará de la consola",
+    "value": "CSME desconfigurado correctamente. Vuelva a configurar CSME. Este dispositivo será eliminado de la consola."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Indicador que muestra cuántas operaciones de borrado están seleccionadas actualmente",
+    "value": "{{selected}} de 3 operaciones seleccionadas",
+    "_value_old": "{{selected}} de {{total}} operaciones seleccionadas"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Indicador mostrado en una fila de capacidad cuando el dispositivo no la admite",
+    "value": "No compatible con este dispositivo"
   }
 }
diff --git a/src/assets/i18n/fi.json b/src/assets/i18n/fi.json
index 17b9ee467..9ff160bd8 100644
--- a/src/assets/i18n/fi.json
+++ b/src/assets/i18n/fi.json
@@ -1427,6 +1427,10 @@
     "description": "HTTPS-verkon käynnistysmerkki",
     "value": "HTTPS-verkkokäynnistys:"
   },
+  "general.remotePlatformErase": {
+    "description": "Etäalustan pyyhinnän etiketti",
+    "value": "Etäalustan pyyhintä:"
+  },
   "general.ideRedirection": {
     "description": "IDE-uudelleenohjauksen etiketti",
     "value": "IDE-uudelleenohjaus:"
@@ -1447,6 +1451,10 @@
     "description": "One Click Recovery -työkalun vinkki ei tueta",
     "value": "Yhden napsautuksen palautusta ei tueta."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Remote Platform Erase -työkaluvinkki ei tueta",
+    "value": "Remote Platform Erasea ei tueta."
+  },
   "general.pbaBootShort": {
     "description": "PBA-käynnistyksen etiketti",
     "value": "PBA-käynnistys:"
@@ -2401,6 +2409,10 @@
     "description": "Satunnaisen salasanan varoituksen dialogin otsikko",
     "value": "Satunnaisesti luotujen salasanojen käyttö"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Virheilmoitus kun SSD-salasana ylittää 32 tavua",
+    "value": "SSD-salasana ei saa ylittää 32 tavua"
+  },
   "sol.connect": {
     "description": "Painike SOL-yhteyden muodostamiseksi",
     "value": "Yhdistä SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Ei saatavilla olevaa dataa",
     "description": "Viesti, kun dataa ei ole saatavilla"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Etäalustan pyyhinnän kategorianimeke",
+    "value": "Etäalustan pyyhintä"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Etäalustan pyyhinnän kuvaus",
+    "value": "Tyhjennä alustan tiedot turvallisesti"
+  },
+  "remotePlatformErase.title": {
+    "description": "Etäalustan pyyhintäominaisuuden kortin otsikko",
+    "value": "Etäalustan pyyhintä"
+  },
+  "remotePlatformErase.description": {
+    "description": "Etäalustan pyyhintäominaisuuden kortin alaotsikko",
+    "value": "Käynnistää etänä suojatun poiston tämän laitteen asemille, TPM:lle ja BIOSille. Poistettuja tietoja ei voi palauttaa.",
+    "_value_old": "Käynnistää etänä suojatun poiston tämän laitteen asemille, TPM:lle, BIOSille tai Intel CSME:lle. Poistettuja tietoja ei voi palauttaa."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Varoitusviesti etäalustan pyyhinnän käyttöönotosta",
+    "value": "Tämän ominaisuuden ottaminen käyttöön mahdollistaa alustan tietojen etäpyyhinnan. Käytä varoen."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Etäalustan pyyhinnän käyttöönottokytkimen etiketti",
+    "value": "Ota etäalustan pyyhintä käyttöön tässä laitteessa"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Käyttöönottokytkimen alla oleva ohjeteksti",
+    "value": "Vaaditaan ennen minkään poistotoiminnon aloittamista."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Pyyhinnan käynnistyskortin otsikko",
+    "value": "Käynnistä etäpyyhintä"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Pyyhinnan käynnistyskortin alaotsikko",
+    "value": "Tyhjennä pysyvästi kaikki tähän alustaan tallennetut tiedot"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Varoitus ennen etäalustan pyyhinnan aloittamista",
+    "value": "Tämä toimenpide on peruuttamaton. Kaikki alustan tiedot poistetaan pysyvästi."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Etäalustan pyyhinnan käynnistyspainikkeen etiketti",
+    "value": "Käynnistä etäpyyhintä"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Onnistumisviesti etäalustan pyyhintäominaisuuden vaihtamisesta",
+    "value": "Etäalustan pyyhintäominaisuus päivitetty onnistuneesti"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Virheviesti etäalustan pyyhintäominaisuuden päivityksen epäonnistuessa",
+    "value": "Etäalustan pyyhintäominaisuuden päivitys epäonnistui"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Onnistumisviesti etäalustan pyyhinnan aloittamisen jälkeen",
+    "value": "Etäalustan pyyhintä käynnistetty onnistuneesti"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Onnistumisviesti käyttöjärjestelmäaseman pyyhinnän jälkeen – kehottaa uudelleenasennukseen",
+    "value": "Käyttöjärjestelmän asema pyyhitty onnistuneesti. Asenna käyttöjärjestelmä uudelleen ennen tämän laitteen käyttöä."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Virheviesti etäalustan pyyhinnan käynnistyksen epäonnistuessa",
+    "value": "Etäalustan pyyhinnan käynnistys epäonnistui"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Virheviesti etäalustan pyyhintäominaisuuden tilan latauksen epäonnistuessa",
+    "value": "Etäalustan pyyhintäominaisuuden tilan lataus epäonnistui"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Virheviesti virran tilan hakemisen epäonnistuessa etäpyyhinnän aikana",
+    "value": "Virhe virran tilan hakemisessa"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Viesti laitteen etäalustan pyyhinnän tuen puuttuessa",
+    "value": "Etäalustan pyyhintää ei tueta"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Pyyhintäominaisuuksien kortin otsikko",
+    "value": "Pyyhintäominaisuudet"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Pyyhintäominaisuuksien kortin alaotsikko",
+    "value": "Valitse pyyhintätoimintoon sisällytettävät ominaisuudet. Ei-tuettuja ominaisuuksia ei voi valita."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Hint shown when feature is enabled, prompting user to select capabilities to erase",
+    "value": "Valitse poistettavat ominaisuudet ja napsauta sitten Käynnistä etäpyyhintä."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Kaikkien SSD-levyjen turvallisen pyyhinnän nimi",
+    "value": "Kaikkien SSD-levyjen turvallinen pyyhintä"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Kaikkien SSD-levyjen turvallisen pyyhinnän kuvaus",
+    "value": "Kaiken sisällön poistaminen ATA- ja NVM-asemilta median ja salauksen pyyhinnän yhdistelmällä"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Valintaruudun otsikko, joka ilmaisee, että SSD-asema vaatii levyn salausavaimen",
+    "value": "SSD vaatii levyn salausavaimen"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "SSD-aseman salaussalasanan syöttökentän otsikko",
+    "value": "Aseman salasana"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "TPM:n tyhjennyksen nimi",
+    "value": "TPM:n tyhjennys"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "TPM:n tyhjennyksen kuvaus",
+    "value": "Kaikkien TPM:hen liittyvien avainten ja niillä suojattujen tietojen poistaminen, kuten virtuaalinen älykortti tai kirjautumis-PIN"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "BIOS EOM-tilaan palauttamisen nimi",
+    "value": "Palauta BIOS EOM-tilaan"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "BIOS EOM-tilaan palauttamisen kuvaus",
+    "value": "Palauta BIOS järjestelmäsuunnittelijan määrittämään End of Manufacture (EOM) -perusmääritykseen"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Intel CSME -laiteohjelmiston konfiguraation poiston nimi",
+    "value": "Poista Intel CSME -laiteohjelmiston konfiguraatio"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Työkaluvihje poistopainikkeen päällä, kun ominaisuuksia ei ole valittu",
+    "value": "Valitse vähintään yksi poisto-ominaisuus"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Vahvistusvalintaikkunan viesti ennen etäalustan pyyhinnän aloittamista. {{device}} on laitteen näyttönimi tai isäntänimi; {{operations}} on pilkuilla eroteltu luettelo valituista pyyhintätoiminnoista.",
+    "value": "Tyhjennä ja käynnistä {{device}} uudelleen? Tämä suorittaa: {{operations}}. Toimintoa ei voi perua."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Intel CSME -laiteohjelmiston konfiguraation poiston kuvaus",
+    "value": "Intel AMT:n täysi poistaminen käytöstä, palautus oletustilaan ja Intel AMT -ominaisuuksien poistaminen käytöstä"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Tietosanoma, joka näytetään kun CSME:n konfiguraation poisto on valittu, selittäen ettei sitä voi yhdistää muihin vaihtoehtoihin",
+    "value": "CSME:n konfiguraation poisto suorittaa Intel AMT:n täydellisen poistamisen ja sitä ei voi yhdistää muihin poistotoimintoihin."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Onnistumisviesti CSME:n konfiguraation poiston jälkeen – kehottaa uudelleenkonfigurointiin ja ilmoittaa, että laite poistetaan konsolista",
+    "value": "CSME:n konfiguraatio poistettu onnistuneesti. Konfiguroi CSME uudelleen. Tämä laite poistetaan konsolista."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Teksti, joka näyttää kuinka monta pyyhintätoimintoa on valittu",
+    "value": "{{selected}} / 3 toimintoa valittu",
+    "_value_old": "{{selected}} / {{total}} toimintoa valittu"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Teksti, joka näytetään ominaisuusrivillä, kun laite ei tue sitä",
+    "value": "Ei tuettu tässä laitteessa"
   }
 }
diff --git a/src/assets/i18n/fr.json b/src/assets/i18n/fr.json
index 2752c73a2..6a2a90c14 100644
--- a/src/assets/i18n/fr.json
+++ b/src/assets/i18n/fr.json
@@ -1427,6 +1427,10 @@
     "description": "Étiquette pour le démarrage réseau HTTPS",
     "value": "HTTPS Démarrage réseau :"
   },
+  "general.remotePlatformErase": {
+    "description": "Étiquette pour l'effacement distant de la plateforme",
+    "value": "Effacement distant de la plateforme :"
+  },
   "general.ideRedirection": {
     "description": "Étiquette pour la redirection IDE",
     "value": "Redirection IDE :"
@@ -1447,6 +1451,10 @@
     "description": "Info-bulle pour la récupération en un clic non prise en charge",
     "value": "La récupération en un clic n'est pas prise en charge."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Info-bulle pour Remote Platform Erase non prise en charge",
+    "value": "Remote Platform Erase n'est pas pris en charge."
+  },
   "general.pbaBootShort": {
     "description": "Étiquette pour le démarrage PBA",
     "value": "Démarrage PBA :"
@@ -2401,6 +2409,10 @@
     "description": "Titre de la boîte de dialogue pour l'avertissement relatif au mot de passe aléatoire",
     "value": "Utilisation de mots de passe générés aléatoirement"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Message d'erreur lorsque le mot de passe SSD dépasse 32 bytes",
+    "value": "Le mot de passe SSD ne doit pas dépasser 32 bytes"
+  },
   "sol.connect": {
     "description": "Bouton pour se connecter à SOL",
     "value": "Connectez SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Aucune donnée disponible",
     "description": "Message indiquant qu’aucune donnée n’est disponible"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Nom de catégorie pour l'effacement distant de la plateforme",
+    "value": "Effacement distant de la plateforme"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Description pour l'effacement distant de la plateforme",
+    "value": "Effacer les données de la plateforme en toute sécurité"
+  },
+  "remotePlatformErase.title": {
+    "description": "Titre de la carte de fonctionnalité d'effacement distant de la plateforme",
+    "value": "Effacement distant de la plateforme"
+  },
+  "remotePlatformErase.description": {
+    "description": "Sous-titre de la carte de fonctionnalité d'effacement distant de la plateforme",
+    "value": "Déclenche à distance un effacement sécurisé des disques, TPM et BIOS sur cet appareil. Les données effacées ne peuvent pas être récupérées.",
+    "_value_old": "Déclenche à distance un effacement sécurisé des disques, TPM, BIOS ou Intel CSME sur cet appareil. Les données effacées ne peuvent pas être récupérées."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Message d'avertissement concernant l'activation de l'effacement distant de la plateforme",
+    "value": "L'activation de cette fonctionnalité permet l'effacement à distance des données de la plateforme. À utiliser avec précaution."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Étiquette du commutateur d'activation de l'effacement distant de la plateforme",
+    "value": "Activer l'effacement distant de la plateforme sur cet appareil"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Texte d'aide sous le commutateur d'activation",
+    "value": "Requis avant d'initier toute opération d'effacement."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Titre de la carte d'action pour lancer l'effacement",
+    "value": "Lancer l'effacement distant"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Sous-titre de la carte d'action pour lancer l'effacement",
+    "value": "Effacer définitivement toutes les données stockées sur cette plateforme"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Avertissement avant de lancer un effacement distant de la plateforme",
+    "value": "Cette action est irréversible. Toutes les données de la plateforme seront définitivement effacées."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Étiquette du bouton pour lancer l'effacement distant de la plateforme",
+    "value": "Lancer l'effacement distant"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Message de succès lors de l'activation ou désactivation de l'effacement distant de la plateforme",
+    "value": "Fonctionnalité d'effacement distant de la plateforme mise à jour avec succès"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Message d'erreur quand la mise à jour de l'effacement distant de la plateforme échoue",
+    "value": "Échec de la mise à jour de la fonctionnalité d'effacement distant de la plateforme"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Message de succès après le lancement de l'effacement distant de la plateforme",
+    "value": "Effacement distant de la plateforme lancé avec succès"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Message de succès après l'effacement du lecteur OS – invite à réinstaller",
+    "value": "Lecteur OS effacé avec succès. Veuillez réinstaller un système d'exploitation avant d'utiliser cet appareil."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Message d'erreur quand l'effacement distant de la plateforme ne peut pas être lancé",
+    "value": "Échec du lancement de l'effacement distant de la plateforme"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Message d'erreur lors du chargement du statut de l'effacement distant de la plateforme",
+    "value": "Échec du chargement du statut de la fonctionnalité d'effacement distant de la plateforme"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Message d'erreur lors de la récupération de l'état d'alimentation pendant l'effacement distant",
+    "value": "Erreur lors de la récupération de l'état d'alimentation"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Message affiché quand l'effacement distant de la plateforme n'est pas pris en charge",
+    "value": "L'effacement distant de la plateforme n'est pas pris en charge"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Titre de la carte des capacités d'effacement",
+    "value": "Capacités d'effacement"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Sous-titre de la carte des capacités d'effacement",
+    "value": "Sélectionnez les capacités à inclure dans l'opération d'effacement. Les capacités non prises en charge ne peuvent pas être sélectionnées."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Indication affichée lorsque la fonctionnalité est activée, invitant l'utilisateur à sélectionner les capacités à effacer",
+    "value": "Sélectionnez les fonctionnalités à effacer, puis cliquez sur Lancer l'effacement distant."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Étiquette pour l'effacement sécurisé de tous les SSD",
+    "value": "Effacement sécurisé de tous les SSD"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Description pour l'effacement sécurisé de tous les SSD",
+    "value": "Suppression de tout le contenu des lecteurs ATA et NVM par une combinaison d'effacement de média et d'effacement cryptographique"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Étiquette pour la case à cocher indiquant que le lecteur SSD nécessite une clé de chiffrement de disque",
+    "value": "Le SSD nécessite une clé de chiffrement de disque"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Étiquette pour le champ de saisie du mot de passe de chiffrement du lecteur SSD",
+    "value": "Mot de passe du lecteur"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Étiquette pour l'effacement du TPM",
+    "value": "Effacement du TPM"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Description pour l'effacement du TPM",
+    "value": "Suppression de toutes les clés créées associées au TPM et des données protégées par ces clés, telles qu'une carte à puce virtuelle ou un code PIN de connexion"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Étiquette pour la restauration du BIOS à l'état EOM",
+    "value": "Restaurer le BIOS à l'état EOM"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Description pour la restauration du BIOS à l'état EOM",
+    "value": "Restaurer le BIOS à la configuration dorée de fin de fabrication (EOM) spécifiée par le concepteur du système"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Étiquette pour la déconfiguration du micrologiciel Intel CSME",
+    "value": "Déconfigurer le micrologiciel Intel CSME"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Info-bulle sur le bouton d'effacement lorsqu'aucune capacité n'est sélectionnée",
+    "value": "Sélectionnez au moins une capacité d'effacement"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Message de la boîte de dialogue de confirmation avant d'initier l'effacement distant de la plateforme. {{device}} est le nom convivial ou le nom d'hôte ; {{operations}} est la liste séparée par des virgules des opérations d'effacement sélectionnées.",
+    "value": "Effacer et redémarrer {{device}} ? Actions effectuées : {{operations}}. Cette action est irréversible."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Description pour la déconfiguration du micrologiciel Intel CSME",
+    "value": "Annulation complète du provisionnement d'Intel AMT, retour à l'état par défaut et désactivation des fonctionnalités Intel AMT"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Message d'information affiché lorsque Déconfigurer CSME est sélectionné, expliquant qu'il ne peut pas être combiné avec d'autres options",
+    "value": "La déconfiguration de CSME effectue un déprovisionnement complet d'Intel AMT et ne peut pas être combinée avec d'autres opérations d'effacement."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Message de succès après la déconfiguration CSME – invite à reconfigurer et informe que l'appareil sera supprimé de la console",
+    "value": "CSME déconfigurée avec succès. Veuillez reconfigurer CSME. Cet appareil sera supprimé de la console."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Légende indiquant combien d'opérations d'effacement sont actuellement sélectionnées",
+    "value": "{{selected}} opération(s) sélectionnée(s) sur 3",
+    "_value_old": "{{selected}} opération(s) sélectionnée(s) sur {{total}}"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Légende affichée sur une ligne de capacité lorsque l'appareil ne la prend pas en charge",
+    "value": "Non pris en charge sur cet appareil"
   }
 }
diff --git a/src/assets/i18n/he.json b/src/assets/i18n/he.json
index 6e74fc3e3..f32780056 100644
--- a/src/assets/i18n/he.json
+++ b/src/assets/i18n/he.json
@@ -1427,6 +1427,10 @@
     "description": "תווית עבור אתחול רשת HTTPS",
     "value": "אתחול רשת HTTPS:"
   },
+  "general.remotePlatformErase": {
+    "description": "תווית למחיקת פלטפורמה מרחוק",
+    "value": "מחיקת פלטפורמה מרחוק:"
+  },
   "general.ideRedirection": {
     "description": "תווית לניתוב מחדש של IDE",
     "value": "ניתוב מחדש של IDE:"
@@ -1447,6 +1451,10 @@
     "description": "קובץ כלים לשחזור לחיצה אחת לא נתמך",
     "value": "התאוששות בלחיצה אחת אינה נתמכת"
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "כלי טיפים למחיקת פלטפורמה מרחוק אינו נתמך",
+    "value": "מחיקת פלטפורמה מרחוק אינה נתמכת"
+  },
   "general.pbaBootShort": {
     "description": "תווית ל- PBA Boot",
     "value": "מגף PBA:"
@@ -2401,6 +2409,10 @@
     "description": "כותרת דו -שיח לאזהרת סיסמא אקראית",
     "value": "באמצעות סיסמאות שנוצרו אקראיות"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "הודעת שגיאה כאשר סיסמת SSD עולה על 32 בתים",
+    "value": "סיסמת SSD לא יכולה להעלות על 32 בתים"
+  },
   "sol.connect": {
     "description": "כפתור לחיבור ל- SOL",
     "value": "Connect Sol"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "אין נתונים זמינים",
     "description": "הודעה כאשר אין נתונים זמינים"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "שם קטגוריה למחיקת פלטפורמה מרחוק",
+    "value": "מחיקת פלטפורמה מרחוק"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "תיאור למחיקת פלטפורמה מרחוק",
+    "value": "מחיקה מאובטחת של נתוני הפלטפורמה"
+  },
+  "remotePlatformErase.title": {
+    "description": "כותרת לכרטיס תכונת מחיקת פלטפורמה מרחוק",
+    "value": "מחיקת פלטפורמה מרחוק"
+  },
+  "remotePlatformErase.description": {
+    "description": "כותרת משנה לכרטיס תכונת מחיקת פלטפורמה מרחוק",
+    "value": "הפעלה מרחוק של מחיקה מאובטחת של כוננים, TPM ו-BIOS במכשיר זה. לא ניתן לשחזר נתונים שנמחקו.",
+    "_value_old": "הפעלה מרחוק של מחיקה מאובטחת של כוננים, TPM, BIOS או Intel CSME במכשיר זה. לא ניתן לשחזר נתונים שנמחקו."
+  },
+  "remotePlatformErase.warning": {
+    "description": "הודעת אזהרה על הפעלת מחיקת פלטפורמה מרחוק",
+    "value": "הפעלת תכונה זו מאפשרת מחיקה מרחוק של נתוני הפלטפורמה. השתמש בזהירות."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "תווית למתג ההפעלה של מחיקת פלטפורמה מרחוק",
+    "value": "הפעל מחיקת פלטפורמה מרחוק במכשיר זה"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "טקסט עזרה מתחת למתג ההפעלה",
+    "value": "נדרש לפני התחלת פעולת מחיקה."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "כותרת לכרטיס פעולת התחלת המחיקה",
+    "value": "התחל מחיקה מרחוק"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "כותרת משנה לכרטיס פעולת התחלת המחיקה",
+    "value": "מחק לצמיתות את כל הנתונים המאוחסנים בפלטפורמה זו"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "אזהרה לפני התחלת מחיקת פלטפורמה מרחוק",
+    "value": "פעולה זו אינה הפיכה. כל נתוני הפלטפורמה יימחקו לצמיתות."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "תווית הכפתור להתחלת מחיקת פלטפורמה מרחוק",
+    "value": "התחל מחיקה מרחוק"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "הודעת הצלחה בעת החלפת מצב תכונת מחיקת פלטפורמה מרחוק",
+    "value": "תכונת מחיקת הפלטפורמה מרחוק עודכנה בהצלחה"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "הודעת שגיאה כאשר עדכון תכונת מחיקת פלטפורמה מרחוק נכשל",
+    "value": "עדכון תכונת מחיקת הפלטפורמה מרחוק נכשל"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "הודעת הצלחה לאחר הפעלת מחיקת פלטפורמה מרחוק",
+    "value": "מחיקת הפלטפורמה מרחוק הופעלה בהצלחה"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "הודעת הצלחה לאחר מחיקת כונן מערכת ההפעלה – מבקשת התקנה מחדש",
+    "value": "כונן מערכת ההפעלה נמחק בהצלחה. אנא התקן מחדש מערכת הפעלה לפני השימוש במכשיר זה."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "הודעת שגיאה כאשר הפעלת מחיקת פלטפורמה מרחוק נכשלת",
+    "value": "הפעלת מחיקת הפלטפורמה מרחוק נכשלה"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "הודעת שגיאה בעת כשל בטעינת סטטוס תכונת מחיקת פלטפורמה מרחוק",
+    "value": "טעינת סטטוס תכונת מחיקת הפלטפורמה מרחוק נכשלה"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "הודעת שגיאה בעת כשל באחזור סטטוס כוח במהלך מחיקת פלטפורמה מרחוק",
+    "value": "שגיאה באחזור סטטוס כוח"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "הודעה המוצגת כאשר מחיקת פלטפורמה מרחוק אינה נתמכת במכשיר",
+    "value": "מחיקת פלטפורמה מרחוק אינה נתמכת"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "כותרת כרטיס יכולות המחיקה",
+    "value": "יכולות מחיקה"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "תת-כותרת כרטיס יכולות המחיקה",
+    "value": "בחר את היכולות לכלול בפעולת המחיקה. לא ניתן לבחור יכולות שאינן נתמכות."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "רמז המוצג כאשר התכונה מופעלת, המבקש מהמשתמש לבחור יכולות למחיקה",
+    "value": "בחר את היכולות שברצונך למחוק, ולאחר מכן לחץ על התחל מחיקה מרחוק."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "תווית יכולת מחיקה מאובטחת של כל ה-SSD",
+    "value": "מחיקה מאובטחת של כל ה-SSD"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "תיאור יכולת מחיקה מאובטחת של כל ה-SSD",
+    "value": "הסרת כל התוכן מכוננות ATA ו-NVM באמצעות שילוב של מחיקת מדיה ומחיקה קריפטוגרפית"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "תווית תיבת הסימון המציינת שכונן ה-SSD דורש מפתח הצפנה של הדיסק",
+    "value": "ה-SSD דורש מפתח הצפנה של הדיסק"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "תווית שדה הזנת סיסמת ההצפנה של כונן ה-SSD",
+    "value": "סיסמת הכונן"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "תווית יכולת ניקוי TPM",
+    "value": "ניקוי TPM"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "תיאור יכולת ניקוי TPM",
+    "value": "מחיקת כל המפתחות שנוצרו הקשורים ל-TPM והנתונים המוגנים על ידם, כגון כרטיס חכם וירטואלי או PIN כניסה"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "תווית יכולת שחזור BIOS למצב EOM",
+    "value": "שחזר BIOS למצב EOM"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "תיאור יכולת שחזור BIOS למצב EOM",
+    "value": "שחזר את ה-BIOS לתצורת הבסיס של סוף הייצור (EOM) שנקבעה על ידי מעצב המערכת"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "תווית יכולת ביטול תצורת קושחת Intel CSME",
+    "value": "בטל את תצורת קושחת Intel CSME"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "טיפ כלי על כפתור המחיקה כאשר לא נבחרו יכולות",
+    "value": "בחר לפחות יכולת מחיקה אחת"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "הודעת תיבת הדו-שיח לאישור לפני תחילת מחיקת הפלטפורמה מרחוק. {{device}} הוא השם הידידותי או שם המארח; {{operations}} היא רשימה מופרדת בפסיקים של פעולות המחיקה שנבחרו.",
+    "value": "למחוק ולהפעיל מחדש את {{device}}? יבוצעו: {{operations}}. לא ניתן לבטל פעולה זו."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "תיאור יכולת ביטול תצורת קושחת Intel CSME",
+    "value": "ביטול מלא של תצורת Intel AMT, חזרה למצב ברירת המחדל והשבתת תכונות Intel AMT"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "הודעת מידע המוצגת כאשר בוחרים בביטול תצורת CSME, ומסבירה מדוע לא ניתן לשלב עם אפשרויות אחרות",
+    "value": "ביטול תצורת CSME מבצע ביטול מלא של תצורת Intel AMT ולא ניתן לשלב אותו עם פעולות מחיקה אחרות."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "הודעת הצלחה לאחר ביטול תצורת CSME – מבקשת הגדרה מחדש ומודיעה שהמכשיר יוסר מהקונסולה",
+    "value": "תצורת CSME בוטלה בהצלחה. אנא הגדר מחדש את CSME. מכשיר זה יוסר מהקונסולה."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "תווית המציגה כמה פעולות מחיקה נבחרו כעת",
+    "value": "נבחרו {{selected}} מתוך 3 פעולות",
+    "_value_old": "נבחרו {{selected}} מתוך {{total}} פעולות"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "תווית המוצגת בשורת יכולת כאשר המכשיר אינו תומך בה",
+    "value": "לא נתמך במכשיר זה"
   }
 }
diff --git a/src/assets/i18n/it.json b/src/assets/i18n/it.json
index 9595e35bb..534c9f0e3 100644
--- a/src/assets/i18n/it.json
+++ b/src/assets/i18n/it.json
@@ -1427,6 +1427,10 @@
     "description": "Etichetta per avvio di rete HTTPS",
     "value": "Avvio di rete HTTPS:"
   },
+  "general.remotePlatformErase": {
+    "description": "Etichetta per la cancellazione remota della piattaforma",
+    "value": "Cancellazione remota della piattaforma:"
+  },
   "general.ideRedirection": {
     "description": "Etichetta per il reindirizzamento IDE",
     "value": "Reindirizzamento IDE:"
@@ -1447,6 +1451,10 @@
     "description": "Tooltip per il ripristino con un clic non supportato",
     "value": "Il ripristino con un clic non è supportato."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Tooltip per Remote Platform Erase non supportato",
+    "value": "Remote Platform Erase non è supportato."
+  },
   "general.pbaBootShort": {
     "description": "Etichetta per l'avvio PBA",
     "value": "Avvio PBA:"
@@ -2401,6 +2409,10 @@
     "description": "Titolo della finestra di dialogo per l'avviso relativo alla password casuale",
     "value": "Utilizzo di password generate in modo casuale"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Messaggio di errore quando la password SSD supera i 32 byte",
+    "value": "La password SSD non deve superare i 32 byte"
+  },
   "sol.connect": {
     "description": "Pulsante per la connessione a SOL",
     "value": "Connettersi a SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Nessun dato disponibile",
     "description": "Messaggio quando non ci sono dati disponibili"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Nome categoria per la cancellazione remota della piattaforma",
+    "value": "Cancellazione remota della piattaforma"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Descrizione per la cancellazione remota della piattaforma",
+    "value": "Cancella in modo sicuro i dati della piattaforma"
+  },
+  "remotePlatformErase.title": {
+    "description": "Titolo della scheda funzione di cancellazione remota della piattaforma",
+    "value": "Cancellazione remota della piattaforma"
+  },
+  "remotePlatformErase.description": {
+    "description": "Sottotitolo della scheda funzione di cancellazione remota della piattaforma",
+    "value": "Attiva da remoto una cancellazione sicura di unità, TPM e BIOS su questo dispositivo. I dati cancellati non possono essere recuperati.",
+    "_value_old": "Attiva da remoto una cancellazione sicura di unità, TPM, BIOS o Intel CSME su questo dispositivo. I dati cancellati non possono essere recuperati."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Messaggio di avviso sull'abilitazione della cancellazione remota della piattaforma",
+    "value": "L'abilitazione di questa funzionalità consente la cancellazione remota dei dati della piattaforma. Usare con cautela."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Etichetta dell'interruttore di abilitazione della cancellazione remota della piattaforma",
+    "value": "Abilita cancellazione remota della piattaforma su questo dispositivo"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Testo di aiuto sotto l'interruttore di abilitazione",
+    "value": "Richiesto prima di avviare qualsiasi operazione di cancellazione."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Titolo della scheda azione per avviare la cancellazione",
+    "value": "Avvia cancellazione remota"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Sottotitolo della scheda azione per avviare la cancellazione",
+    "value": "Cancella definitivamente tutti i dati archiviati su questa piattaforma"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Avviso prima di avviare la cancellazione remota della piattaforma",
+    "value": "Questa azione è irreversibile. Tutti i dati della piattaforma verranno cancellati definitivamente."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Etichetta del pulsante per avviare la cancellazione remota della piattaforma",
+    "value": "Avvia cancellazione remota"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Messaggio di successo quando la funzione di cancellazione remota viene attivata",
+    "value": "Funzionalità di cancellazione remota della piattaforma aggiornata con successo"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Messaggio di errore quando l'aggiornamento della funzione di cancellazione remota fallisce",
+    "value": "Impossibile aggiornare la funzionalità di cancellazione remota della piattaforma"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Messaggio di successo dopo aver avviato la cancellazione remota della piattaforma",
+    "value": "Cancellazione remota della piattaforma avviata con successo"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Messaggio di successo dopo la cancellazione dell'unità OS – invita alla reinstallazione",
+    "value": "Unità OS cancellata con successo. Reinstallare un sistema operativo prima di utilizzare questo dispositivo."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Messaggio di errore quando la cancellazione remota della piattaforma non può essere avviata",
+    "value": "Impossibile avviare la cancellazione remota della piattaforma"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Messaggio di errore durante il caricamento dello stato della funzione di cancellazione remota",
+    "value": "Impossibile caricare lo stato della funzionalità di cancellazione remota della piattaforma"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Messaggio di errore durante il recupero dello stato di alimentazione nella cancellazione remota",
+    "value": "Errore durante il recupero dello stato di alimentazione"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Messaggio mostrato quando la cancellazione remota della piattaforma non è supportata",
+    "value": "La cancellazione remota della piattaforma non è supportata"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Titolo della scheda delle capacità di cancellazione",
+    "value": "Capacità di cancellazione"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Sottotitolo della scheda delle capacità di cancellazione",
+    "value": "Seleziona le capacità da includere nell'operazione di cancellazione. Le capacità non supportate non possono essere selezionate."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Suggerimento mostrato quando la funzionalità è abilitata, che chiede all'utente di selezionare le capacità da cancellare",
+    "value": "Seleziona le funzionalità che vuoi cancellare, quindi fai clic su Avvia cancellazione remota."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Etichetta per la cancellazione sicura di tutti gli SSD",
+    "value": "Cancellazione sicura di tutti gli SSD"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Descrizione per la cancellazione sicura di tutti gli SSD",
+    "value": "Rimozione di tutti i contenuti dalle unità ATA e NVM tramite una combinazione di cancellazione dei supporti e cancellazione crittografica"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Etichetta per la casella di controllo che indica che l'unità SSD richiede una chiave di cifratura del disco",
+    "value": "L'SSD richiede una chiave di cifratura del disco"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Etichetta per il campo di immissione della password di cifratura dell'unità SSD",
+    "value": "Password unità"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Etichetta per la cancellazione TPM",
+    "value": "Cancellazione TPM"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Descrizione per la cancellazione TPM",
+    "value": "Eliminazione di tutte le chiavi create associate al TPM e dei dati protetti da esse, come una smart card virtuale o un PIN di accesso"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Etichetta per il ripristino del BIOS allo stato EOM",
+    "value": "Ripristina BIOS allo stato EOM"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Descrizione per il ripristino del BIOS allo stato EOM",
+    "value": "Ripristina il BIOS alla configurazione golden di End of Manufacture (EOM) specificata dal progettista del sistema"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Etichetta per la deconfigurazione del firmware Intel CSME",
+    "value": "Deconfigura il firmware Intel CSME"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Suggerimento sul pulsante di cancellazione quando non sono selezionate funzionalità",
+    "value": "Seleziona almeno una funzionalità di cancellazione"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Messaggio della finestra di dialogo di conferma prima di avviare la cancellazione remota della piattaforma. {{device}} è il nome descrittivo o il nome host; {{operations}} è un elenco separato da virgole delle operazioni di cancellazione selezionate.",
+    "value": "Cancellare e riavviare {{device}}? Verrà eseguito: {{operations}}. Questa azione è irreversibile."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Descrizione per la deconfigurazione del firmware Intel CSME",
+    "value": "Deprovisioning completo di Intel AMT, ritorno allo stato predefinito e disabilitazione delle funzionalità Intel AMT"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Messaggio informativo mostrato quando è selezionato Deconfigura CSME, spiegando che non può essere combinato con altre opzioni",
+    "value": "La deconfigurazione CSME esegue un deprovisioning completo di Intel AMT e non può essere combinata con altre operazioni di cancellazione."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Messaggio di successo dopo la deconfigurazione CSME – invita alla riconfigurazione e informa che il dispositivo verrà rimosso dalla console",
+    "value": "CSME deconfigurato con successo. Riconfigurare CSME. Questo dispositivo verrà rimosso dalla console."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Didascalia che indica quante operazioni di cancellazione sono attualmente selezionate",
+    "value": "{{selected}} di 3 operazioni selezionate",
+    "_value_old": "{{selected}} di {{total}} operazioni selezionate"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Didascalia mostrata su una riga di capacità quando il dispositivo non la supporta",
+    "value": "Non supportato su questo dispositivo"
   }
 }
diff --git a/src/assets/i18n/ja.json b/src/assets/i18n/ja.json
index f30c0fa43..19385b6b8 100644
--- a/src/assets/i18n/ja.json
+++ b/src/assets/i18n/ja.json
@@ -1427,6 +1427,10 @@
     "description": "HTTPS ネットワークブートのラベル",
     "value": "HTTPS ネットワークブート:"
   },
+  "general.remotePlatformErase": {
+    "description": "リモートプラットフォーム消去のラベル",
+    "value": "リモートプラットフォーム消去:"
+  },
   "general.ideRedirection": {
     "description": "IDEリダイレクト用ラベル",
     "value": "IDE リダイレクト："
@@ -1447,6 +1451,10 @@
     "description": "ワンクリック復元機能のツールチップはサポートされていません",
     "value": "ワンクリック復元はサポートされていません"
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "リモートプラットフォーム消去のツールチップはサポートされていません",
+    "value": "リモートプラットフォーム消去はサポートされていません"
+  },
   "general.pbaBootShort": {
     "description": "PBAブート用ラベル",
     "value": "PBA ブート:"
@@ -2401,6 +2409,10 @@
     "description": "ランダムパスワード警告ダイアログのタイトル",
     "value": "ランダム生成パスワードの使用について"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "SSDパスワードが32バイトを超える場合のエラーメッセージ",
+    "value": "SSDパスワードは32バイトを超えることはできません"
+  },
   "sol.connect": {
     "description": "SOL接続用ボタン",
     "value": "Connect SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "利用可能なデータがありません",
     "description": "データが利用できない場合のメッセージ"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "リモートプラットフォーム消去のカテゴリ名",
+    "value": "リモートプラットフォーム消去"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "リモートプラットフォーム消去の説明",
+    "value": "プラットフォームデータを安全に消去する"
+  },
+  "remotePlatformErase.title": {
+    "description": "リモートプラットフォーム消去機能カードのタイトル",
+    "value": "リモートプラットフォーム消去"
+  },
+  "remotePlatformErase.description": {
+    "description": "リモートプラットフォーム消去機能カードのサブタイトル",
+    "value": "このデバイスのドライブ、TPM、BIOS のリモートによる安全な消去を実行します。消去されたデータは復元できません。",
+    "_value_old": "このデバイスのドライブ、TPM、BIOS、または Intel CSME のリモートによる安全な消去を実行します。消去されたデータは復元できません。"
+  },
+  "remotePlatformErase.warning": {
+    "description": "リモートプラットフォーム消去の有効化に関する警告メッセージ",
+    "value": "この機能を有効にすると、プラットフォームデータをリモートで消去できます。慎重に使用してください。"
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "リモートプラットフォーム消去の有効化スイッチのラベル",
+    "value": "このデバイスでリモートプラットフォーム消去を有効にする"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "有効化スイッチ下のヘルプテキスト",
+    "value": "消去操作を開始する前に必要です。"
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "消去開始アクションカードのタイトル",
+    "value": "リモート消去の開始"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "消去開始アクションカードのサブタイトル",
+    "value": "このプラットフォームに保存されているすべてのデータを完全に消去する"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "リモートプラットフォーム消去を開始する前の警告",
+    "value": "この操作は元に戻せません。すべてのプラットフォームデータが完全に消去されます。"
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "リモートプラットフォーム消去を開始するボタンのラベル",
+    "value": "リモート消去を開始"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "リモートプラットフォーム消去機能の切り替え成功メッセージ",
+    "value": "リモートプラットフォーム消去機能を正常に更新しました"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "リモートプラットフォーム消去機能の更新失敗エラーメッセージ",
+    "value": "リモートプラットフォーム消去機能の更新に失敗しました"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "リモートプラットフォーム消去開始後の成功メッセージ",
+    "value": "リモートプラットフォーム消去が正常に開始されました"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "OSドライブ消去後の成功メッセージ – 再インストールを促す",
+    "value": "OSドライブが正常に消去されました。このデバイスを使用する前にOSを再インストールしてください。"
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "リモートプラットフォーム消去の開始失敗エラーメッセージ",
+    "value": "リモートプラットフォーム消去の開始に失敗しました"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "リモートプラットフォーム消去機能の状態読み込み失敗エラーメッセージ",
+    "value": "リモートプラットフォーム消去機能のステータスの読み込みに失敗しました"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "リモート消去中の電源状態取得失敗エラーメッセージ",
+    "value": "電源状態の取得に失敗しました"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "デバイスでリモートプラットフォーム消去がサポートされていない場合のメッセージ",
+    "value": "リモートプラットフォーム消去はサポートされていません"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "消去機能カードのタイトル",
+    "value": "消去機能"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "消去機能カードのサブタイトル",
+    "value": "消去操作に含める機能を選択してください。サポートされていない機能は選択できません。"
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "機能が有効な場合に表示されるヒント。消去する機能を選択するようユーザーに促す",
+    "value": "消去する機能を選択し、リモート消去を開始をクリックしてください。"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "全SSDのセキュア消去のラベル",
+    "value": "全SSDのセキュア消去"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "全SSDのセキュア消去の説明",
+    "value": "メディア消去と暗号消去の組み合わせにより、ATAおよびNVMドライブからすべてのコンテンツを削除します"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "SSDドライブにディスク暗号化キーが必要であることを示すチェックボックスのラベル",
+    "value": "SSDにはディスク暗号化キーが必要です"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "SSDドライブの暗号化パスワード入力フィールドのラベル",
+    "value": "ドライブパスワード"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "TPMクリアのラベル",
+    "value": "TPMクリア"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "TPMクリアの説明",
+    "value": "TPMに関連するすべての作成済みキーと、仮想スマートカードやログインPINなど、それらで保護されたデータを削除します"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "BIOSをEOM状態に復元するラベル",
+    "value": "BIOSをEOM状態に復元"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "BIOSをEOM状態に復元する説明",
+    "value": "BIOSをシステム設計者が指定したEnd of Manufacture（EOM）のゴールデン構成に復元します"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Intel CSMEファームウェアの設定解除のラベル",
+    "value": "Intel CSMEファームウェアの設定解除"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "機能が選択されていない場合の消去開始ボタンのツールチップ",
+    "value": "少なくとも1つの消去機能を選択してください"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "リモートプラットフォーム消去を開始する前の確認ダイアログメッセージ。{{device}} はフレンドリー名またはホスト名、{{operations}} は選択された消去操作のカンマ区切りリスト。",
+    "value": "{{device}} を消去して再起動しますか？ 実行内容: {{operations}}。この操作は元に戻せません。"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Intel CSMEファームウェアの設定解除の説明",
+    "value": "Intel AMTの完全なプロビジョニング解除、デフォルト状態への復帰、およびIntel AMT機能の無効化"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "CSMEの設定解除が選択されたときに表示される情報メッセージ（他のオプションと組み合わせられない理由を説明）",
+    "value": "CSMEの設定解除はIntel AMTの完全なプロビジョニング解除を実行し、他の消去操作と組み合わせることはできません。"
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "CSMEの設定解除後の成功メッセージ – 再設定を促し、デバイスがコンソールから削除されることを通知",
+    "value": "CSMEの設定が正常に解除されました。CSMEを再設定してください。このデバイスはコンソールから削除されます。"
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "現在選択されている消去操作の数を示すキャプション",
+    "value": "3 件中 {{selected}} 件の操作が選択されています",
+    "_value_old": "{{total}} 件中 {{selected}} 件の操作が選択されています"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "デバイスが対応していない機能の行に表示されるキャプション",
+    "value": "このデバイスでサポートされていません"
   }
 }
diff --git a/src/assets/i18n/nl.json b/src/assets/i18n/nl.json
index b3b0b8a37..691ad0377 100644
--- a/src/assets/i18n/nl.json
+++ b/src/assets/i18n/nl.json
@@ -1427,6 +1427,10 @@
     "description": "Label voor HTTPS Netwerkboot",
     "value": "HTTPS Netwerkboot:"
   },
+  "general.remotePlatformErase": {
+    "description": "Label voor extern wissen van het platform",
+    "value": "Extern platform wissen:"
+  },
   "general.ideRedirection": {
     "description": "Label voor IDE-omleiding",
     "value": "IDE-omleiding:"
@@ -1447,6 +1451,10 @@
     "description": "Tooltip voor herstel met één klik wordt niet ondersteund.",
     "value": "One Click Recovery wordt niet ondersteund."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Tooltip voor Remote Platform Erase wordt niet ondersteund.",
+    "value": "Remote Platform Erase wordt niet ondersteund."
+  },
   "general.pbaBootShort": {
     "description": "Label voor PBA-opstart",
     "value": "PBA-boot:"
@@ -2401,6 +2409,10 @@
     "description": "Dialoogvenster voor waarschuwing over willekeurig wachtwoord",
     "value": "Gebruik van willekeurig gegenereerde wachtwoorden"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Foutbericht wanneer SSD-wachtwoord meer dan 32 bytes is",
+    "value": "SSD-wachtwoord mag niet meer dan 32 bytes zijn"
+  },
   "sol.connect": {
     "description": "Knop voor verbinding met SOL",
     "value": "Connect SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Geen gegevens beschikbaar",
     "description": "Bericht wanneer er geen gegevens beschikbaar zijn"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Categorienaam voor extern wissen van het platform",
+    "value": "Extern platform wissen"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Beschrijving voor extern wissen van het platform",
+    "value": "Platformgegevens veilig wissen"
+  },
+  "remotePlatformErase.title": {
+    "description": "Titel van de functiekaart voor extern wissen van het platform",
+    "value": "Extern platform wissen"
+  },
+  "remotePlatformErase.description": {
+    "description": "Ondertitel van de functiekaart voor extern wissen van het platform",
+    "value": "Start op afstand een veilige wissing van schijven, TPM en BIOS op dit apparaat. Gewiste gegevens kunnen niet worden hersteld.",
+    "_value_old": "Start op afstand een veilige wissing van schijven, TPM, BIOS of Intel CSME op dit apparaat. Gewiste gegevens kunnen niet worden hersteld."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Waarschuwingsbericht over het inschakelen van extern wissen van het platform",
+    "value": "Als u deze functie inschakelt, kunnen platformgegevens op afstand worden gewist. Gebruik met voorzichtigheid."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Label van de schakelaar voor extern wissen van het platform",
+    "value": "Extern wissen van het platform op dit apparaat inschakelen"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Helptekst onder de inschakelschakelaar",
+    "value": "Vereist voordat een wisbewerking kan worden gestart."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Titel van de actiekaart voor het starten van wissen",
+    "value": "Extern wissen starten"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Ondertitel van de actiekaart voor het starten van wissen",
+    "value": "Alle gegevens op dit platform permanent wissen"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Waarschuwing voor het starten van extern wissen van het platform",
+    "value": "Deze actie is onomkeerbaar. Alle platformgegevens worden permanent gewist."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Knoplaabel voor het starten van extern wissen van het platform",
+    "value": "Extern wissen starten"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Succesbericht bij het in- of uitschakelen van extern wissen van het platform",
+    "value": "Functie voor extern wissen van het platform succesvol bijgewerkt"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Foutbericht wanneer bijwerken van extern wissen van het platform mislukt",
+    "value": "Bijwerken van de functie voor extern wissen van het platform mislukt"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Succesbericht na het starten van extern wissen van het platform",
+    "value": "Extern wissen van het platform succesvol gestart"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Succesbericht na het wissen van de OS-schijf – vraagt om herinstallatie",
+    "value": "OS-schijf succesvol gewist. Installeer een besturingssysteem opnieuw voordat u dit apparaat gebruikt."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Foutbericht wanneer extern wissen van het platform niet kan worden gestart",
+    "value": "Starten van extern wissen van het platform mislukt"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Foutbericht bij het laden van de status van extern wissen van het platform",
+    "value": "Laden van de status van de functie voor extern wissen van het platform mislukt"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Foutbericht bij het ophalen van de stroomstatus tijdens extern wissen",
+    "value": "Fout bij het ophalen van de stroomstatus"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Bericht dat wordt weergegeven wanneer extern wissen van het platform niet wordt ondersteund",
+    "value": "Extern wissen van het platform wordt niet ondersteund"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Titel van de kaart met wissmogelijkheden",
+    "value": "Wissmogelijkheden"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Ondertitel van de kaart met wissmogelijkheden",
+    "value": "Selecteer welke mogelijkheden u wilt opnemen in de wisbewerking. Niet-ondersteunde mogelijkheden kunnen niet worden geselecteerd."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Hint die wordt weergegeven wanneer de functie is ingeschakeld en de gebruiker vraagt mogelijkheden te selecteren om te wissen",
+    "value": "Selecteer de mogelijkheden die u wilt wissen en klik vervolgens op Extern wissen starten."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Label voor veilig wissen van alle SSD's",
+    "value": "Veilig wissen van alle SSD's"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Beschrijving voor veilig wissen van alle SSD's",
+    "value": "Verwijdering van alle inhoud van ATA- en NVM-schijven door een combinatie van mediawissen en cryptografisch wissen"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Label voor het selectievakje dat aangeeft dat de SSD-schijf een schijfcoderingssleutel vereist",
+    "value": "SSD vereist schijfcoderingssleutel"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Label voor het invoerveld voor het coderingswachtwoord van de SSD-schijf",
+    "value": "Schijfwachtwoord"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Label voor TPM wissen",
+    "value": "TPM wissen"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Beschrijving voor TPM wissen",
+    "value": "Alle gemaakte sleutels die zijn gekoppeld aan de TPM en door die sleutels beschermde gegevens verwijderen, zoals een virtuele smartcard of een inlog-PIN"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Label voor BIOS herstellen naar EOM-status",
+    "value": "BIOS herstellen naar EOM-status"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Beschrijving voor BIOS herstellen naar EOM-status",
+    "value": "Herstel het BIOS naar de gouden configuratie voor End of Manufacture (EOM) zoals opgegeven door de systeemontwerper"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Label voor Intel CSME-firmware deconfigureren",
+    "value": "Intel CSME-firmware deconfigureren"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Tooltip op de verwijderknop wanneer er geen mogelijkheden zijn geselecteerd",
+    "value": "Selecteer ten minste één verwijdermogelijkheid"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Bevestigingsdialoogbericht voordat extern platform wissen wordt gestart. {{device}} is de vriendelijke naam of hostnaam; {{operations}} is een komma-gescheiden lijst van geselecteerde wisbewerkingen.",
+    "value": "{{device}} wissen en opnieuw opstarten? Dit voert uit: {{operations}}. Deze actie is onomkeerbaar."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Beschrijving voor Intel CSME-firmware deconfigureren",
+    "value": "Volledige deprovisioning van Intel AMT, terugkeer naar de standaardstatus en uitschakeling van Intel AMT-functies"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Informatiebericht getoond wanneer CSME deconfigureren is geselecteerd, legt uit dat het niet kan worden gecombineerd met andere opties",
+    "value": "CSME-deconfiguratie voert een volledige deprovisioning van Intel AMT uit en kan niet worden gecombineerd met andere wisbewerkingen."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Succesbericht na CSME-deconfiguratie – vraagt om herconfiguratie en meldt dat het apparaat uit de console wordt verwijderd",
+    "value": "CSME succesvol gedeconfigureerd. Configureer CSME opnieuw. Dit apparaat wordt verwijderd uit de console."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Bijschrift dat aangeeft hoeveel wisbewerkingen momenteel zijn geselecteerd",
+    "value": "{{selected}} van 3 bewerkingen geselecteerd",
+    "_value_old": "{{selected}} van {{total}} bewerkingen geselecteerd"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Bijschrift dat wordt weergegeven op een capaciteitsrij wanneer het apparaat deze niet ondersteunt",
+    "value": "Niet ondersteund op dit apparaat"
   }
 }
diff --git a/src/assets/i18n/ru.json b/src/assets/i18n/ru.json
index a8b0266dd..ea3ee2b55 100644
--- a/src/assets/i18n/ru.json
+++ b/src/assets/i18n/ru.json
@@ -1427,6 +1427,10 @@
     "description": "Метка для HTTPS Сетевая загрузка",
     "value": "HTTPS Сетевая загрузка:"
   },
+  "general.remotePlatformErase": {
+    "description": "Метка для удалённого стирания платформы",
+    "value": "Удалённое стирание платформы:"
+  },
   "general.ideRedirection": {
     "description": "Метка для перенаправления IDE",
     "value": "Перенаправление IDE:"
@@ -1447,6 +1451,10 @@
     "description": "Всплывающая подсказка для функции «Восстановление в один клик» не поддерживается.",
     "value": "Восстановление одним щелчком мыши не поддерживается."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Всплывающая подсказка для удалённого стирания платформы не поддерживается.",
+    "value": "Удалённое стирание платформы не поддерживается."
+  },
   "general.pbaBootShort": {
     "description": "Метка для загрузки PBA",
     "value": "Загрузка PBA:"
@@ -2401,6 +2409,10 @@
     "description": "Заголовок диалогового окна для предупреждения о случайном пароле",
     "value": "Использование случайно сгенерированных паролей"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Сообщение об ошибке когда пароль SSD превышает 32 байта",
+    "value": "Пароль SSD не должен превышать 32 байта"
+  },
   "sol.connect": {
     "description": "Кнопка для подключения к SOL",
     "value": "Подключите SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Нет доступных данных",
     "description": "Сообщение при отсутствии данных"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Имя категории для удалённого стирания платформы",
+    "value": "Удалённое стирание платформы"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Описание удалённого стирания платформы",
+    "value": "Безопасное стирание данных платформы"
+  },
+  "remotePlatformErase.title": {
+    "description": "Заголовок карточки функции удалённого стирания платформы",
+    "value": "Удалённое стирание платформы"
+  },
+  "remotePlatformErase.description": {
+    "description": "Подзаголовок карточки функции удалённого стирания платформы",
+    "value": "Удалённый запуск безопасного стирания данных с дисков, TPM и BIOS на этом устройстве. Стёртые данные невозможно восстановить.",
+    "_value_old": "Удалённый запуск безопасного стирания данных с дисков, TPM, BIOS или Intel CSME на этом устройстве. Стёртые данные невозможно восстановить."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Предупреждение о включении удалённого стирания платформы",
+    "value": "Включение этой функции позволяет удалённо стирать данные платформы. Используйте с осторожностью."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Метка переключателя для включения удалённого стирания платформы",
+    "value": "Включить удалённое стирание платформы на этом устройстве"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Пояснительный текст под переключателем включения",
+    "value": "Требуется перед началом любой операции стирания."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Заголовок карточки действия запуска стирания",
+    "value": "Запустить удалённое стирание"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Подзаголовок карточки действия запуска стирания",
+    "value": "Безвозвратно удалить все данные, хранящиеся на этой платформе"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Предупреждение перед запуском удалённого стирания платформы",
+    "value": "Это действие необратимо. Все данные платформы будут безвозвратно удалены."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Подпись кнопки для запуска удалённого стирания платформы",
+    "value": "Запустить удалённое стирание"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Сообщение об успехе при переключении функции удалённого стирания платформы",
+    "value": "Функция удалённого стирания платформы успешно обновлена"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Сообщение об ошибке при неудачном обновлении функции удалённого стирания платформы",
+    "value": "Не удалось обновить функцию удалённого стирания платформы"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Сообщение об успехе после запуска удалённого стирания платформы",
+    "value": "Удалённое стирание платформы успешно запущено"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Сообщение об успехе после стирания диска ОС — предлагает переустановить ОС",
+    "value": "Диск ОС успешно стёрт. Пожалуйста, переустановите операционную систему перед использованием этого устройства."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Сообщение об ошибке при невозможности запустить удалённое стирание платформы",
+    "value": "Не удалось запустить удалённое стирание платформы"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Сообщение об ошибке при загрузке статуса функции удалённого стирания платформы",
+    "value": "Не удалось загрузить статус функции удалённого стирания платформы"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Сообщение об ошибке при получении статуса питания во время удалённого стирания",
+    "value": "Ошибка при получении информации о состоянии питания"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Сообщение, отображаемое когда удалённое стирание платформы не поддерживается устройством",
+    "value": "Удалённое стирание платформы не поддерживается"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Заголовок карточки возможностей стирания",
+    "value": "Возможности стирания"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Подзаголовок карточки возможностей стирания",
+    "value": "Выберите возможности для включения в операцию стирания. Неподдерживаемые возможности недоступны для выбора."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Подсказка, отображаемая при включённой функции и предлагающая пользователю выбрать возможности для стирания",
+    "value": "Выберите функции, которые хотите стереть, затем нажмите Запустить удалённое стирание."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Метка для безопасного стирания всех SSD",
+    "value": "Безопасное стирание всех SSD"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Описание для безопасного стирания всех SSD",
+    "value": "Удаление всего содержимого с накопителей ATA и NVM с помощью комбинации стирания носителя и криптографического стирания"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Метка флажка, указывающего, что SSD-накопитель требует ключ шифрования диска",
+    "value": "SSD требует ключ шифрования диска"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Метка поля ввода пароля шифрования SSD-накопителя",
+    "value": "Пароль диска"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Метка для очистки TPM",
+    "value": "Очистка TPM"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Описание для очистки TPM",
+    "value": "Удаление всех созданных ключей, связанных с TPM, и данных, защищённых этими ключами, например виртуальной смарт-карты или PIN-кода входа"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Метка для восстановления BIOS до состояния EOM",
+    "value": "Восстановить BIOS до состояния EOM"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Описание для восстановления BIOS до состояния EOM",
+    "value": "Восстановление BIOS до базовой конфигурации End of Manufacture (EOM), заданной разработчиком системы"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Метка для отмены настройки прошивки Intel CSME",
+    "value": "Отменить настройку прошивки Intel CSME"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Подсказка на кнопке запуска очистки, когда не выбрано ни одной возможности",
+    "value": "Выберите хотя бы одну возможность очистки"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Сообщение диалога подтверждения перед запуском удалённого стирания платформы. {{device}} — дружественное имя или имя хоста; {{operations}} — список выбранных операций стирания через запятую.",
+    "value": "Стереть и перезапустить {{device}}? Будет выполнено: {{operations}}. Это действие необратимо."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Описание для отмены настройки прошивки Intel CSME",
+    "value": "Полное отключение Intel AMT, возврат к состоянию по умолчанию и отключение функций Intel AMT"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Информационное сообщение при выборе отмены настройки CSME, объясняющее, что её нельзя объединить с другими параметрами",
+    "value": "Отмена настройки CSME выполняет полное отключение Intel AMT и не может быть объединена с другими операциями стирания."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Сообщение об успехе после отмены настройки CSME – предлагает перенастроить CSME и сообщает, что устройство будет удалено из консоли",
+    "value": "Настройка CSME успешно отменена. Пожалуйста, перенастройте CSME. Это устройство будет удалено из консоли."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Подпись, показывающая, сколько операций стирания выбрано в данный момент",
+    "value": "Выбрано операций: {{selected}} из 3",
+    "_value_old": "Выбрано операций: {{selected}} из {{total}}"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Подпись в строке возможности, когда устройство её не поддерживает",
+    "value": "Не поддерживается на этом устройстве"
   }
 }
diff --git a/src/assets/i18n/sv.json b/src/assets/i18n/sv.json
index 4764efa8b..77589b051 100644
--- a/src/assets/i18n/sv.json
+++ b/src/assets/i18n/sv.json
@@ -1427,6 +1427,10 @@
     "description": "Etikett för HTTPS Nätverksstart",
     "value": "HTTPS Nätverksstart:"
   },
+  "general.remotePlatformErase": {
+    "description": "Etikett för fjärrradering av plattform",
+    "value": "Fjärrradering av plattform:"
+  },
   "general.ideRedirection": {
     "description": "Etikett för IDE-omdirigering",
     "value": "IDE-omdirigering:"
@@ -1447,6 +1451,10 @@
     "description": "Verktygstips för återställning med ett klick stöds inte",
     "value": "Återställning med ett klick stöds inte."
   },
+  "general.remotePlatformEraseNotSupported": {
+    "description": "Verktygstips för Remote Platform Erase stöds inte",
+    "value": "Remote Platform Erase stöds inte."
+  },
   "general.pbaBootShort": {
     "description": "Etikett för PBA-start",
     "value": "PBA-start:"
@@ -2401,6 +2409,10 @@
     "description": "Dialogrubrik för varning om slumpmässigt lösenord",
     "value": "Använda slumpmässigt genererade lösenord"
   },
+  "remotePlatformErase.ssdPasswordTooLong": {
+    "description": "Felmeddelande när SSD-lösenordet överskrider 32 bytes",
+    "value": "SSD-lösenordet får inte överskrida 32 bytes"
+  },
   "sol.connect": {
     "description": "Knapp för anslutning till SOL",
     "value": "Anslut SOL"
@@ -2828,5 +2840,159 @@
   "common.noData": {
     "value": "Ingen data tillgänglig",
     "description": "Meddelande när ingen data är tillgänglig"
+  },
+  "deviceDetail.remotePlatformErase": {
+    "description": "Kategorinamn för fjärrradering av plattform",
+    "value": "Fjärrradering av plattform"
+  },
+  "deviceDetail.remotePlatformEraseDescription": {
+    "description": "Beskrivning för fjärrradering av plattform",
+    "value": "Radera plattformsdata på ett säkert sätt"
+  },
+  "remotePlatformErase.title": {
+    "description": "Titel på funktionskortet för fjärrradering av plattform",
+    "value": "Fjärrradering av plattform"
+  },
+  "remotePlatformErase.description": {
+    "description": "Underrubrik på funktionskortet för fjärrradering av plattform",
+    "value": "Utför en säker fjärrradering av diskar, TPM och BIOS på den här enheten. Raderade data kan inte återställas.",
+    "_value_old": "Utför en säker fjärrradering av diskar, TPM, BIOS eller Intel CSME på den här enheten. Raderade data kan inte återställas."
+  },
+  "remotePlatformErase.warning": {
+    "description": "Varningsmeddelande om aktivering av fjärrradering av plattform",
+    "value": "Att aktivera den här funktionen tillåter fjärrradering av plattformsdata. Använd med försiktighet."
+  },
+  "remotePlatformErase.featureEnabled": {
+    "description": "Etikett för växlingsknappen för att aktivera fjärrradering av plattform",
+    "value": "Aktivera fjärrradering av plattform på den här enheten"
+  },
+  "remotePlatformErase.featureEnabledHint": {
+    "description": "Hjälptext under aktiveringsknappen",
+    "value": "Krävs innan någon raderingsåtgärd kan startas."
+  },
+  "remotePlatformErase.initiateTitle": {
+    "description": "Titel på åtgärdskortet för att starta radering",
+    "value": "Starta fjärrradering"
+  },
+  "remotePlatformErase.initiateDescription": {
+    "description": "Underrubrik på åtgärdskortet för att starta radering",
+    "value": "Radera permanent alla data som lagras på den här plattformen"
+  },
+  "remotePlatformErase.initiateWarning": {
+    "description": "Varning innan fjärrradering av plattform påbörjas",
+    "value": "Den här åtgärden är oåterkallelig. All plattformsdata kommer att raderas permanent."
+  },
+  "remotePlatformErase.initiateButton": {
+    "description": "Knappetikett för att starta fjärrradering av plattform",
+    "value": "Starta fjärrradering"
+  },
+  "remotePlatformErase.updateSuccess": {
+    "description": "Framgångsmeddelande när funktionen för fjärrradering växlas",
+    "value": "Fjärrraderingsfunktionen för plattformen har uppdaterats"
+  },
+  "remotePlatformErase.updateError": {
+    "description": "Felmeddelande när uppdatering av fjärrradering av plattform misslyckas",
+    "value": "Det gick inte att uppdatera fjärrraderingsfunktionen för plattformen"
+  },
+  "remotePlatformErase.eraseSuccess": {
+    "description": "Framgångsmeddelande efter att fjärrradering av plattform initierats",
+    "value": "Fjärrradering av plattform har startats"
+  },
+  "remotePlatformErase.osEraseSuccess": {
+    "description": "Framgångsmeddelande efter radering av OS-enhet – uppmanar till ominstallation",
+    "value": "OS-enheten har raderats. Installera om ett operativsystem innan du använder den här enheten."
+  },
+  "remotePlatformErase.eraseError": {
+    "description": "Felmeddelande när fjärrradering av plattform inte kan initieras",
+    "value": "Det gick inte att starta fjärrraderingen av plattformen"
+  },
+  "remotePlatformErase.errorLoad": {
+    "description": "Felmeddelande vid fel vid inläsning av status för fjärrradering av plattform",
+    "value": "Det gick inte att läsa in statusen för fjärrraderingsfunktionen för plattformen"
+  },
+  "remotePlatformErase.errorRetrievingPower": {
+    "description": "Felmeddelande vid hämtning av strömstatus under fjärrradering",
+    "value": "Fel vid hämtning av strömstatus"
+  },
+  "remotePlatformErase.notSupported": {
+    "description": "Meddelande som visas när fjärrradering av plattform inte stöds på enheten",
+    "value": "Fjärrradering av plattform stöds inte"
+  },
+  "remotePlatformErase.caps.title": {
+    "description": "Titel på kortet med raderingsmöjligheter",
+    "value": "Raderingsmöjligheter"
+  },
+  "remotePlatformErase.caps.description": {
+    "description": "Undertitel på kortet med raderingsmöjligheter",
+    "value": "Välj vilka funktioner som ska ingå i raderingsoperationen. Funktioner som inte stöds kan inte väljas."
+  },
+  "remotePlatformErase.caps.selectHint": {
+    "description": "Tips som visas när funktionen är aktiverad och uppmanar användaren att välja funktioner att radera",
+    "value": "Välj de funktioner du vill radera och klicka sedan på Starta fjärrradering."
+  },
+  "remotePlatformErase.cap.secureEraseSsds.label": {
+    "description": "Etikett för säker radering av alla SSD:er",
+    "value": "Säker radering av alla SSD:er"
+  },
+  "remotePlatformErase.cap.secureEraseSsds.desc": {
+    "description": "Beskrivning för säker radering av alla SSD:er",
+    "value": "Borttagning av allt innehåll från ATA- och NVM-enheter genom en kombination av medieradering och kryptografisk radering"
+  },
+  "remotePlatformErase.ssdEncrypted.label": {
+    "description": "Etikett för kryssrutan som anger att SSD-enheten kräver en diskkrypteringsnyckel",
+    "value": "SSD kräver diskkrypteringsnyckel"
+  },
+  "remotePlatformErase.ssdPassword.label": {
+    "description": "Etikett för inmatningsfältet för SSD-enhetens krypteringslösenord",
+    "value": "Enhetslösenord"
+  },
+  "remotePlatformErase.cap.tpmClear.label": {
+    "description": "Etikett för TPM-rensning",
+    "value": "TPM-rensning"
+  },
+  "remotePlatformErase.cap.tpmClear.desc": {
+    "description": "Beskrivning för TPM-rensning",
+    "value": "Ta bort alla skapade nycklar kopplade till TPM och data som skyddas av dessa nycklar, såsom ett virtuellt smartkort eller en inloggnings-PIN"
+  },
+  "remotePlatformErase.cap.biosRestore.label": {
+    "description": "Etikett för återställning av BIOS till EOM-tillstånd",
+    "value": "Återställ BIOS till EOM-tillstånd"
+  },
+  "remotePlatformErase.cap.biosRestore.desc": {
+    "description": "Beskrivning för återställning av BIOS till EOM-tillstånd",
+    "value": "Återställ BIOS till den av systemdesignern specificerade EOM-guldkonfigurationen (End of Manufacture)"
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.label": {
+    "description": "Etikett för avkonfigurering av Intel CSME-firmware",
+    "value": "Avkonfigurera Intel CSME-firmware"
+  },
+  "remotePlatformErase.initiateNoCapsTooltip": {
+    "description": "Verktygstips på raderingsknappen när inga funktioner är valda",
+    "value": "Välj minst en raderingsfunktion"
+  },
+  "remotePlatformErase.confirmMessage": {
+    "description": "Meddelande i bekräftelsedialogen innan fjärrradering av plattform initieras. {{device}} är det vänliga namnet eller värdnamnet; {{operations}} är en kommaseparerad lista över valda raderingsåtgärder.",
+    "value": "Radera och starta om {{device}}? Följande kommer att utföras: {{operations}}. Den här åtgärden kan inte ångras."
+  },
+  "remotePlatformErase.cap.csmeUnconfigure.desc": {
+    "description": "Beskrivning för avkonfigurering av Intel CSME-firmware",
+    "value": "Fullständig avetablering av Intel AMT, återgång till standardtillståndet och inaktivering av Intel AMT-funktioner"
+  },
+  "remotePlatformErase.csmeUnconfigureExclusive": {
+    "description": "Informationsmeddelande som visas när Avkonfigurering av CSME är valt, förklarar att det inte kan kombineras med andra alternativ",
+    "value": "Avkonfigurering av CSME utför en fullständig avetablering av Intel AMT och kan inte kombineras med andra raderingsåtgärder."
+  },
+  "remotePlatformErase.csmeEraseSuccess": {
+    "description": "Framgångsmeddelande efter CSME-avkonfigurering – uppmanar till omkonfigurering och informerar om att enheten tas bort från konsolen",
+    "value": "CSME avkonfigurerades. Konfigurera om CSME. Den här enheten tas bort från konsolen."
+  },
+  "remotePlatformErase.selectionCount": {
+    "description": "Bildtext som visar hur många raderingsåtgärder som för närvarande är valda",
+    "value": "{{selected}} av 3 åtgärder valda",
+    "_value_old": "{{selected}} av {{total}} åtgärder valda"
+  },
+  "remotePlatformErase.capUnsupported": {
+    "description": "Bildtext som visas på en funktionsrad när enheten inte stöder den",
+    "value": "Stöds inte på den här enheten"
   }
 }
diff --git a/src/assets/kJEhBvYX7BgnkSrUwT8OhrdQw4oELdPIeeII9v6oFsI.woff2 b/src/assets/kJEhBvYX7BgnkSrUwT8OhrdQw4oELdPIeeII9v6oFsI.woff2
index fdc1aae88..4db7e7ee0 100644
Binary files a/src/assets/kJEhBvYX7BgnkSrUwT8OhrdQw4oELdPIeeII9v6oFsI.woff2 and b/src/assets/kJEhBvYX7BgnkSrUwT8OhrdQw4oELdPIeeII9v6oFsI.woff2 differ
diff --git a/src/models/models.ts b/src/models/models.ts
index 407385a71..dad5ee162 100644
--- a/src/models/models.ts
+++ b/src/models/models.ts
@@ -137,7 +137,8 @@ export interface AMTFeaturesResponse {
   httpsBootSupported: boolean
   winREBootSupported: boolean
   localPBABootSupported: boolean
-  remoteErase: boolean
+  rpe: boolean
+  rpeSupported: boolean
   pbaBootFilesPath: BootParams[]
   winREBootFilesPath: BootParams
 }
@@ -147,7 +148,18 @@ export interface AMTFeaturesRequest {
   enableSOL: boolean
   enableIDER: boolean
   ocr: boolean
-  remoteErase: boolean
+  rpe: boolean
+}
+
+export interface BootCapabilities {
+  secureEraseAllSSDs: boolean
+  tpmClear: boolean
+  restoreBIOSToEOM: boolean
+  unconfigureCSME: boolean
+}
+
+export interface RemoteEraseRequest extends BootCapabilities {
+  ssdPassword?: string
 }
 
 export interface PowerState {