diff --git a/overlay/frameworks/base/core/res/res/values-ast-rES/strings.xml b/overlay/frameworks/base/core/res/res/values-ast-rES/strings.xml
index 82d688e..278318a 100644
--- a/overlay/frameworks/base/core/res/res/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-ast-rES/strings.xml
@@ -19,12 +19,14 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="byteShort">B</string>
+    <string name="fileSizeSuffix"><xliff:g id="number" example="123">%1$s</xliff:g> <xliff:g id="unit" example="B">%2$s</xliff:g></string>
     <string name="untitled">&lt;Ensin títulu&gt;</string>
     <string name="emptyPhoneNumber">(Ensin númberu de teléfonu)</string>
     <string name="unknownName">Desconozse</string>
     <string name="defaultVoiceMailAlphaTag">Buzón de voz</string>
     <string name="defaultMsisdnAlphaTag">MSISDN1</string>
     <string name="mmiError">Hebo un problema de conexón o\'l códigu MMI nun ye válidu.</string>
+    <string name="mmiErrorNotSupported">La función nun ye compatible.</string>
     <string name="mmiFdnError">La operación ta llendada a númberos de marcáu fixos.</string>
     <string name="mmiErrorWhileRoaming">Nun se puen camudar los axustes del esvíu de llamaes del teléfonu mentanto tas en roaming.</string>
     <string name="serviceEnabled">Activóse\'l serviciu.</string>
@@ -39,6 +41,8 @@
     <string name="mismatchPin">Los PIN que teclexesti nun concasen.</string>
     <string name="invalidPin">Teclexa un PIN que seya de 4 a 8 númberos.</string>
     <string name="invalidPuk">Teclexa un PUK que seya de 8 númberos o mayor.</string>
+    <string name="needPuk">La SIM ta bloquiada col PUK. Teclexa\'l códigu PUK pa desbloquiala.</string>
+    <string name="needPuk2">Teclexa\'l PUK2 pa desbloquiar la SIM.</string>
     <string name="enablePin">Hebo un fallu, activa\'l bloquéu de SIM/RUIM.</string>
     <plurals name="pinpuk_attempts">
         <item quantity="one">Quédate <xliff:g id="number">%d</xliff:g> intentu enantes de bloquiar la SIM.</item>
@@ -47,6 +51,7 @@
     <string name="imei">IMEI</string>
     <string name="meid">MEID</string>
     <string name="ClipMmi">ID de llamador entrante</string>
+    <string name="ClirMmi">Anubrir la ID de llamadores salientes</string>
     <string name="ColpMmi">ID de llinia conectada</string>
     <string name="ColrMmi">Torga d\'ID de la llinia conectada</string>
     <string name="CfMmi">Esvíu de llamaes</string>
@@ -66,6 +71,8 @@
     <string name="CLIRDefaultOffNextCallOff">Por defeutu, la ID de los llamadores nun se torga. Llamada siguiente: nun se torga</string>
     <string name="serviceNotProvisioned">Nun se fornió\'l serviciu.</string>
     <string name="CLIRPermanent">Nun pues camudar l\'axuste d\'ID de llamadores.</string>
+    <string name="auto_data_switch_title">Los datos cambiaron a «<xliff:g id="carrierDisplay" example="Verizon">%s</xliff:g>»</string>
+    <string name="auto_data_switch_content">Pues camudar esta opción cuando quieras en Configuración</string>
     <string name="RestrictedOnDataTitle">Nun hai serviciu de datos móviles</string>
     <string name="RestrictedOnEmergencyTitle">Les llamaes d\'emerxencia nun tán disponibles</string>
     <string name="RestrictedOnNormalTitle">Nun hai serviciu de voz</string>
@@ -130,18 +137,20 @@
     <string name="wfcSpnFormat_wifi">Wi-Fi</string>
     <string name="wfcSpnFormat_wifi_calling_wo_hyphen">Llamaes per WiFi</string>
     <string name="wfcSpnFormat_vowifi">VoWifi</string>
+    <string name="wfcSpnFormat_wifi_call">Llamada per Wi-Fi</string>
     <string name="wifi_calling_off_summary">Desactivaes</string>
     <string name="wfc_mode_wifi_preferred_summary">Llamar per Wi-Fi</string>
     <string name="wfc_mode_cellular_preferred_summary">Llamar pela rede móvil</string>
     <string name="wfc_mode_wifi_only_summary">Namás Wi-Fi</string>
     <string name="crossSimFormat_spn"><xliff:g id="spn" example="Operator">%s</xliff:g></string>
+    <string name="crossSimFormat_spn_cross_sim_calling">Llamaes alternatives (<xliff:g id="spn" example="Operator">%s</xliff:g>)</string>
     <string name="cfTemplateNotForwarded"><xliff:g id="bearer_service_code">{0}</xliff:g>: nun s\'esvió</string>
     <string name="cfTemplateForwarded"><xliff:g id="bearer_service_code">{0}</xliff:g>: <xliff:g id="dialing_number">{1}</xliff:g></string>
     <string name="cfTemplateForwardedTime"><xliff:g id="bearer_service_code">{0}</xliff:g>: <xliff:g id="dialing_number">{1}</xliff:g> dempués de <xliff:g id="time_delay">{2}</xliff:g> segundos</string>
     <string name="cfTemplateRegistered"><xliff:g id="bearer_service_code">{0}</xliff:g>: nun s\'esvió</string>
     <string name="cfTemplateRegisteredTime"><xliff:g id="bearer_service_code">{0}</xliff:g>: nun s\'esvió</string>
-    <string name="fcComplete">Códigu de carauterística completu.</string>
-    <string name="fcError">Hebo un problema de conexón o\'l códigu de carauterística nun ye válidu.</string>
+    <string name="fcComplete">Códigu de función completu.</string>
+    <string name="fcError">Hebo un problema de conexón o\'l códigu de función nun ye válidu.</string>
     <string name="httpErrorOk">OK</string>
     <string name="httpError">Hebo un fallu de rede.</string>
     <string name="httpErrorLookup">Nun se pudo atopar la URL.</string>
@@ -166,6 +175,11 @@
     <string name="low_memory" product="watch">L\'almacenamientu del reló ta enllén. Desanicia dalgunos ficheros pa lliberar espaciu.</string>
     <string name="low_memory" product="tv">L\'almacenamientu d\'Android TV ta enllén. Desanicia dalgunos ficheros pa lliberar espaciu.</string>
     <string name="low_memory" product="default">L\'almacenamientu del teléfonu ta enllén. Desanicia dalgunos ficheros pa lliberar espaciu.</string>
+    <string name="ssl_ca_cert_warning">{count, plural,
+        one {}=1    {Instalóse la entidá de certificación}
+        other {Instaláronse les entidaes de certificación}
+    }
+    </string>
     <string name="ssl_ca_cert_noti_by_unknown">Por un terceru desconocíu</string>
     <string name="ssl_ca_cert_noti_by_administrator">Pol alministrador del perfil llaboral</string>
     <string name="ssl_ca_cert_noti_managed">Por «<xliff:g id="managing_domain">%s</xliff:g>»</string>
@@ -179,10 +193,15 @@
     <string name="network_logging_notification_text">La to organización xestiona esti preséu y pue supervisar el tránsitu de la rede. Toca pa ver los detalles.</string>
     <string name="location_changed_notification_title">Les aplicaciones puen acceder a la to llocalización</string>
     <string name="location_changed_notification_text">Ponte en contautu col alministrador de TI pa saber más</string>
+    <string name="geofencing_service">Serviciu de llendes xeográfiques</string>
     <string name="country_detector">Detector de países</string>
     <string name="location_service">Serviciu de llocalización</string>
+    <string name="gnss_service">Serviciu GNSS</string>
     <string name="sensor_notification_service">Serviciu d\'avisos de los sensores</string>
     <string name="twilight_service">Serviciu Twilight</string>
+    <string name="gnss_time_update_service">Serviciu del anovamientu horariu de GNSS</string>
+    <string name="device_policy_manager_service">Serviciu del xestor de polítiques del preséu</string>
+    <string name="music_recognition_manager_service">Serviciu del xestor de reconocimientu de música</string>
     <string name="factory_reset_warning">El preséu va reafitase</string>
     <string name="factory_reset_message">L\'aplicación d\'alministración nun se pue usar. Van
         desaniciase los datos del preséu.\n\nSi tienes duldes,
@@ -196,6 +215,10 @@
         <xliff:g id="number" example="3">%3$d</xliff:g> díes.
     </string>
     <string name="personal_apps_suspended_turn_profile_on">Activar</string>
+    <string name="work_profile_telephony_paused_title">Llamaes y mensaxes desactivaos</string>
+    <string name="work_profile_telephony_paused_text">Posesti les aplicaciones llaborales.
+        Nun vas recibir llamaes o mensaxes de testu.</string>
+    <string name="work_profile_telephony_paused_turn_on_button">Volver activar</string>
     <string name="me">Yo</string>
     <string name="power_dialog" product="tablet">Opciones de la tableta</string>
     <string name="power_dialog" product="tv">Opciones d\'Android TV</string>
@@ -216,7 +239,7 @@
     <string name="reboot_to_reset_message">Reaniciando\u2026</string>
     <string name="shutdown_progress">Apagando\u2026</string>
     <string name="shutdown_confirm" product="tablet">La tableta va apagase.</string>
-    <string name="shutdown_confirm" product="tv">El preséu d\'Android TV va apagase.</string>
+    <string name="shutdown_confirm" product="tv">El preséu Android TV va apagase.</string>
     <string name="shutdown_confirm" product="watch">El reló va apagase.</string>
     <string name="shutdown_confirm" product="default">El teléfonu va apagase.</string>
     <string name="shutdown_confirm_question">¿Quies apagar el preséu?</string>
@@ -251,6 +274,11 @@
         mínima cuando\'l preséu nun respuenda o vaiga lentu, o cuando precises toles
         seiciones del informe. Nun permite qu\'introduzas más detalles o faigas más
         captures de pantalla.</string>
+    <string name="bugreport_countdown">{count, plural,
+        one {}=1 {Va facese una captura de pantalla pal informe de fallos en # segundu.}
+        other {Va facese una captura de pantalla pal informe de fallos en # segundos.}
+    }
+    </string>
     <string name="bugreport_screenshot_success_toast">Fízose una captura de pantalla col informe de fallos</string>
     <string name="bugreport_screenshot_failure_toast">Hebo un fallu al facer la captura de pantalla col informe de fallos</string>
     <string name="global_action_toggle_silent_mode">Mou silenciosu</string>
@@ -283,6 +311,7 @@
     <string name="notification_channel_heavy_weight_app">Aplicación n\'execución</string>
     <string name="notification_channel_foreground_service">Aplicaciones que gasten enerxía</string>
     <string name="notification_channel_accessibility_magnification">Aumentu</string>
+    <string name="notification_channel_accessibility_security_policy">Usu de l\'accesibilidá</string>
     <string name="foreground_service_app_in_background">«<xliff:g id="app_name">%1$s</xliff:g>»
         ta gastando enerxía</string>
     <string name="foreground_service_apps_in_background"><xliff:g id="number">%1$d</xliff:g>
@@ -295,6 +324,8 @@
     <string name="android_system_label">Sistema Android</string>
     <string name="user_owner_label">Cambiar al perfil personal</string>
     <string name="managed_profile_label">Cambiar al perfil llaboral</string>
+    <string name="user_owner_app_label">Cambiar a l\'aplicación «<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>» del perfil personal</string>
+    <string name="managed_profile_app_label">Cambiar a l\'aplicación «<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>» del perfil llaboral</string>
     <string name="permgrouplab_contacts">Contautos</string>
     <string name="permgroupdesc_contacts">accesu a los contautos</string>
     <string name="permgrouplab_location">Llocalización</string>
@@ -303,6 +334,12 @@
     <string name="permgroupdesc_calendar">accesu al calendariu</string>
     <string name="permgrouplab_sms">SMS</string>
     <string name="permgroupdesc_sms">unviu y visualización de mensaxes SMS</string>
+    <string name="permgrouplab_storage">Ficheros</string>
+    <string name="permgroupdesc_storage">accesu a los ficheros del preséu</string>
+    <string name="permgrouplab_readMediaAural">Música y audiu</string>
+    <string name="permgroupdesc_readMediaAural">accesu a la música y al audiu del preséu</string>
+    <string name="permgrouplab_readMediaVisual">Semeyes y vídeos</string>
+    <string name="permgroupdesc_readMediaVisual">accesu a les semeyes y los vídeos del preséu</string>
     <string name="permgrouplab_microphone">Micrófonu</string>
     <string name="permgroupdesc_microphone">grabación d\'audiu</string>
     <string name="permgrouplab_activityRecognition">Actividá física</string>
@@ -310,6 +347,7 @@
     <string name="permgrouplab_camera">Cámara</string>
     <string name="permgroupdesc_camera">fechura d\'imáxenes y grabación de vídeos</string>
     <string name="permgrouplab_nearby_devices">Preseos cercanos</string>
+    <string name="permgroupdesc_nearby_devices">descubrimientu de preseos y conexón con ellos</string>
     <string name="permgrouplab_calllog">Rexistru de llamaes</string>
     <string name="permgroupdesc_calllog">llectura y escritura nel rexistru de llamaes telefóniques</string>
     <string name="permgrouplab_phone">Teléfonu</string>
@@ -317,6 +355,7 @@
     <string name="permgrouplab_sensors">Sensores corporales</string>
     <string name="permgroupdesc_sensors">accesu a los datos del sensor sobre les tos constantes vitales</string>
     <string name="permgrouplab_notifications">Avisos</string>
+    <string name="permgroupdesc_notifications">amuesa d\'avisos</string>
     <string name="capability_title_canRetrieveWindowContent">Recuperar el conteníu de les ventanes</string>
     <string name="capability_desc_canRetrieveWindowContent">Inspeiciona\'l conteníu de la ventana
         cola que teas interactuando.</string>
@@ -337,12 +376,15 @@
         sobre\'l sensor de buelgues del preséu.</string>
     <string name="capability_title_canTakeScreenshot">Facer una captura de pantalla</string>
     <string name="capability_desc_canTakeScreenshot">Pue facer una captura de la pantalla.</string>
+    <string name="dream_preview_title">Previsualización, <xliff:g id="dream_name" example="Clock">%1$s</xliff:g></string>
     <string name="permlab_statusBar">desactivación o modificación de la barra d\'estáu</string>
     <string name="permdesc_statusBar">Permite que l\'aplicación desactive la barra d\'estáu o amieste y quite iconos del sistema.</string>
     <string name="permlab_statusBarService">barra d\'estáu</string>
     <string name="permdesc_statusBarService">Permite que l\'aplicación tea na barra d\'estáu.</string>
     <string name="permlab_expandStatusBar">espansión/contraición de la barra d\'estáu</string>
     <string name="permdesc_expandStatusBar">Permite que l\'aplicación espanda o contraya la barra d\'estáu.</string>
+    <string name="permlab_fullScreenIntent">amuesa d\'avisos como actividaes a pantalla completa nun preséu bloquiáu</string>
+    <string name="permdesc_fullScreenIntent">Permite que l\'aplicación amuese avisos como actividaes a pantalla completa nun preséu bloquiáu</string>
     <string name="permlab_install_shortcut">instalación d\'atayos</string>
     <string name="permdesc_install_shortcut">Permite qu\'una aplicación amieste atayos a la
         pantalla d\'aniciu ensin la intervención del usuariu.</string>
@@ -370,6 +412,10 @@
         entréguense en dalgunos llugares p\'aviste de situaciones d\'emerxencia.
         Les aplicaciones malicioses puen interfirir col rindimientu u operación
         del preséu cuando se reciba un espardimientu móvil d\'emerxencia.</string>
+    <string name="permlab_manageOngoingCalls">xestión de llamaes en cursu</string>
+    <string name="permdesc_manageOngoingCalls">Permite qu\'una aplicación vea los detalles de les
+         llamaes en cursu del preséu ya que controle
+         eses llamaes.</string>
     <string name="permlab_readCellBroadcasts">llectura de los mensaxes d\'espardimientu móvil</string>
     <string name="permdesc_readCellBroadcasts">Permite que l\'aplicación llea
         los mensaxes d\'espardimientu móvil que reciba\'l preséu. Les alertes
@@ -410,16 +456,47 @@
       causar qu\'otres aplicaciones dexen de tar n\'execución.</string>
     <string name="permlab_systemAlertWindow">Esta aplicación pue apaecer enriba d\'otres</string>
     <string name="permdesc_systemAlertWindow">Esta aplicación pue apaecer enriba d\'otres aplicaciones o d\'otres partes de la pantalla. Poro, ye posible qu\'interfira col usu normal de les aplicaciones y camudar la forma na qu\'apaecen.</string>
+    <string name="permdesc_hideOverlayWindows">Esta aplicación pue solicitar al sistema qu\'anubra les superposiciones d\'otres aplicaciones pa que nun s\'amuesen penriba.</string>
     <string name="permlab_runInBackground">execución en segundu planu</string>
     <string name="permdesc_runInBackground">Esta aplicación pue executase en segundu planu. Poro, la batería pue escosar aína.</string>
     <string name="permlab_useDataInBackground">usu de los datos en segundu planu</string>
     <string name="permdesc_useDataInBackground">Esta aplicación pue usar datos en segundu planu. Poro, l\'usu de datos pue aumentar.</string>
+    <string name="permlab_schedule_exact_alarm">programación d\'aiciones en momentos concretos</string>
+    <string name="permdesc_schedule_exact_alarm">Esta aplicación pue programar un trabayu pa que se faiga nun tiempu futuru. Esto tamién significa que l\'aplicación pue executase cuando nun teas usando activamente\'l preséu.</string>
+    <string name="permlab_use_exact_alarm">programación d\'alarmes o recordatorios d\'eventos</string>
+    <string name="permdesc_use_exact_alarm">Esta aplicación pue programar aiciones, como alarmes y recordatorios, p\'avisate cuando escueyas.</string>
     <string name="permlab_persistentActivity">execución continua de l\'aplicación</string>
     <string name="permdesc_persistentActivity" product="tablet">Permite que l\'aplicación faiga que partes sigo mesma seyan permanentes en memoria.  Esto pue llendar la memoria disponible pa otres aplicaciones y amenorgar la velocidá de la tableta.</string>
     <string name="permdesc_persistentActivity" product="tv">Permite que l\'aplicación faiga que partes sigo mesma seyan permanentes en memoria.  Esto pue llendar la memoria disponible pa otres aplicaciones y amenorgar la velocidá d\'Android TV.</string>
     <string name="permdesc_persistentActivity" product="default">Permite que l\'aplicación faiga que partes sigo mesma seyan permanentes en memoria.  Esto pue llendar la memoria disponible pa otres aplicaciones y amenorgar la velocidá del teléfonu.</string>
     <string name="permlab_foregroundService">execución de servicios en primer planu</string>
     <string name="permdesc_foregroundService">Permite que l\'aplicación use los servicios en primer planu.</string>
+    <string name="permlab_foregroundServiceCamera">execución d\'un serviciu en primer planu col tipu «camera»</string>
+    <string name="permdesc_foregroundServiceCamera">Permite que l\'aplicación use los servicios en primer planu col tipu «camera»</string>
+    <string name="permlab_foregroundServiceConnectedDevice">execución d\'un serviciu en primer planu col tipu «connectedDevice»</string>
+    <string name="permdesc_foregroundServiceConnectedDevice">Permite que l\'aplicación use los servicios en primer planu col tipu «connectedDevice»</string>
+    <string name="permlab_foregroundServiceDataSync">execución d\'un serviciu en primer planu col tipu «dataSync»</string>
+    <string name="permdesc_foregroundServiceDataSync">Permite que l\'aplicación use los servicios en primer planu col tipu «dataSync»</string>
+    <string name="permlab_foregroundServiceLocation">execución d\'un serviciu en primer planu col tipu «location»</string>
+    <string name="permdesc_foregroundServiceLocation">Permite que l\'aplicación use los servicios en primer planu col tipu «location»</string>
+    <string name="permlab_foregroundServiceMediaPlayback">execución d\'un serviciu en primer planu col tipu «mediaPlayback»</string>
+    <string name="permdesc_foregroundServiceMediaPlayback">Permite que l\'aplicación use los servicios en primer planu col tipu «mediaPlayback»</string>
+    <string name="permlab_foregroundServiceMediaProjection">execución d\'un serviciu en primer planu col tipu «mediaProjection»</string>
+    <string name="permdesc_foregroundServiceMediaProjection">Permite que l\'aplicación use los servicios en primer planu col tipu «mediaProjection»</string>
+    <string name="permlab_foregroundServiceMicrophone">execución d\'un serviciu en primer planu col tipu «microphone»</string>
+    <string name="permdesc_foregroundServiceMicrophone">Permite que l\'aplicación use los servicios en primer planu col tipu «microphone»</string>
+    <string name="permlab_foregroundServicePhoneCall">execución d\'un serviciu en primer planu col tipu «phoneCall»</string>
+    <string name="permdesc_foregroundServicePhoneCall">Permite que l\'aplicación use los servicios en primer planu col tipu «phoneCall»</string>
+    <string name="permlab_foregroundServiceHealth">execución d\'un serviciu en primer planu col tipu «health»</string>
+    <string name="permdesc_foregroundServiceHealth">Permite que l\'aplicación use los servicios en primer planu col tipu «health»</string>
+    <string name="permlab_foregroundServiceRemoteMessaging">execución d\'un serviciu en primer planu col tipu «remoteMessaging»</string>
+    <string name="permdesc_foregroundServiceRemoteMessaging">Permite que l\'aplicación use los servicios en primer planu col tipu «remoteMessaging»</string>
+    <string name="permlab_foregroundServiceSystemExempted">execución d\'un serviciu en primer planu col tipu «systemExempted»</string>
+    <string name="permdesc_foregroundServiceSystemExempted">Permite que l\'aplicación use los servicios en primer planu col tipu «systemExempted»</string>
+    <string name="permlab_foregroundServiceFileManagement">execución d\'un serviciu en primer planu col tipu «fileManagement»</string>
+    <string name="permdesc_foregroundServiceFileManagement">Permite que l\'aplicación use los servicios en primer planu col tipu «fileManagement»</string>
+    <string name="permlab_foregroundServiceSpecialUse">execución d\'un serviciu en primer planu col tipu «specialUse»</string>
+    <string name="permdesc_foregroundServiceSpecialUse">Permite que l\'aplicación use los servicios en primer planu col tipu «specialUse»</string>
     <string name="permlab_getPackageSize">midimientu del espaciu d\'almacenamientu de l\'aplicación</string>
     <string name="permdesc_getPackageSize">Permite que l\'aplicación recupere los datos, el códigu y los tamaños de la caché de so</string>
     <string name="permlab_writeSettings">modificación de los axustes del sistema</string>
@@ -484,6 +561,10 @@
     <string name="permdesc_writeCallLog" product="default">Permite que l\'aplicación modifique\'l rexistru de llamaes del teléfonu, incluyíes les llamaes entrantes
         y salientes. Les aplicaciones malicioses puen usar esti permisu pa desaniciar o modificar
         el rexistru de llamaes.</string>
+    <string name="permlab_bodySensors">accesu a los datos de los sensores corporales mentanto tán n\'usu</string>
+    <string name="permdesc_bodySensors" product="default">Permite que l\'aplicación acceda a los datos de los sensores corporales, como la frecuencia cardiaca, el porcentaxe d\'oxíxenu na sangre y la temperatura mentanto l\'aplicación ta n\'usu.</string>
+    <string name="permlab_bodySensors_background">accesu a los datos de los sensores corporales en segundu planu</string>
+    <string name="permdesc_bodySensors_background" product="default">Permite que l\'aplicación acceda a los datos de los sensores corporales, como la frecuencia cardiaca, el porcentaxe d\'oxíxenu na sangre y la temperatura mentanto l\'aplicación ta en segundu planu.</string>
     <string name="permlab_readCalendar">llectura de los eventos y los detalles del calendariu</string>
     <string name="permdesc_readCalendar" product="tablet">Esta aplicación pue lleer tolos eventos del calendariu atroxaos na tableta y compartir o guardar los datos del calendariu.</string>
     <string name="permdesc_readCalendar" product="tv">Esta aplicación pue lleer tolos eventos del calendariu atroxaos n\'Android TV y compartir o guardar datos del calendariu.</string>
@@ -496,7 +577,7 @@
     <string name="permdesc_accessLocationExtraCommands">Permite que l\'aplicación acceda
         a los comandos adicionales del fornidor de llocalización.  Esti permisu
         pue interfirir col funcionamientu del GPS con otres fontes de llocalización.</string>
-    <string name="permlab_accessFineLocation">accesua la llocalización exauta namás en primer planu</string>
+    <string name="permlab_accessFineLocation">accesu a la llocalización exauta namás en primer planu</string>
     <string name="permdesc_accessFineLocation">Esta aplicación pue consiguir la lo llocalización exautu pente les fontes de llocalización mentanto l\'aplicación ta n\'usu. Los servicios de llocalización han tar activaos pa que l\'aplicación consiga la llocalización. Poro, l\'aplicación pue consumir más enerxía.</string>
     <string name="permlab_accessCoarseLocation">accesu a la llocalización namás en primer planu</string>
     <string name="permdesc_accessCoarseLocation">Esta aplicación pue consiguir la to llocalización aproximada pente les fontes de llocalización mentanto l\'aplicación ta n\'usu. Los servicios de llocalización han tar activaos pa que l\'aplicación consiga la llocalización.</string>
@@ -505,12 +586,18 @@
     <string name="permlab_modifyAudioSettings">cambéu de los axustes d\'audiu</string>
     <string name="permdesc_modifyAudioSettings">Permite que l\'aplicación modifique los axustes d\'audiu globales como\'l volume o l\'altavoz que s\'usa pa la salida.</string>
     <string name="permlab_recordAudio">grabación d\'audiu</string>
+    <string name="permdesc_recordAudio">Esta aplicación pue grabar audiu col micrófonu mentanto la uses.</string>
+    <string name="permlab_recordBackgroundAudio">grabación d\'audiu en segundu planu</string>
     <string name="permdesc_recordBackgroundAudio">Esta aplicación pue grabar audiu en cualesquier momentu cola cámara.</string>
+    <string name="permlab_detectScreenCapture">deteición de les captures de pantalla de les ventanes de les aplicaciones</string>
+    <string name="permdesc_detectScreenCapture">Esta aplicación va recibir un avisu cuando se faiga una captura de pantalla mentanto l\'aplicación ta n\'usu.</string>
     <string name="permlab_sim_communication">comunicación cola SIM</string>
     <string name="permdesc_sim_communication">Permite que l\'aplicación unvie comandos a la SIM. Esto ye perpeligroso.</string>
     <string name="permlab_activityRecognition">reconocencia de l\'actividá física</string>
     <string name="permdesc_activityRecognition">Esta aplicación pue reconocer la to actividá física.</string>
     <string name="permlab_camera">fechura de semeyes y vídeos</string>
+    <string name="permdesc_camera">Esta aplicación pue facer semeyes y grabar vídeos cola cámara mentanto l\'aplicación ta n\'usu.</string>
+    <string name="permlab_backgroundCamera">fechura de semeyes y vídeos en segundu planu</string>
     <string name="permdesc_backgroundCamera">Esta aplicación pue facer semeyes y grabar vídeos en cualesquier momentu cola cámara.</string>
     <string name="permlab_systemCamera">Permite qu\'una aplicación o serviciu acceda a les cámara del sistema pa facer semeyes y vídeos</string>
     <string name="permdesc_systemCamera">Esta aplicación del sistema o con privilexos pue facer semeyes y grabar vídeos cola cámara del sistema en cualesquier momentu. L\'aplicación tamién ha tener el permisu android.permission.CAMERA pa facelo</string>
@@ -520,6 +607,13 @@
     <string name="permdesc_vibrate">Permite que l\'aplicación controle\'l vibrador.</string>
     <string name="permdesc_vibrator_state">Permite que l\'aplicación acceda al estáu del vibrador.</string>
     <string name="permlab_callPhone">llamada direuta a los númberos de teléfonu</string>
+    <string name="permdesc_callPhone">Permite que l\'aplicación faiga llamaes
+      ensin la to intervención. Esta aición pue xenerar cargos o llamaes
+      inesperaos. Decátate qu\'esto nun permite a l\'aplicación facer llamaes a
+      númberos d\'emerxencia. Les aplicaciones malicioses puen facer llamaes
+      que xeneren costos ensin la to confirmación o marcar códigos de la
+      operadora que faigan que les llamaes entrantes s\'esvíen de forma
+      automática a otru númberu.</string>
     <string name="permlab_accessImsCallService">accesu al serviciu de llamaes IMS</string>
     <string name="permdesc_accessImsCallService">Permite que l\'aplicación use\'l serviciu IMS pa facer llamaes ensin la to intervención.</string>
     <string name="permlab_readPhoneState">llectura del estáu y la identidá del teléfonu</string>
@@ -527,6 +621,9 @@
       funciones telefóniques del preséu. Con esti permisu l\'aplicación pue determinar
       el númberu de teléfonu y les IDs de preseos, saber si hai llamaes en cursu y los
       númberos remotos conectaos pente una llamada.</string>
+    <string name="permlab_readBasicPhoneState">llectura del estáu y la identidá básicos de telefonía</string>
+    <string name="permdesc_readBasicPhoneState">Permite que l\'aplicación acceda a les funciones
+        de telefonía básiques del preséu.</string>
     <string name="permlab_manageOwnCalls">encaminamientu de llamaes pente\'l sistema</string>
     <string name="permdesc_manageOwnCalls">Permite que l\'aplicación encamine les sos llamaes
         pente\'l sistema p\'ayuda a ameyorar la
@@ -633,8 +730,16 @@
     <string name="permdesc_bluetooth" product="default">Permite que l\'aplicación vea la
       configuración del Bluetooth del teléfonu y faiga y acepte
       conexones colos preseos empareyaos.</string>
-    <string name="permdesc_bluetooth_scan" product="default">Permite que l\'aplicación descubra y s\'empareye con preseos Bluetooth cercanos</string>
+    <string name="permlab_bluetooth_scan">descubrimientu de preseos Bluetooth cercanos y empareyamientu con ellos</string>
+    <string name="permdesc_bluetooth_scan" product="default">Permite que l\'aplicación descubra ya s\'empareye con preseos Bluetooth cercanos</string>
+    <string name="permlab_bluetooth_connect">conexón con preseos Bluetooth empareyaos</string>
     <string name="permdesc_bluetooth_connect" product="default">Permite que l\'aplicación se conecte a los preseos Bluetooth empareyaos</string>
+    <string name="permlab_bluetooth_advertise">avisos a preseos Bluetooth cercanos</string>
+    <string name="permdesc_bluetooth_advertise" product="default">Permite que l\'aplicación s\'anuncie a los preseos Bluetooth cercanos</string>
+    <string name="permlab_uwb_ranging">cálculu de la posición relativa ente preseos de banda ultraampla cercanos</string>
+    <string name="permdesc_uwb_ranging">Permite que l\'aplicación determine la posición relativa ente preseos de banda ultraampla cercanos</string>
+    <string name="permlab_nearby_wifi_devices">interaición colos preseos Wi\u2011Fi cercanos</string>
+    <string name="permdesc_nearby_wifi_devices">Permite que l\'aplicación s\'anuncie, conecte y determine la posición relativa de los preseos Wi\u2011Fi cercanos</string>
     <string name="permlab_preferredPaymentInfo">Información del serviciu de pagos preferíu per NFC</string>
     <string name="permdesc_preferredPaymentInfo">Permite que l\'aplicación consiga información del serviciu de pagos preferíu
       per NFC, como ayudes rexistraes y destinos de caminos.</string>
@@ -654,6 +759,10 @@
         estes recomendaciones. Decátate que\'l bloquéu de pantalla nun s\'atroxa como testu ensin
         formatu, polo que l\'aplicación nun conoz la contraseña exauta.
     </string>
+    <string name="permlab_postNotification">amuesa d\'avisos</string>
+    <string name="permdesc_postNotification">Permite que l\'aplicación amuese avisos</string>
+    <string name="permlab_turnScreenOn">encendíu de la pantalla</string>
+    <string name="permdesc_turnScreenOn">Permite que l\'aplicación prenda la pantalla.</string>
     <string name="permlab_useBiometric">usu del hardware biométrico</string>
     <string name="permdesc_useBiometric">Permite que l\'aplicación use\'l hardware biométrico pa l\'autenticación</string>
     <string name="permlab_manageFingerprint">xestión del hardware de buelgues</string>
@@ -668,48 +777,115 @@
     <string name="permdesc_imagesWrite">Permite que l\'aplicación modifique la coleición de semeyes.</string>
     <string name="permlab_mediaLocation">llectura de los llugares de los elementos de la coleición multimedia</string>
     <string name="permdesc_mediaLocation">Permite que l\'aplicación llea los llugares onde se ficieron los elementos de la coleición multimedia.</string>
+    <string name="biometric_app_setting_name">Usar la biometría</string>
+    <string name="biometric_or_screen_lock_app_setting_name">Usar la biometría o\'l bloquéu de la pantalla</string>
     <string name="biometric_dialog_default_title">Verifica que yes tu</string>
+    <string name="biometric_dialog_default_subtitle">Usa la biometría pa siguir</string>
+    <string name="biometric_or_screen_lock_dialog_default_subtitle">Pa siguir, usa la biometría o\'l bloquéu de pantalla</string>
     <string name="biometric_error_hw_unavailable">El hardware biométrico nun ta disponible</string>
     <string name="biometric_error_user_canceled">Encaboxóse l\'autenticación</string>
     <string name="biometric_not_recognized">Nun se reconoz</string>
+    <string name="biometric_face_not_recognized">Nun se reconoció la cara</string>
     <string name="biometric_error_canceled">Encaboxóse l\'autenticación</string>
     <string name="biometric_error_device_not_secured">Nun s\'afitó nengún PIN, patrón o contraseña</string>
+    <string name="biometric_error_generic">Hebo un error na autenticación</string>
+    <string name="screen_lock_app_setting_name">Usar el bloquéu de pantalla</string>
+    <string name="screen_lock_dialog_default_subtitle">Pa siguir, introduz el bloquéu de pantalla</string>
+    <string name="fingerprint_acquired_partial">Primi\'l sensor con firmeza</string>
+    <string name="fingerprint_acquired_insufficient">Nun se pue reconocer la buelga. Volvi tentalo.</string>
+    <string name="fingerprint_acquired_imager_dirty">Llimpia\'l sensor de buelgues y volvi tentalo</string>
+    <string name="fingerprint_acquired_imager_dirty_alt">Llimpia\'l sensor y volvi tentalo</string>
+    <string name="fingerprint_acquired_too_fast">Primi\'l sensor con firmeza</string>
     <string name="fingerprint_acquired_too_slow">El deu movióse perdespacio. Volvi tentalo.</string>
-    <string name="fingerprint_acquired_already_enrolled">Prueba otra buelga</string>
+    <string name="fingerprint_acquired_already_enrolled">Prueba con otra buelga</string>
+    <string name="fingerprint_acquired_too_bright">Hai permuncha lluz</string>
+    <string name="fingerprint_acquired_power_press">Primióse\'l botón de prendíu</string>
+    <string name="fingerprint_acquired_try_adjusting">Prueba a mover el deu</string>
+    <string name="fingerprint_acquired_immobile">Camuda llixeramente la posición del deu en cada intentu</string>
     <string-array name="fingerprint_acquired_vendor"/>
+    <string name="fingerprint_error_not_match">Nun se reconoció la buelga</string>
+    <string name="fingerprint_udfps_error_not_match">Nun se reconoció la buelga</string>
+    <string name="fingerprint_dialog_use_fingerprint_instead">Nun se pue reconocer la cara. Usa la buelga.</string>
     <string name="fingerprint_authenticated">Autenticóse la buelga</string>
     <string name="face_authenticated_no_confirmation_required">Autenticóse la cara</string>
     <string name="face_authenticated_confirmation_required">Autenticóse la cara, primi «Confirmar»</string>
     <string name="fingerprint_error_hw_not_available">El hardware de buelgues nun ta disponible.</string>
+    <string name="fingerprint_error_no_space">Nun se pue configurar la buelga</string>
+    <string name="fingerprint_error_timeout">Escosó\'l tiempu d\'espera pa configurar la buelga. Volvi tentalo.</string>
     <string name="fingerprint_error_canceled">Encaboxóse la operación de buelga.</string>
     <string name="fingerprint_error_user_canceled">L\'usuariu encaboxó la operación de la buelga.</string>
+    <string name="fingerprint_error_lockout">Ficiéronse milenta intentos. Usa\'l bloquéu de pantalla.</string>
+    <string name="fingerprint_error_lockout_permanent">Ficiéronse milenta intentos. Usa\'l bloquéu de pantalla.</string>
+    <string name="fingerprint_error_unable_to_process">Nun se pue procesar la buelga. Volvi tentalo.</string>
     <string name="fingerprint_error_no_fingerprints">Nun se rexistró nenguna buelga.</string>
     <string name="fingerprint_error_hw_not_present">Esti preséu nun tien nengún sensor de buelgues.</string>
     <string name="fingerprint_error_security_update_required">El sensor desactivóse temporalmente.</string>
+    <string name="fingerprint_error_bad_calibration">Nun se pue usar el sensor de buelgues. Visita un fornidor de reparaciones</string>
+    <string name="fingerprint_error_power_pressed">Primióse\'l botón de prendíu</string>
     <string name="fingerprint_name_template">Deu <xliff:g id="fingerId" example="1">%d</xliff:g></string>
+    <string name="fingerprint_app_setting_name">Usar la buelga</string>
+    <string name="fingerprint_or_screen_lock_app_setting_name">Usar la buelga o\'l bloquéu de pantalla</string>
+    <string name="fingerprint_dialog_default_subtitle">Pa siguir, usa la buelga</string>
+    <string name="fingerprint_or_screen_lock_dialog_default_subtitle">Pa siguir, usa la buelga o\'l bloquéu de pantalla</string>
     <string-array name="fingerprint_error_vendor"/>
+    <string name="fingerprint_error_vendor_unknown">Asocedió daqué malo. Volvi tentalo.</string>
     <string name="fingerprint_icon_content_description">Iconu de buelga</string>
+    <string name="device_unlock_notification_name">Desbloquéu del preséu</string>
+    <string name="alternative_unlock_setup_notification_title">Prueba otra forma de desbloquiar</string>
+    <string name="alternative_face_setup_notification_content">Usa\'l bloquéu facial cuando nun se reconoza la buelga por, por exemplu, tener los deos moyaos</string>
+    <string name="alternative_fp_setup_notification_content">Usa\'l desbloquéu cola buelga cuando nun se reconoza la cara por, por exemplu, nun haber abonda lluz</string>
     <string name="face_recalibrate_notification_name">Desbloquéu facial</string>
+    <string name="face_recalibrate_notification_title">Hai un problema col desbloquéu facial</string>
+    <string name="face_recalibrate_notification_content">Toca pa desaniciar el modelu facial y, dempués, volvi amestar la to cara</string>
+    <string name="face_sensor_privacy_enabled">Pa usar el desbloquéu facial, activa la opción <b>Accesu a la cámara</b> en Configuración &gt; Privacidá</string>
     <string name="fingerprint_recalibrate_notification_name">Desbloquéu cola buelga</string>
     <string name="fingerprint_recalibrate_notification_title">Nun se pue usar el sensor de buelgues</string>
+    <string name="fingerprint_recalibrate_notification_content">Visita un fornidor de reparaciones.</string>
+    <string name="face_acquired_insufficient">Nun se pue crear el modelu facial. Volvi tentalo.</string>
     <string name="face_acquired_too_bright">Hai muncha lluz. Busca un llugar con menos lluz.</string>
+    <string name="face_acquired_too_dark">Nun hai abonda lluz</string>
+    <string name="face_acquired_too_close">Alloña\'l teléfonu</string>
+    <string name="face_acquired_too_far">Avera\'l teléfonu</string>
+    <string name="face_acquired_too_high">Alza\'l teléfonu</string>
+    <string name="face_acquired_too_low">Baxa\'l teléfonu</string>
+    <string name="face_acquired_too_right">Movi\'l teléfonu a la esquierda</string>
+    <string name="face_acquired_too_left">Movi\'l teléfonu a la derecha</string>
     <string name="face_acquired_poor_gaze">Mira de mou más direutu al preséu.</string>
+    <string name="face_acquired_not_detected">Nun se pue ver la cara. Pon el teléfonu al altor de los güeyos.</string>
     <string name="face_acquired_too_much_motion">Hebo munchu movimientu. Nun muevas el teléfonu.</string>
     <string name="face_acquired_recalibrate">Volvi rexistrar la cara.</string>
+    <string name="face_acquired_too_different">Nun se pue reconocer la cara. Volvi tentalo.</string>
+    <string name="face_acquired_too_similar">Camuda llixeramente la posición de la cabeza</string>
+    <string name="face_acquired_pan_too_extreme">Mira\'l teléfonu de forma más direuta</string>
+    <string name="face_acquired_tilt_too_extreme">Mira\'l teléfonu de forma más direuta</string>
+    <string name="face_acquired_roll_too_extreme">Mira\'l teléfonu de forma más direuta</string>
     <string name="face_acquired_obscured">Quita tolo qu\'anubra la cara.</string>
     <string name="face_acquired_sensor_dirty">Llimipia\'l sensor del estremu cimeru.</string>
+    <string name="face_acquired_dark_glasses_detected">@string/face_acquired_dark_glasses_detected_alt</string>
+    <string name="face_acquired_mouth_covering_detected">@string/face_acquired_mouth_covering_detected_alt</string>
+    <string name="face_acquired_recalibrate_alt">Nun se pue crear el modelu facial. Volvi tentalo.</string>
+    <string name="face_acquired_dark_glasses_detected_alt">Detectáronse lentes escures. La cara ha tar completamente visible.</string>
+    <string name="face_acquired_mouth_covering_detected_alt">Detectóse que la cara ta cubierta. La cara ha tar completamente visible.</string>
     <string-array name="face_acquired_vendor"/>
     <string name="face_error_hw_not_available">Nun se pue verificar la cara. El hardware nun ta disponible.</string>
     <string name="face_error_timeout">Volvi probar el desbloquéu facial</string>
     <string name="face_error_no_space">P\'atroxar los datos faciales nuevos, desanicia los antiguos.</string>
     <string name="face_error_canceled">Encaboxóse la operación facial</string>
+    <string name="face_error_user_canceled">L\'usuariu encaboxó\'l desbloquéu facial</string>
     <string name="face_error_lockout">Ficiéronse milenta intentos. Volvi tentalo.</string>
+    <string name="face_error_lockout_permanent">Ficiéronse milenta intentos. El desbloquéu facial nun ta disponible.</string>
+    <string name="face_error_lockout_screen_lock">Ficiéronse milenta intentos. Introduz el bloquéu de pantalla.</string>
     <string name="face_error_unable_to_process">Nun se pue verificar la cara. Volvi tentalo.</string>
     <string name="face_error_not_enrolled">Nun configuresti\u2019l desbloquéu facial</string>
     <string name="face_error_hw_not_present">El desbloquéu facial nun ye compatible con esti preséu</string>
     <string name="face_error_security_update_required">El sensor desactivóse temporalmente.</string>
     <string name="face_name_template">Cara <xliff:g id="faceId" example="1">%d</xliff:g></string>
+    <string name="face_app_setting_name">Usar el desbloquéu facial</string>
+    <string name="face_or_screen_lock_app_setting_name">Usar la cara o\'l bloquéu de pantalla</string>
+    <string name="face_dialog_default_subtitle">Usa la cara pa siguir</string>
+    <string name="face_or_screen_lock_dialog_default_subtitle">Pa siguir, usa la cara o\'l bloquéu de pantalla</string>
     <string-array name="face_error_vendor"/>
+    <string name="face_error_vendor_unknown">Asocedió daqué malo. Volvi tentalo.</string>
     <string name="face_icon_content_description">Iconu facial</string>
     <string name="permlab_readSyncSettings">llectura de los axustes de sincronización</string>
     <string name="permdesc_readSyncSettings">Permite que l\'aplicación llea los axustes de sincronización d\'una cuenta. Por exemplu, esto pue determinar si l\'aplicación Persones ta sincronizada con una cuenta.</string>
@@ -719,6 +895,14 @@
     <string name="permdesc_readSyncStats">Permite que l\'aplicación consulte les estadístiques de sincronización d\'una cuenta, incluyíos l\'historial d\'eventos sincronizaos y la cantidá de datos que se sincronicen. </string>
     <string name="permlab_sdcardRead">llectura del conteníu del almacenamientu compartíu</string>
     <string name="permdesc_sdcardRead">Permite que l\'aplicación llea\'l conteníu del almacenamientu compartíu.</string>
+    <string name="permlab_readMediaAudio">llectura de ficheros d\'audiu del almacenamientu compartíu</string>
+    <string name="permdesc_readMediaAudio">Permite que l\'aplicación llea ficheros d\'audiu del almacenamientu compartíu.</string>
+    <string name="permlab_readMediaVideo">llectura de ficheros videu del almacenamientu compartíu</string>
+    <string name="permdesc_readMediaVideo">Permite que l\'aplicación llea ficheros de videu del almacenamientu compartíu.</string>
+    <string name="permlab_readMediaImages">llectura de ficheros d\'imaxe del almacenamientu compartíu</string>
+    <string name="permdesc_readMediaImages">Permite que l\'aplicación llea ficheros d\'imaxe del almacenamientu compartíu.</string>
+    <string name="permlab_readVisualUserSelect">llectura de los ficheros d\'imaxe y de videu seleicionaos pol usuariu del almacenamientu compartíu</string>
+    <string name="permdesc_readVisualUserSelect">Permite que l\'aplicación llea los ficheros d\'imaxe y de videu que seleiciones del almacenamientu compartíu.</string>
     <string name="permlab_sdcardWrite">modificación o desaniciu del conteníu del almacenamientu compartíu</string>
     <string name="permdesc_sdcardWrite">Permite que l\'aplicación escriba conteníu nel almacenamientu compartíu.</string>
     <string name="permlab_use_sip">fechura/receición de llamaes SIP</string>
@@ -769,6 +953,14 @@
     <string name="permdesc_access_notification_policy">Permite que l\'aplicación llea la configuración del mou «Nun molestar» y escriba nella.</string>
     <string name="permlab_startViewPermissionUsage">aniciu de la visualización del usu de permisos</string>
     <string name="permdesc_startViewPermissionUsage">Permite que\'l propietariu anicie l\'usu de permisos d\'una aplicación. Les aplicaciones normales enxamás habríen precisar esti permisu.</string>
+    <string name="permlab_startReviewPermissionDecisions">visualización de les decisiones tocante a los permisos</string>
+    <string name="permdesc_startReviewPermissionDecisions">Permite que\'l propietariu anicie la pantalla pa previsualizar les decisiones de los permisos. Les aplicaciones normales enxamás habríen precisar esti permisu.</string>
+    <string name="permlab_startViewAppFeatures">visualización de les funciones d\'aplicaciones</string>
+    <string name="permdesc_startViewAppFeatures">Permite que\'l propietariu anicie la visualización de la información de les funciones d\'una aplicación.</string>
+    <string name="permlab_highSamplingRateSensors">accesu a los datos de los sensores a una velocidá d\'amuesa alta</string>
+    <string name="permdesc_highSamplingRateSensors">Permite que l\'aplicación recueya los datos de sensores a una frecuencia superior a 200 Hz</string>
+    <string name="permlab_updatePackagesWithoutUserAction">anovamientu d\'aplicaciones ensin la intervención del usuariu</string>
+    <string name="permdesc_updatePackagesWithoutUserAction">Permite que\'l propietariu anueve les aplicaciones qu\'instalares anteriormente ensin la intervención del usuariu</string>
     <string name="policylab_limitPassword">Configuración de les regles pa les contraseñes</string>
     <string name="policydesc_limitPassword">Controla la llongura y los caráuteres permitíos nes contraseñes y nos PIN de la pantalla de bloquéu.</string>
     <string name="policylab_watchLogin">Supervisión de los intentos del desbloquéu de pantalla</string>
@@ -778,6 +970,9 @@
     <string name="policydesc_watchLogin" product="tv">Supervisa\'l númberu incorreutu de contraseñes
     teclexaes al desbloquiar la pantalla y bloquia Android TV o desanicia tolos sos
     datos si s\'introducen milenta contraseñes incorreutes.</string>
+    <string name="policydesc_watchLogin" product="automotive">Supervisa\'l númberu incorreutu de contraseñes
+    teclexaes al desbloquiar la pantalla y bloquia\'l sistema d\'información y entretenimientu o desanicia tolos sos
+    datos si s\'introducen milenta contraseñes incorreutes.</string>
     <string name="policydesc_watchLogin" product="default">Supervisa\'l númberu incorreutu de contraseñes
     teclexaes al desbloquiar la pantalla y bloquia\'l teléfonu o desanicia tolos sos
     datos si s\'introducen milenta contraseñes incorreutes.</string>
@@ -787,6 +982,9 @@
     <string name="policydesc_watchLogin_secondaryUser" product="tv">Supervisa\'l númberu incorreutu de contraseñes
     teclexaes al desbloquiar la pantalla y bloquia Android TV o desanicia tolos datos
     d\'esti usuariu si s\'introducen milenta contraseñes incorreutes.</string>
+    <string name="policydesc_watchLogin_secondaryUser" product="automotive">Supervisa\'l númberu incorreutu de contraseñes
+    teclexaes al desbloquiar la pantalla y bloquia\'l sistema d\'información y entretenimientu o desanicia tolos
+    datos d\'esti perfil si s\'introducen milenta contraseñes incorreutes.</string>
     <string name="policydesc_watchLogin_secondaryUser" product="default">Supervisa\'l númberu incorreutu de contraseñes
     teclexaes al desbloquiar la pantalla y bloquia\'l teléfonu o desanicia tolos datos
     d\'esti usuariu si s\'introducen milenta contraseñes incorreutes.</string>
@@ -797,10 +995,13 @@
     <string name="policylab_wipeData">Desaniciu de tolos datos</string>
     <string name="policydesc_wipeData" product="tablet">Desanicia los datos de la tableta ensin avisar y reafita\'l preséu.</string>
     <string name="policydesc_wipeData" product="tv">Desanicia los datos d\'Android TV ensin avisar y reafita\'l preséu.</string>
+    <string name="policydesc_wipeData" product="automotive">Desanicia los datos del sistema d\'información y entretenimientu ensin avisar y reafita\'l preséu.</string>
     <string name="policydesc_wipeData" product="default">Desanicia los datos del teléfonu ensin avisar y reafita\'l preséu.</string>
+    <string name="policylab_wipeData_secondaryUser" product="automotive">Desaniciu de los datos de perfiles</string>
     <string name="policylab_wipeData_secondaryUser" product="default">Desaniciu de los datos del usuariu</string>
     <string name="policydesc_wipeData_secondaryUser" product="tablet">Desanicia los datos guardaos d\'esti usuariu na tableta ensin avisar.</string>
     <string name="policydesc_wipeData_secondaryUser" product="tv">Desanicia los datos guardaos d\'esti usuariu n\'Android TV ensin avisar.</string>
+    <string name="policydesc_wipeData_secondaryUser" product="automotive">Desanicia los datos del perfil d\'esti sistema d\'información y entretenimientu ensin avisar.</string>
     <string name="policydesc_wipeData_secondaryUser" product="default">Desanicia los datos guardaos d\'esti usuariu nel teléfonu ensin avisar.</string>
     <string name="policylab_setGlobalProxy">Configuración del proxy global del preséu</string>
     <string name="policydesc_setGlobalProxy">Afita\'l proxy global del preséu
@@ -950,6 +1151,15 @@
     <string name="lockscreen_password_wrong">Volvi tentalo</string>
     <string name="lockscreen_storage_locked">Desbloquia p\'acceder a toles funciones y datos</string>
     <string name="faceunlock_multiple_failures">Superóse\'l númberu máximu d\'intentos del desbloquéu facial</string>
+    <string name="lockscreen_missing_sim_message_short">Nun hai nenguna SIM</string>
+    <string name="lockscreen_missing_sim_message" product="tablet">Nun hai nenguna SIM na tableta.</string>
+    <string name="lockscreen_missing_sim_message" product="tv">Nun hai nenguna SIM n\'Android TV.</string>
+    <string name="lockscreen_missing_sim_message" product="default">Nun hai nenguna SIM nel teléfonu.</string>
+    <string name="lockscreen_missing_sim_instructions">Amiesta una SIM.</string>
+    <string name="lockscreen_missing_sim_instructions_long">Falta la SIM o nun se pue lleer. Amiesta una.</string>
+    <string name="lockscreen_permanent_disabled_sim_message_short">La SIM ta inutilizada.</string>
+    <string name="lockscreen_permanent_disabled_sim_instructions">La SIM inhabilitóse dafechu.\n
+    Ponte en contautu col fornidor de servicios ensin filos pa consiguir otra.</string>
     <string name="lockscreen_transport_prev_description">Pista anterior</string>
     <string name="lockscreen_transport_next_description">Pista siguiente</string>
     <string name="lockscreen_transport_pause_description">Posar</string>
@@ -959,7 +1169,10 @@
     <string name="lockscreen_transport_ffw_description">Avance rápidu</string>
     <string name="emergency_calls_only" msgid="2485604591272668370">Namás llamaes d\'emerxencia</string>
     <string name="lockscreen_network_locked_message">Rede bloquiada</string>
+    <string name="lockscreen_sim_puk_locked_message">La SIM ta bloquiada col PUK.</string>
     <string name="lockscreen_sim_puk_locked_instructions">Mira la Guía del Usuariu o ponte en contautu con Atención al Veceru.</string>
+    <string name="lockscreen_sim_locked_message">La SIM ta bloquiada.</string>
+    <string name="lockscreen_sim_unlock_progress_dialog_message">Desbloquiando la SIM\u2026</string>
     <string name="lockscreen_too_many_failed_attempts_dialog_message">        Dibuxesti incorreutamente\'l patrón de desbloquéu <xliff:g id="number">%1$d</xliff:g> vegaes.
         \n\nVolvi tentalo en <xliff:g id="number">%2$d</xliff:g> segundos.
     </string>
@@ -1075,6 +1288,7 @@
     <string name="permlab_addVoicemail">amiestu de mensaxes nel buzón de voz</string>
     <string name="permdesc_addVoicemail">Permite que l\'aplicación amieste
       mensaxes al buzón de voz.</string>
+    <string name="pasted_from_clipboard">«<xliff:g id="pasting_app_name" example="Gmail">%1$s</xliff:g>» apegó\'l conteníu del cartafueyu</string>
     <string name="more_item_label">Más</string>
     <string name="prepend_shortcut_label">Menú+</string>
     <string name="menu_meta_shortcut_label">Meta+</string>
@@ -1102,6 +1316,10 @@
        deu o facer xestos pa interactuar col teléfonu.</string>
     <string name="oneMonthDurationPast">Hai un mes</string>
     <string name="beforeOneMonthDurationPast">Hai más d\'un mes</string>
+    <string name="last_num_days">{ count, plural,
+        one {}=1 {L\'últimu día (#)}
+        other {Los # últimos díes}
+    }</string>
     <string name="last_month">El mes pasáu</string>
     <string name="older">Anterior</string>
     <string name="preposition_for_date">el <xliff:g id="date" example="May 29">%s</xliff:g></string>
@@ -1120,6 +1338,62 @@
     <string name="year">añu</string>
     <string name="years">años</string>
     <string name="now_string_shortest">agora</string>
+    <string name="duration_minutes_shortest">        <xliff:g id="count">%d</xliff:g>m
+    </string>
+    <string name="duration_hours_shortest">        <xliff:g id="count">%d</xliff:g>h
+    </string>
+    <string name="duration_days_shortest">       <xliff:g id="count">%d</xliff:g>d
+    </string>
+    <string name="duration_years_shortest">        <xliff:g id="count">%d</xliff:g>a
+    </string>
+    <string name="duration_minutes_shortest_future">        en <xliff:g id="count">%d</xliff:g>m
+    </string>
+    <string name="duration_hours_shortest_future">        en <xliff:g id="count">%d</xliff:g>h
+    </string>
+    <string name="duration_days_shortest_future">        en <xliff:g example="1" id="count">%d</xliff:g>d
+    </string>
+    <string name="duration_years_shortest_future">        en <xliff:g id="count">%d</xliff:g>a
+    </string>
+    <string name="duration_minutes_relative">{count, plural,
+        one {}=1 {Hai # minutu}
+        other {Hai # minutos}
+    }
+    </string>
+    <string name="duration_hours_relative">{count, plural,
+        one {}=1 {Hai # hora}
+        other {Hai # hores}
+    }
+    </string>
+    <string name="duration_days_relative">{count, plural,
+        one {}=1 {Hai # día}
+        other {Hai # díes}
+    }
+    </string>
+    <string name="duration_years_relative">{count, plural,
+        one {}=1 {Hai # añu}
+        other {Hai # años}
+    }
+    </string>
+    <string name="duration_minutes_relative_future">{count, plural,
+        one {}=1 {# minutu}
+        other {# minutos}
+    }
+    </string>
+    <string name="duration_hours_relative_future">{count, plural,
+        one {}=1 {# hora}
+        other {# hores}
+    }
+    </string>
+    <string name="duration_days_relative_future">{count, plural,
+        one {}=1 {# día}
+        other {# díes}
+    }
+    </string>
+    <string name="duration_years_relative_future">{count, plural,
+        one {}=1 {# añu}
+        other {# años}
+    }
+    </string>
     <string name="VideoView_error_title">Hai un problema col videu</string>
     <string name="VideoView_error_text_invalid_progressive_playback">Esti videu nun val pa la tresmisión al preséu.</string>
     <string name="VideoView_error_text_unknown">Nun se pue reproducir esti videu.</string>
@@ -1150,6 +1424,7 @@
     <string name="inputMethod">Métodu d\'entrada</string>
     <string name="editTextMenuTitle">Aiciones del testu</string>
     <string name="input_method_nav_back_button_desc">Atrás</string>
+    <string name="input_method_ime_switch_button_desc">Cambiar el métodu d\'introducción de testu</string>
     <string name="low_internal_storage_view_title">L\'espaciu d\'almacenamientu ta escosando</string>
     <string name="low_internal_storage_view_text">Quiciabes dalgunes funciones del sistema nun funcionen</string>
     <string name="low_internal_storage_view_text_no_boot">Nun hai abondu almacenamientu pal sistema. Asegúrate de que tienes 250 MB d\'espaciu llibre y reanicia.</string>
@@ -1167,6 +1442,14 @@
     <string name="capital_off">NON</string>
     <string name="checked">marcóse</string>
     <string name="not_checked">nun se marcó</string>
+    <string name="selected">seleicionóse</string>
+    <string name="not_selected">nun se seleicionó</string>
+    <string name="rating_label">{ rating, plural,
+        one {}=1 {# estrella de {max}}
+        other {# estrelles de {max}}
+    }
+    </string>
+    <string name="in_progress">en cursu</string>
     <string name="whichApplication">Completar l\'aición con</string>
     <string name="whichApplicationNamed">Completar l\'aición con «%1$s»</string>
     <string name="whichApplicationLabel">Completar l\'aición</string>
@@ -1245,7 +1528,12 @@
     <string name="android_preparing_apk">Tresnando «<xliff:g id="appname">%1$s</xliff:g>».</string>
     <string name="android_upgrading_starting_apps">Aniciando les aplicaciones.</string>
     <string name="android_upgrading_complete">Finando l\'arrinque.</string>
+    <string name="fp_power_button_enrollment_message">Primiesti\'l botón de prendíu, aición que suel apagar la pantalla.\n\nPrueba a tocalu llixeramente mentanto configures la buelga.</string>
+    <string name="fp_power_button_enrollment_title">Pa finar, apaga la pantalla</string>
     <string name="fp_power_button_enrollment_button_text">Desactivar</string>
+    <string name="fp_power_button_bp_title">¿Quies siguir verificando la buelga?</string>
+    <string name="fp_power_button_bp_message">Primiesti\'l botón de prendíu, aición que suel apagar la pantalla.\n\nPrueba a tocalu llixeramente pa verificar la to buelga.</string>
+    <string name="fp_power_button_bp_positive_button">Apagar la pantalla</string>
     <string name="fp_power_button_bp_negative_button">Siguir</string>
     <string name="heavy_weight_notification">«<xliff:g id="app">%1$s</xliff:g>» ta n\'execución</string>
     <string name="heavy_weight_notification_detail">Toca pa volver al xuegu</string>
@@ -1336,7 +1624,10 @@
     <string name="sms_short_code_remember_undo_instruction">Camúdalo dempués n\'Axustes\u00A0&gt;\u00A0Aplicaciones</string>
     <string name="sms_short_code_confirm_always_allow">Permitir siempres</string>
     <string name="sms_short_code_confirm_never_allow">Nun permitir enxamás</string>
+    <string name="sim_removed_title">Estráxose una SIM</string>
+    <string name="sim_removed_message">La rede móvil nun va tar disponible hasta que reanicies el preséu con una SIM válida.</string>
     <string name="sim_done_button">Fecho</string>
+    <string name="sim_added_title">Amestóse una SIM</string>
     <string name="sim_added_message">Reanicia\'l preséu p\'acceder a la rede móvil.</string>
     <string name="sim_restart_button">Reaniciar</string>
     <string name="install_carrier_app_notification_title">Activación del serviciu móvil</string>
@@ -1360,6 +1651,7 @@
     <string name="usb_ptp_notification_title">Activóse\'l mou PTP per USB</string>
     <string name="usb_tether_notification_title">Activóse\'l tethering per USB</string>
     <string name="usb_midi_notification_title">Activóse\'l mou MIDI per USB</string>
+    <string name="usb_uvc_notification_title">El preséu conectóse como una cámara web</string>
     <string name="usb_accessory_notification_title">Conectóse un accesoriu USB</string>
     <string name="usb_notification_message">Toca pa ver más opciones.</string>
     <string name="usb_power_notification_message">El preséu conectáu ta en carga. Toca pa ver más opciones.</string>
@@ -1375,6 +1667,8 @@
     <string name="test_harness_mode_notification_message">Reafita\'l preséu pa desactivar el mou «Prueba Harness».</string>
     <string name="console_running_notification_title">Consola de serie activada</string>
     <string name="console_running_notification_message">El rindimientu ta afeutáu. Pa desactivar esta función, comprueba\'l cargador d\'arrinque.</string>
+    <string name="mte_override_notification_title">Activóse\'l MTE esperimental</string>
+    <string name="mte_override_notification_message">El rindimientu y la estabilidá puen vese afeutaos. Reanicia pa desactivar esta estensión. Si s\'activó con arm64.memtag.bootctl, afítala primero a «none».</string>
     <string name="usb_contaminant_detected_title">Hai líquidu o porquería nel puertu USB</string>
     <string name="usb_contaminant_detected_message">El puertu USB inhabilitóse automáticamente. Toca pa saber más.</string>
     <string name="usb_contaminant_not_detected_title">Yá se pue usar el puertu USB</string>
@@ -1389,6 +1683,9 @@
     <string name="decline_remote_bugreport_action">REFUGAR</string>
     <string name="select_input_method">Escoyeta d\'un métodu d\'entrada</string>
     <string name="show_ime">Caltiénse na pantalla mentanto\'l tecláu físicu ta activu</string>
+    <string name="hardware">Usar el tecláu en pantalla</string>
+    <string name="select_keyboard_layout_notification_title">Configura «<xliff:g id="device_name" example="Foobar USB Keyboard">%s</xliff:g>»</string>
+    <string name="select_multiple_keyboards_layout_notification_title">Configura los teclaos físicos</string>
     <string name="select_keyboard_layout_notification_message">Toca pa esbillar la llingua y la distribución</string>
     <string name="fast_scroll_alphabet">\u0020ABCDEFGHḤIJKLḶMNÑOPQRSTUVWXYZ</string>
     <string name="fast_scroll_numeric_alphabet">\u00200123456789ABCDEFGHḤIJKLḶMNÑOPQRSTUVWXYZ</string>
@@ -1399,15 +1696,24 @@
     <string name="alert_windows_notification_turn_off_action">Desactivar</string>
     <string name="ext_media_checking_notification_title">Comprobando\'l mediu «<xliff:g id="name" example="SD card">%s</xliff:g>»\u2026</string>
     <string name="ext_media_checking_notification_message">Revisando\'l conteníu actual</string>
+    <string name="ext_media_checking_notification_message" product="tv">Analizando l\'almacenamientu del mediu</string>
     <string name="ext_media_new_notification_title">Mediu nuevu «<xliff:g id="name" example="SD card">%s</xliff:g>»</string>
     <string name="ext_media_new_notification_title" product="automotive">«<xliff:g id="name" example="SD card">%s</xliff:g>» nun funciona</string>
     <string name="ext_media_new_notification_message">Toca pa configurar</string>
+    <string name="ext_media_new_notification_message" product="tv">Toca pa configurar</string>
     <string name="ext_media_new_notification_message" product="automotive">Quiciabes tengas de volver formatiar el preséu. Toca pa espulsalu.</string>
+    <string name="ext_media_ready_notification_message">P\'atroxar semeyes, vídeos, música y más</string>
+    <string name="ext_media_ready_notification_message" product="tv">Restola los ficheros multimedia</string>
     <string name="ext_media_unmountable_notification_title">Hai problemes con «<xliff:g id="name" example="SD card">%s</xliff:g>»</string>
     <string name="ext_media_unmountable_notification_title" product="automotive">«<xliff:g id="name" example="SD card">%s</xliff:g>» nun funciona</string>
     <string name="ext_media_unmountable_notification_message">Toca pa igualu</string>
     <string name="ext_media_unmountable_notification_message" product="tv">El mediu «<xliff:g id="name" example="SD card">%s</xliff:g>» ta toyíu. Esbilla esti avisu pa igualu.</string>
     <string name="ext_media_unmountable_notification_message" product="automotive">Quiciabes tengas de volver formatiar el preséu. Toca pa espulsalu.</string>
+    <string name="ext_media_unsupported_notification_title">Detectóse\'l mediu «<xliff:g id="name" example="SD card">%s</xliff:g>»</string>
+    <string name="ext_media_unsupported_notification_title" product="automotive">«<xliff:g id="name" example="SD card">%s</xliff:g>» nun funciona</string>
+    <string name="ext_media_unsupported_notification_message">Toca pa configuralu.</string>
+    <string name="ext_media_unsupported_notification_message" product="tv">Seleiciona pa configurar «<xliff:g id="name" example="SD card">%s</xliff:g>» nun formatu compatible.</string>
+    <string name="ext_media_unsupported_notification_message" product="automotive">Quiciabes tengas de volver formatiar el preséu</string>
     <string name="ext_media_badremoval_notification_title">«<xliff:g id="name" example="SD card">%s</xliff:g>» estráxose inesperadamente</string>
     <string name="ext_media_badremoval_notification_message">Espulsa\'l mediu enantes d\'estrayelu pa evitar la perda del conteníu</string>
     <string name="ext_media_nomedia_notification_title">Estráxose\'l mediu «<xliff:g id="name" example="SD card">%s</xliff:g>»</string>
@@ -1501,6 +1807,11 @@
     <string name="skip_button_label">Saltar</string>
     <string name="no_matches">Nun hai coincidencies</string>
     <string name="find_on_page">Atopar na páxina</string>
+    <string name="matches_found">{ count, plural,
+        one {}=1 {# coincidencia}
+        other {# de {total}}
+    }
+    </string>
     <string name="action_mode_done">Fecho</string>
     <string name="progress_erasing">Desaniciando l\'almacenamientu compartíu\u2026</string>
     <string name="share">Compartir</string>
@@ -1600,13 +1911,16 @@
     <string name="activity_resolver_use_always">Siempres</string>
     <string name="activity_resolver_use_once">Namás una vegada</string>
     <string name="activity_resolver_work_profiles_support">«%1$s» nun ye compatible col perfil llaboral</string>
+    <string name="default_audio_route_id">default_audio_route</string>
     <string name="default_audio_route_name" product="tablet">Tableta</string>
     <string name="default_audio_route_name" product="tv">TV</string>
     <string name="default_audio_route_name" product="default">Teléfonu</string>
     <string name="default_audio_route_name_dock_speakers">Altavoces de la base</string>
+    <string name="default_audio_route_name_external_device">Preséu esternu</string>
     <string name="default_audio_route_name_headphones">Auriculares</string>
     <string name="default_audio_route_name_usb">USB</string>
     <string name="default_audio_route_category_name">Sistema</string>
+    <string name="bluetooth_a2dp_audio_route_id">bluetooth_a2dp_audio_route</string>
     <string name="bluetooth_a2dp_audio_route_name">Audiu per Bluetooth</string>
     <string name="wireless_display_route_description">Pantalla ensin filos</string>
     <string name="media_route_button_content_description">Tresmitir</string>
@@ -1636,6 +1950,7 @@
     <string name="kg_puk_enter_puk_hint">La tarxeta SIM ta inhabilitada. Introduz el códigu PUK pa siguir. Ponte en contautu cola operadora pa consiguir más información.</string>
     <string name="kg_puk_enter_pin_hint">Introduz el códigu PIN deseáu</string>
     <string name="kg_enter_confirm_pin_hint">Confirma\'l códigu PIN deseáu</string>
+    <string name="kg_sim_unlock_progress_dialog_message">Desbloquiando la SIM\u2026</string>
     <string name="kg_password_wrong_pin_code">El códigu PIN ye incorreutu.</string>
     <string name="kg_invalid_sim_pin_hint">Teclexa un PIN que seya de 4 a 8 númberos.</string>
     <string name="kg_invalid_sim_puk_hint">El códigu PUK ha ser de 8 númberos.</string>
@@ -1698,13 +2013,19 @@
     <string name="kg_reordering_delete_drop_target_text">Quitar</string>
     <string name="safe_media_volume_warning" product="default">       ¿Quies xubir el volume penriba del nivel aconseyáu?\n\nSentir l\'audiu a volume altu demientres munchu tiempu pue dañar l\'audición.
     </string>
+    <string name="csd_dose_reached_warning" product="default">        \"¿Quies siguir escuchando a un volume eleváu?\n\nEl volume de los auriculares tuvo altu más tiempu del aconseyáu, lo que pue dañar l\'audición.\"
+    </string>
+    <string name="csd_momentary_exposure_warning" product="default">        \"Detectóse un soníu fuerte\n\nEl volume de los auriculares tuvo más altu de lo aconseyao, lo que pue dañar l\'audición.\"
+    </string>
     <string name="accessibility_shortcut_warning_dialog_title">¿Quies usar l\'atayu «Accesibilidá»?</string>
     <string name="accessibility_shortcut_toogle_warning">        Cuando l\'atayu ta activáu, primi los botones del volume demientres 3 segundos
-        p\'aniciar una carauterística de privacidá.
+        p\'aniciar una función de privacidá.
     </string>
-    <string name="accessibility_shortcut_multiple_service_warning">Tener primíes les tecles del volume demientres unos segundos activa les carauterístiques d\'accesibilidá. Esto pue camuda cómo funciona\'l preséu.\n\nCarauterístiques actuales:\n<xliff:g id="service" example="TalkBack">%1$s</xliff:g>\nPues camudar les carauterístiques esbillaes n\'Axustes &gt; Accesibilidá.</string>
-    <string name="accessibility_shortcut_multiple_service_list">\u0020• <xliff:g id="service" example="TalkBack">%1$s</xliff:g>\n</string>
-    <string name="accessibility_shortcut_single_service_warning">Tener primíes les tecles del volume demientres unos segundos activa «<xliff:g id="service" example="TalkBack">%1$s</xliff:g>,» una carauterística d\'accesibilidá. Esto pue camudar cómo funciona\'l preséu.\n\nPues camudar la carauterística d\'esti atayu n\'Axustes &gt; Accesibilidá.</string>
+    <string name="accessibility_shortcut_multiple_service_warning_title">¿Quies activar l\'atayu de les funciones d\'accesibilidá?</string>
+    <string name="accessibility_shortcut_multiple_service_warning">Tener primíes les tecles del volume demientres unos segundos activa les funciones d\'accesibilidá. Esto pue camuda cómo funciona\'l preséu.\n\nfunciones actuales:\n<xliff:g id="service" example="TalkBack">%1$s</xliff:g>\nPues camudar les funciones esbillaes n\'Axustes &gt; Accesibilidá.</string>
+    <string name="accessibility_shortcut_multiple_service_list">\t• <xliff:g id="service" example="TalkBack">%1$s</xliff:g>\n</string>
+    <string name="accessibility_shortcut_single_service_warning_title">¿Quies activar l\'atayu «<xliff:g id="service" example="TalkBack">%1$s</xliff:g>»?</string>
+    <string name="accessibility_shortcut_single_service_warning">Tener primíes les tecles del volume demientres unos segundos activa «<xliff:g id="service" example="TalkBack">%1$s</xliff:g>,» una función d\'accesibilidá. Esto pue camudar cómo funciona\'l preséu.\n\nPues camudar la función d\'esti atayu n\'Axustes &gt; Accesibilidá.</string>
     <string name="accessibility_shortcut_on">Activar</string>
     <string name="accessibility_shortcut_off">Nun activar</string>
     <string name="accessibility_shortcut_menu_item_status_on">SÍ</string>
@@ -1725,11 +2046,11 @@
     </string>
     <string name="accessibility_dialog_button_allow">Permitir</string>
     <string name="accessibility_dialog_button_deny">Negar</string>
-    <string name="accessibility_select_shortcut_menu_title">Toca una carauterística pa comenzar a usala:</string>
-    <string name="accessibility_edit_shortcut_menu_button_title">Escueyi qué carauterístiques usar
+    <string name="accessibility_select_shortcut_menu_title">Toca una función pa comenzar a usala:</string>
+    <string name="accessibility_edit_shortcut_menu_button_title">Escueyi qué funciones usar
         col botón «Accesibilidá»
     </string>
-    <string name="accessibility_edit_shortcut_menu_volume_title">Escueyi qué carauterístiques usar
+    <string name="accessibility_edit_shortcut_menu_volume_title">Escueyi qué funciones usar
         col atayu de les tecles del volume
     </string>
     <string name="accessibility_uncheck_legacy_item_warning">        «<xliff:g id="service_name" example="TalkBack">%s</xliff:g>» desactivóse</string>
@@ -1737,19 +2058,26 @@
     <string name="done_accessibility_shortcut_menu_button">Fecho</string>
     <string name="disable_accessibility_shortcut">Desactivar l\'atayu</string>
     <string name="leave_accessibility_shortcut_on">Usar l\'atayu</string>
+    <string name="color_inversion_feature_name">Inversión de colores</string>
+    <string name="color_correction_feature_name">Correición del color</string>
+    <string name="one_handed_mode_feature_name">Mou d\'una mano</string>
+    <string name="reduce_bright_colors_feature_name">Escurecimientu adicional</string>
+    <string name="hearing_aids_feature_name">Audífonos</string>
     <string name="accessibility_shortcut_enabling_service">Tuviéronse primíes les tecles del volume. Activóse «<xliff:g id="service_name" example="TalkBack">%1$s</xliff:g>».</string>
     <string name="accessibility_shortcut_disabling_service">Tuviéronse primíes les tecles del volume. Desactivóse «<xliff:g id="service_name" example="TalkBack">%1$s</xliff:g>».</string>
-    <string name="accessibility_button_prompt_text">Escueyi la carauterística que va usase cuando toques el botón d\'accesibilidá:</string>
-    <string name="accessibility_gesture_prompt_text">Escueyi la carauterística que va usase pal xestu d\'accesibilidá (esliza dende lo baxero a lo cimero de la pantalla con dos deos):</string>
-    <string name="accessibility_gesture_3finger_prompt_text">Escueyi la carauterística que va usase pal xestu d\'accesibilidá (esliza dende lo baxero a lo cimero de la pantalla con trés deos):</string>
-    <string name="accessibility_button_instructional_text">Pa cambiar de carauterístiques, ten primíu\'l botón d\'accesibilidá.</string>
-    <string name="accessibility_gesture_instructional_text">Pa cambiar de carauterístiques, esliza p\'arriba con dos deos y ten primida la pantalla.</string>
-    <string name="accessibility_gesture_3finger_instructional_text">Pa cambiar de carauterístiques, esliza p\'arriba con trés deos y ten primida la pantalla.</string>
+    <string name="accessibility_shortcut_spoken_feedback">Suelta los botones del volume. P\'activar el serviciu «<xliff:g id="service_name" example="TalkBack">%1$s</xliff:g>», volvi tener primíos los dos botones del volume demientres 3 segundos.</string>
+    <string name="accessibility_button_prompt_text">Escueyi la función que va usase cuando toques el botón d\'accesibilidá:</string>
+    <string name="accessibility_gesture_prompt_text">Escueyi la función que va usase pal xestu d\'accesibilidá (esliza dende lo baxero a lo cimero de la pantalla con dos deos):</string>
+    <string name="accessibility_gesture_3finger_prompt_text">Escueyi la función que va usase pal xestu d\'accesibilidá (esliza dende lo baxero a lo cimero de la pantalla con trés deos):</string>
+    <string name="accessibility_button_instructional_text">Pa cambiar de función, ten primíu\'l botón d\'accesibilidá.</string>
+    <string name="accessibility_gesture_instructional_text">Pa cambiar de función, esliza p\'arriba con dos deos y ten primida la pantalla.</string>
+    <string name="accessibility_gesture_3finger_instructional_text">Pa cambiar de función, esliza p\'arriba con trés deos y ten primida la pantalla.</string>
     <string name="accessibility_magnification_chooser_text">Aumentu</string>
     <string name="user_switched">Usuariu actual: <xliff:g id="name" example="Bob">%1$s</xliff:g>.</string>
     <string name="user_switching_message">Cambiando a «<xliff:g id="name" example="Bob">%1$s</xliff:g>»\u2026</string>
     <string name="user_logging_out_message">Zarrando la sesión de «<xliff:g id="name" example="Bob">%1$s</xliff:g>»\u2026</string>
     <string name="owner_name" msgid="3879126011135546571">Propietariu</string>
+    <string name="guest_name">Convidáu</string>
     <string name="error_message_title">Fallu</string>
     <string name="error_message_change_not_allowed">L\'alministrador nun permite esti cambéu</string>
     <string name="app_not_found">Nun s\'atopó nenguna aplicación pa remanar esta aición</string>
@@ -1868,6 +2196,8 @@
     <string name="immersive_cling_title">Vista a pantalla completa</string>
     <string name="immersive_cling_description">Pa colar, esliza dende lo baxero hasta lo cimero.</string>
     <string name="immersive_cling_positive">Entendílo</string>
+    <string name="display_rotation_camera_compat_toast_after_rotation">Voltia la pantalla p\'ameyorar la visualización</string>
+    <string name="display_rotation_camera_compat_toast_in_multi_window">Abri «<xliff:g id="name" example="MyApp">%s</xliff:g>» a pantalla completa p\'ameyorar la visualización</string>
     <string name="done_label">Fecho</string>
     <string name="hour_picker_description">Control circular de les hores</string>
     <string name="minute_picker_description">Control circular de los minutos</string>
@@ -1879,6 +2209,7 @@
     <string name="managed_profile_label_badge">«<xliff:g id="label" example="Email">%1$s</xliff:g>» del trabayu</string>
     <string name="managed_profile_label_badge_2">2u «<xliff:g id="label" example="Email">%1$s</xliff:g>» del trabayu</string>
     <string name="managed_profile_label_badge_3">3r «<xliff:g id="label" example="Email">%1$s</xliff:g>» del trabayu</string>
+    <string name="clone_profile_label_badge">Clon de: <xliff:g id="label" example="Messenger">%1$s</xliff:g></string>
     <string name="time_placeholder">--</string>
     <string name="radial_numbers_typeface">sans-serif</string>
     <string name="sans_serif">sans-serif</string>
@@ -1892,11 +2223,52 @@
     <string name="package_updated_device_owner">L\'alministrador anovó l\'aplicación</string>
     <string name="package_deleted_device_owner">L\'alministrador desanició l\'aplicación</string>
     <string name="confirm_battery_saver">OK</string>
-    <string name="battery_saver_description_with_learn_more">L\'aforrador d\'enerxía activa l\'estilu escuru y torga l\'actividá en segundu planu, dalgunos efeutos visuales, otres funciones y dalgunes conexones a la rede.</string>
-    <string name="battery_saver_description">L\'aforrador d\'enerxía activa l\'estilu escuru y torga l\'actividá en segundu planu, dalgunos efeutos visuales, otres funciones y dalgunes conexones a la rede.</string>
-    <string name="data_saver_description">P\'ayudar a amenorgar l\'usu de datos, «Aforrador de datos» evita que que les aplicaciones unvien y reciban datos en segundu planu. L\'aplicación que teas usando pue acceder a los datos, mas quiciabes lo faiga con menos frecuencia. Esto quier dicir, por exemplu, que les imáxenes nun van amosase hasta que calques nelles.</string>
+    <string name="battery_saver_description_with_learn_more">L\'aforrador d\'enerxía activa l\'estilu escuru ya torga l\'actividá en segundu planu, dalgunos efeutos visuales, determinaes funciones ya dalgunes conexones a la rede.</string>
+    <string name="battery_saver_description">L\'aforrador d\'enerxía activa l\'estilu escuru ya torga l\'actividá en segundu planu, dalgunos efeutos visuales, determinaes funciones ya dalgunes conexones a la rede.</string>
+    <string name="data_saver_description">P\'ayudar a amenorgar l\'usu de datos, «Aforrador de datos» evita que les aplicaciones unvien y reciban datos en segundu planu. L\'aplicación que teas usando pue acceder a los datos, mas quiciabes lo faiga con menos frecuencia. Esto quier dicir, por exemplu, que les imáxenes nun van amosase hasta que calques nelles.</string>
     <string name="data_saver_enable_title">¿Quies activar «Aforrador de datos»?</string>
     <string name="data_saver_enable_button">Activar</string>
+    <string name="zen_mode_duration_minutes_summary">{count, plural,
+        one {}=1    {Demientres # minutu (hasta: {formattedTime})}
+        other {Demientres # minutos (hasta: {formattedTime})}
+    }
+    </string>
+    <string name="zen_mode_duration_minutes_summary_short">{count, plural,
+        one {}=1    {Demientres # min (hasta: {formattedTime})}
+        other {Demientres # min (hasta: {formattedTime})}
+    }
+    </string>
+    <string name="zen_mode_duration_hours_summary">{count, plural,
+        one {}=1    {Demientres # hora (hasta: {formattedTime})}
+        other {Demientres # hores (hasta: {formattedTime})}
+    }
+    </string>
+    <string name="zen_mode_duration_hours_summary_short">{count, plural,
+        one {}=1    {Demientres 1 h (hasta: {formattedTime})}
+        other {Demientres 1 h (hasta: {formattedTime})}
+    }
+    </string>
+    <string name="zen_mode_duration_minutes">{count, plural,
+        one {}=1    {Demientres # minutu}
+        other {Demientres # minutos}
+    }
+    </string>
+    <string name="zen_mode_duration_minutes_short">{count, plural,
+        one {}=1    {Demientres # min}
+        other {Demientres # min}
+    }
+    </string>
+    <string name="zen_mode_duration_hours">{count, plural,
+        one {}=1    {Demientres # hora}
+        other {Demientres # hores}
+    }
+    </string>
+    <string name="zen_mode_duration_hours_short">{count, plural,
+        one {}=1    {Demientres # h}
+        other {Demientres # h}
+    }
+    </string>
+    <string name="zen_mode_until_next_day">Hasta: <xliff:g id="formattedTime" example="Tue, 10 PM">%1$s</xliff:g></string>
     <string name="zen_mode_until">Hasta: <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g></string>
     <string name="zen_mode_alarm">Hasta: <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g> (alarma siguiente)</string>
     <string name="zen_mode_forever">Hasta desactivar esta opción</string>
@@ -1909,6 +2281,7 @@
     <string name="zen_mode_default_weekends_name">Fin de selmana</string>
     <string name="zen_mode_default_events_name">Eventu</string>
     <string name="zen_mode_default_every_night_name">Dormiendo</string>
+    <string name="zen_mode_implicit_deactivated">Desactivaes</string>
     <string name="muted_by">«<xliff:g id="third_party">%1$s</xliff:g>» ta desactivando dalgunos soníos</string>
     <string name="system_error_wipe_data">Hai un problema internu col preséu y pue que funcione de forma inestable hasta que lu reafites.</string>
     <string name="system_error_manufacturer">Hai un problema internu col preséu. Ponte en contautu col fabricante pa consiguir más información.</string>
@@ -1920,8 +2293,10 @@
     <string name="stk_cc_ss_to_dial_video">La solicitú SS camudó a una videollamada</string>
     <string name="stk_cc_ss_to_ussd">La solicitú SS camudó a una solicitú USSD</string>
     <string name="stk_cc_ss_to_ss">Camudó a una solicitú SS nueva</string>
+    <string name="notification_phishing_alert_content_description">Alerta de phishing</string>
     <string name="notification_work_profile_content_description">Perfil llaboral</string>
     <string name="notification_alerted_content_description">Alertóse</string>
+    <string name="notification_verified_content_description">Verificóse</string>
     <string name="expand_button_content_description_collapsed">Espander</string>
     <string name="expand_button_content_description_expanded">Contrayer</string>
     <string name="expand_action_accessibility">alternar la espansión</string>
@@ -1934,19 +2309,27 @@
     <string name="close_button_text">Zarrar</string>
     <string name="notification_inbox_ellipsis">\u2026</string>
     <string name="notification_messaging_title_template"><xliff:g id="conversation_title" example="Tasty Treat Team">%1$s</xliff:g>: <xliff:g id="sender_name" example="Adrian Baker">%2$s</xliff:g></string>
+    <string name="call_notification_answer_action">Contestar</string>
     <string name="call_notification_answer_video_action">Videu</string>
     <string name="call_notification_decline_action">Refugar</string>
+    <string name="call_notification_hang_up_action">Colgar</string>
+    <string name="call_notification_incoming_text">Llamada entrante</string>
+    <string name="call_notification_ongoing_text">Llamada en cursu</string>
+    <string name="call_notification_screening_text">Filtrando una llamada entrante</string>
     <string name="default_notification_channel_label">Ensin estaya</string>
     <string name="importance_from_user">Afitesti la importancia d\'estos avisos.</string>
     <string name="importance_from_person">Ye importante pola mor de les persones implicaes.</string>
     <string name="notification_history_title_placeholder">Avisu d\'aplicación personalizáu</string>
     <string name="user_creation_account_exists">¿Quies permitir que «<xliff:g id="app" example="Gmail">%1$s</xliff:g>» cree un usuariu con «<xliff:g id="account" example="foobar@gmail.com">%2$s</xliff:g>»? (Yá esiste un usuariu con esta cuenta)</string>
     <string name="user_creation_adding">¿Quies permitir que «<xliff:g id="app" example="Gmail">%1$s</xliff:g>» cree un usuariu con «<xliff:g id="account" example="foobar@gmail.com">%2$s</xliff:g>»?</string>
+    <string name="supervised_user_creation_label">Amestar un usuariu supervisáu</string>
     <string name="language_selection_title">Amiestu d\'una llingua</string>
     <string name="country_selection_title">Preferencia rexonal</string>
     <string name="search_language_hint">Nome de la llingua</string>
     <string name="language_picker_section_suggested">Suxerse</string>
     <string name="language_picker_regions_section_suggested">Suxerse</string>
+    <string name="language_picker_section_suggested_bilingual">Llingües suxeríes</string>
+    <string name="region_picker_section_suggested_bilingual">Rexones suxeríes</string>
     <string name="language_picker_section_all">Toles llingües</string>
     <string name="region_picker_section_all">Toles rexones</string>
     <string name="locale_search_menu">Buscar</string>
@@ -1955,11 +2338,32 @@
     </string>
     <string name="app_suspended_more_details">Saber más</string>
     <string name="app_suspended_unsuspend_message">Anular la posa</string>
+    <string name="work_mode_off_title">¿Reactivar apls. llaborales?</string>
+    <string name="work_mode_turn_on">Volver activar</string>
     <string name="work_mode_emergency_call_button">Emerxencia</string>
     <string name="app_blocked_title">L\'aplicación nun ta disponible</string>
     <string name="app_blocked_message">        Nesti momentu, «<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>» nun ta disponible.
     </string>
+    <string name="app_streaming_blocked_title">«<xliff:g id="activity" example="Permission dialog">%1$s</xliff:g>» nun ta disponible</string>
+    <string name="app_streaming_blocked_title_for_camera_dialog">La cámara nun ta disponible</string>
+    <string name="app_streaming_blocked_title_for_fingerprint_dialog">Sigue nel teléfonu</string>
+    <string name="app_streaming_blocked_title_for_microphone_dialog">El micrófonu nun ta disponible</string>
+    <string name="app_streaming_blocked_title_for_playstore_dialog">«Play Store» nun ta disponible</string>
+    <string name="app_streaming_blocked_title_for_settings_dialog" product="tv">La configuración d\'Android TV nun ta disponible</string>
+    <string name="app_streaming_blocked_title_for_settings_dialog" product="tablet">La configuración de la tableta nun ta disponible</string>
+    <string name="app_streaming_blocked_title_for_settings_dialog" product="default">La configuración del teléfonu nun ta disponible</string>
+    <string name="app_streaming_blocked_message" product="tv">Nesti momentu, nun se pue acceder a esti conteníu en: <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prueba nel preséu Android TV.</string>
+    <string name="app_streaming_blocked_message" product="tablet">Nesti momentu, nun se pue acceder a esti conteníu en: <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prueba na tableta.</string>
+    <string name="app_streaming_blocked_message" product="default">Nesti momentu, nun se pue acceder a esti conteníu en: <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prueba nel teléfonu.</string>
+    <string name="app_streaming_blocked_message_for_fingerprint_dialog" product="tv">Esta aplicación solicita más seguranza. Prueba nel preséu Android TV.</string>
+    <string name="app_streaming_blocked_message_for_fingerprint_dialog" product="tablet">Esta aplicación solicita más seguranza. Prueba na tableta.</string>
+    <string name="app_streaming_blocked_message_for_fingerprint_dialog" product="default">Esta aplicación solicita más seguranza. Prueba nel teléfonu.</string>
+    <string name="app_streaming_blocked_message_for_settings_dialog" product="tv">Esti conteníu nun se pue acceder en: <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prueba nel preséu Android TV.</string>
+    <string name="app_streaming_blocked_message_for_settings_dialog" product="tablet">Nun se pue acceder a esti conteníu en: <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prueba na tableta.</string>
+    <string name="app_streaming_blocked_message_for_settings_dialog" product="default">Nun se pue acceder a esti conteníu en: <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prueba nel teléfonu.</string>
+    <string name="deprecated_target_sdk_message">Esta aplicación compilóse pa una versión antigua d\'Android. Quiciabes nun funcione correutamente nin incluya les últimes proteiciones de seguranza y privacidá. Comprueba si tien anovamientos o ponte en contautu col desendolcador de l\'aplicación.</string>
     <string name="deprecated_target_sdk_app_store">Comprobar los anovamientos</string>
+    <string name="deprecated_abi_message">Esta aplicación nun ye compatible cola última versión d\'Android. Comprueba si tien anovamientos o ponte en contautu col desendolcador de l\'aplicación.</string>
     <string name="new_sms_notification_title">Tienes mensaxes nuevos</string>
     <string name="new_sms_notification_content">Abri l\'aplicación de SMS pa velos</string>
     <string name="profile_encrypted_title">Pue haber funciones llendaes</string>
@@ -2000,6 +2404,11 @@
     <string name="autofill_save_accessibility_title">Guardar pal autorellenu</string>
     <string name="autofill_error_cannot_autofill">El conteníu nun se pue autorellenar</string>
     <string name="autofill_picker_no_suggestions">Nun hai nenguna suxerencia del autorellenu</string>
+    <string name="autofill_picker_some_suggestions">{count, plural,
+        one {}=1    {# suxerencia de rellenu automáticu}
+        other {# suxerencies de rellenu automáticu}
+    }
+    </string>
     <string name="autofill_save_title">¿Quies guardar el conteníu en: <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
     <string name="autofill_save_title_with_type">¿Quies guardar «<xliff:g id="type" example="Credit Card">%1$s</xliff:g>» en: <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
     <string name="autofill_save_title_with_2types">¿Quies guardar «<xliff:g id="type" example="Password">%1$s</xliff:g>» y «<xliff:g id="type" example="Credit Card">%2$s</xliff:g>» en: <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
@@ -2007,7 +2416,6 @@
     <string name="autofill_update_title">¿Quies anovar el conteníu de: <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_type">¿Quies anovar «<xliff:g id="type" example="Credit Card">%1$s</xliff:g>» de: <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_2types">¿Quies anovar «<xliff:g id="type" example="Password">%1$s</xliff:g>» y «<xliff:g id="type" example="Credit Card">%2$s</xliff:g>» de: <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
-    <string name="autofill_update_title_with_3types">¿Quies anovar «<xliff:g id="type" example="Username">%1$s</xliff:g>», «<xliff:g id="type" example="Password">%2$s</xliff:g>» y «<xliff:g id="type" example="Credit Card">%3$s</xliff:g>» en: <b><xliff:g id="label" example="MyPass">%4$s</xliff:g></b>?</string>
     <string name="autofill_save_yes">Guardar</string>
     <string name="autofill_save_no">Non, gracies</string>
     <string name="autofill_save_notnow">Agora non</string>
@@ -2055,12 +2463,20 @@
     <string name="zen_upgrade_notification_visd_content">Toca pa saber más y camudar los axustes.</string>
     <string name="zen_upgrade_notification_title">«Nun molestar» camudó</string>
     <string name="zen_upgrade_notification_content">Toca pa comprobar qué se bloquió.</string>
+    <string name="review_notification_settings_title">Revisa la configuración de los avisos</string>
+    <string name="review_notification_settings_text">A partir de la versión 13 d\'Android, les aplicaciones qu\'instales precisen el permisu pa unviar avisos. Toca pa camudar esti permisu pa les aplicaciones esistentes.</string>
+    <string name="review_notification_settings_remind_me_action">Recordámelo dempués</string>
     <string name="review_notification_settings_dismiss">Escartar</string>
     <string name="notification_app_name_system">Sistema</string>
-    <string name="notification_app_name_settings">Axustes</string>
+    <string name="notification_app_name_settings">Configuración</string>
     <string name="notification_appops_camera_active">Cámara</string>
     <string name="notification_appops_microphone_active">Micrófonu</string>
     <string name="notification_appops_overlay_active">superpónse a otres aplicaciones de la pantalla</string>
+    <string name="notification_feedback_indicator">Opinar</string>
+    <string name="notification_feedback_indicator_alerted">El nivel d\'esti avisu amenorgó a «Por defeutu». Toca equí pa opinar.</string>
+    <string name="notification_feedback_indicator_silenced">El nivel d\'esti avisu amenorgó a «Silenciu». Toca equí pa opinar.</string>
+    <string name="notification_feedback_indicator_promoted">Esti avisu clasificóse con un nivel superior. Toca equí pa opinar.</string>
+    <string name="notification_feedback_indicator_demoted">Esti avisu clasificóse con un nivel inferior. Toca equí pa opinar.</string>
     <string name="nas_upgrade_notification_title">Avisos ameyoraos</string>
     <string name="nas_upgrade_notification_content">Agora los avisos ameyoraos fornen les aiciones y les rempuestes suxeríes. Los avisos adautables d\'Android yá nun son compatibles.</string>
     <string name="nas_upgrade_notification_enable_action">OK</string>
@@ -2068,11 +2484,13 @@
     <string name="nas_upgrade_notification_learn_more_action">Saber más</string>
     <string name="nas_upgrade_notification_learn_more_content">Los avisos ameyoraos trocaron los avisos adautables n\'Android 12. Esta función amuesa aiciones y rempuestes suxeríes, y organiza los avisos.\n\nLos avisos ameyoraos puen acceder al conteníu de los avisos, incluyida la información personal como\'l nome y los mensaxes de los contautos. Esta función tamién pue escartar o responder a los avisos, como les llamaes telefóniques y controlar el mou «Nun molestar».</string>
     <string name="dynamic_mode_notification_channel_name">Avisu d\'información el mou Rutina</string>
+    <string name="dynamic_mode_notification_title">Activóse l\'aforrador d\'enerxía</string>
+    <string name="dynamic_mode_notification_summary">Ta amenorgándose l\'usu de la batería p\'aumentar la so duración</string>
     <string name="battery_saver_notification_channel_name">Aforrador d\'enerxía</string>
     <string name="battery_saver_off_notification_title">Desactivóse l\'aforrador d\'enerxía</string>
-    <string name="battery_saver_charged_notification_summary" product="default">El teléfonu yá cargó abondo. Les carauterístiques yá nun tán torgaes.</string>
-    <string name="battery_saver_charged_notification_summary" product="tablet">La tableta yá cargó abondo. Les carauterístiques yá nun tán torgaes.</string>
-    <string name="battery_saver_charged_notification_summary" product="device">El preséu yá cargó abondo. Les carauterístiques yá nun tán torgaes.</string>
+    <string name="battery_saver_charged_notification_summary" product="default">El teléfonu yá cargó abondo. Les funciones yá nun tán torgaes.</string>
+    <string name="battery_saver_charged_notification_summary" product="tablet">La tableta yá cargó abondo. Les funciones yá nun tán torgaes.</string>
+    <string name="battery_saver_charged_notification_summary" product="device">El preséu yá cargó abondo. Les funciones yá nun tán torgaes.</string>
     <string name="mime_type_folder">Carpeta</string>
     <string name="mime_type_apk">Aplicación d\'Android</string>
     <string name="mime_type_generic">Ficheru</string>
@@ -2093,6 +2511,11 @@
     <string name="mime_type_presentation_ext">Presentación <xliff:g id="extension" example="PDF">%1$s</xliff:g></string>
     <string name="bluetooth_airplane_mode_toast">El Bluetooth va siguir habilitáu nel mou avión</string>
     <string name="car_loading_profile">Cargando</string>
+    <string name="file_count">{count, plural,
+        one {}=1    {{file_name} + # ficheru}
+        other {{file_name} + # ficheros}
+    }
+    </string>
     <string name="chooser_no_direct_share_targets">Nun hai nenguna persona suxerida cola que compartir</string>
     <string name="chooser_all_apps_button_label">Llista d\'aplicaciones</string>
     <string name="usb_device_resolve_prompt_warn">Esta aplicación nun tien permisu pa grabar audiu, mas podría capturalu pente esti preséu USB.</string>
@@ -2104,9 +2527,16 @@
     <string name="accessibility_system_action_power_dialog_label">Diálogu d\'apagáu</string>
     <string name="accessibility_system_action_lock_screen_label">Pantalla de bloquéu</string>
     <string name="accessibility_system_action_screenshot_label">Captura de pantalla</string>
+    <string name="accessibility_system_action_headset_hook_label">Ganchu p\'auriculares con micrófonu</string>
     <string name="accessibility_system_action_on_screen_a11y_shortcut_label">Atayos d\'accesibilidá en pantalla</string>
     <string name="accessibility_system_action_on_screen_a11y_shortcut_chooser_label">Selector d\'atayos d\'accesibilidá en pantalla</string>
     <string name="accessibility_system_action_hardware_a11y_shortcut_label">Atayu d\'accesibilidá</string>
+    <string name="accessibility_system_action_dismiss_notification_shade">Escartar l\'área d\'avisos</string>
+    <string name="accessibility_system_action_dpad_up_label">Cruceta direicional: arriba</string>
+    <string name="accessibility_system_action_dpad_down_label">Cruceta direicional: abaxo</string>
+    <string name="accessibility_system_action_dpad_left_label">Cruceta direicional: esquierda</string>
+    <string name="accessibility_system_action_dpad_right_label">Cruceta direicional: derecha</string>
+    <string name="accessibility_system_action_dpad_center_label">Cruceta direicional: centru</string>
     <string name="accessibility_freeform_caption">Barra de sotítulos de: <xliff:g id="app_name">%1$s</xliff:g>.</string>
     <string name="as_app_forced_to_restricted_bucket">        <xliff:g id="package_name" example="com.android.example">%1$s</xliff:g> incluyóse nel grupu TÓRGASE</string>
     <string name="conversation_single_line_name_display"><xliff:g id="sender_name" example="Sara">%1$s</xliff:g>:</string>
@@ -2118,12 +2548,26 @@
     <string name="resolver_work_tab">Trabayu</string>
     <string name="resolver_personal_tab_accessibility">Vista personal</string>
     <string name="resolver_work_tab_accessibility">Vista llaboral</string>
+    <string name="resolver_cross_profile_blocked">L\'alministrador de TI bloquió\'l conteníu</string>
     <string name="resolver_cant_share_with_work_apps_explanation">Esti conteníu nun se pue compartir coles aplicaciones llaborales</string>
     <string name="resolver_cant_access_work_apps_explanation">Esti conteníu nun se pue abrir coles aplicaciones llaborales</string>
     <string name="resolver_cant_share_with_personal_apps_explanation">Esti conteníu nun se pue compartir coles aplicaciones personales</string>
     <string name="resolver_cant_access_personal_apps_explanation">Esti conteníu nun se pue abrir coles aplicaciones personales</string>
+    <string name="resolver_turn_on_work_apps">Les aplicaciones llaborales tán en posa</string>
+    <string name="resolver_switch_on_work">Volver activar</string>
+    <string name="resolver_no_work_apps_available">Nun hai nenguna aplicación llaboral</string>
+    <string name="resolver_no_personal_apps_available">No personal apps</string>
+    <string name="miniresolver_open_work">¿Quies abrir l\'aplicación «<xliff:g id="app" example="YouTube">%s</xliff:g>» del perfil llaboral?</string>
+    <string name="miniresolver_open_in_personal">¿Quies abrir el conteníu na aplicación «<xliff:g id="app" example="YouTube">%s</xliff:g>» del perfil personal?</string>
+    <string name="miniresolver_open_in_work">¿Quies abrir el conteníu na aplicación «<xliff:g id="app" example="YouTube">%s</xliff:g>» del perfil llaboral?</string>
+    <string name="miniresolver_call_in_work">¿Quies llamar dende l\'aplicación llaboral?</string>
+    <string name="miniresolver_switch_to_work">¿Quies cambiar a l\'aplicación llaboral?</string>
+    <string name="miniresolver_call_information">La to organización namás te permite facer llamaes dende aplicaciones llaborales</string>
+    <string name="miniresolver_sms_information">La to organización namás te permite unviar mensaxes dende aplicaciones llaborales</string>
     <string name="miniresolver_use_personal_browser">Usar el restolador personal</string>
     <string name="miniresolver_use_work_browser">Usar el restolador llaboral</string>
+    <string name="miniresolver_call">Llamar</string>
+    <string name="miniresolver_switch">Cambiar</string>
     <string name="PERSOSUBSTATE_SIM_NETWORK_ENTRY">PIN de desbloquéu de la rede de la SIM</string>
     <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ENTRY">PIN de desbloquéu del soconxuntu de la rede de la SIM</string>
     <string name="PERSOSUBSTATE_SIM_CORPORATE_ENTRY">PIN de desbloquéu de la SIM corporativa</string>
@@ -2232,7 +2676,59 @@
     <string name="PERSOSUBSTATE_SIM_ICCID_SUCCESS">El desbloquéu del ICCID fízose correutamente.</string>
     <string name="PERSOSUBSTATE_SIM_IMPI_SUCCESS">La solicitú de desbloquéu del IMPI fízose correutamente.</string>
     <string name="PERSOSUBSTATE_SIM_NS_SP_SUCCESS">El desbloquéu del fornidor de servicios del soconxuntu de la rede fízose correutamente.</string>
+    <string name="window_magnification_prompt_title">Configuración d\'agrandamientu nueva</string>
+    <string name="window_magnification_prompt_content">Agora pues agrandar una parte de la pantalla</string>
+    <string name="turn_on_magnification_settings_action">Activar en Configuración</string>
     <string name="dismiss_action">Escartar</string>
+    <string name="sensor_privacy_start_use_mic_notification_content_title">Desbloquia\'l micrófonu de la cámara</string>
+    <string name="sensor_privacy_start_use_camera_notification_content_title">Desbloquia la cámara del preséu</string>
+    <string name="sensor_privacy_start_use_notification_content_text">Pa &lt;b&gt;<xliff:g id="app" example="Gmail">%s</xliff:g>&lt;/b&gt; ya pa toles aplicaciones ya tolos servicios</string>
     <string name="sensor_privacy_start_use_dialog_turn_on_button">Desbloquiar</string>
+    <string name="sensor_privacy_notification_channel_label">Privacidá de los sensores</string>
+    <string name="splash_screen_view_icon_description">Iconu de l\'aplicación</string>
+    <string name="splash_screen_view_branding_description">Imaxe de la marca de l\'aplicación</string>
+    <string name="view_and_control_notification_title">Comprueba la configuración d\'accesu</string>
+    <string name="view_and_control_notification_content">«<xliff:g id="service_name" example="TalkBack">%s</xliff:g>» pue ver y controlar la pantalla. Toca equí pa revisalo.</string>
+    <string name="ui_translation_accessibility_translated_text">Tradúxose «<xliff:g id="message" example="Hello">%1$s</xliff:g>».</string>
+    <string name="ui_translation_accessibility_translation_finished">Mensaxe traducíu del «<xliff:g id="from_language" example="English">%1$s</xliff:g>» al «<xliff:g id="to_language" example="French">%2$s</xliff:g>».</string>
+    <string name="notification_channel_abusive_bg_apps">Actividá en segundu planu</string>
+    <string name="notification_title_abusive_bg_apps">Una aplicación consume muncha enerxía</string>
+    <string name="notification_title_long_running_fgs">Una aplicación sigue activa</string>
+    <string name="notification_content_abusive_bg_apps">        «<xliff:g id="app" example="Gmail">%1$s</xliff:g>» ta executándose en segundu planu. Toca pa xestionar l\'usu de la batería.</string>
+    <string name="notification_content_long_running_fgs">        Ye posible que «<xliff:g id="app" example="Gmail">%1$s</xliff:g>» afeute a la duración de la batería. Toca pa revisar les aplicaciones actives.
+    </string>
+    <string name="notification_action_check_bg_apps">Comprobar les aplicaciones actives</string>
+    <string name="vdm_camera_access_denied" product="default">Nun se pue acceder a la cámara del teléfonu dende <xliff:g id="device" example="Chromebook">%1$s</xliff:g></string>
+    <string name="vdm_camera_access_denied" product="tablet">Nun se pue acceder a la cámara de la tableta dende <xliff:g id="device" example="Chromebook">%1$s</xliff:g></string>
+    <string name="vdm_secure_window">Nun se pue acceder a esti conteníu mentanto s\'emite. Prueba nel teléfonu.</string>
+    <string name="vdm_pip_blocked">Nun se pue ver el mou «Picture-in-Picture» mentanto s\'emite</string>
+    <string name="system_locale_title">Preaxuste del sistema</string>
+    <string name="default_card_name">TARXETA <xliff:g id="cardNumber" example="1">%d</xliff:g></string>
+    <string name="permlab_companionProfileWatch">permisu del perfil de relós complementarios pa xestionar relós</string>
+    <string name="permdesc_companionProfileWatch">Permite qu\'una aplicación complementaria xestione relós.</string>
+    <string name="permlab_observeCompanionDevicePresence">deteición de la presencia de preseos complementarios</string>
+    <string name="permdesc_observeCompanionDevicePresence">Permite qu\'una aplicación complementaria detecte la presencia de preseos complementarios cuando tán cerca o lloñe.</string>
+    <string name="permlab_deliverCompanionMessages">unviu de mensaxes complementarios</string>
+    <string name="permdesc_deliverCompanionMessages">Permite qu\'una aplicación complementaria unvie mensaxes complementarios a otros preseos.</string>
+    <string name="permlab_startForegroundServicesFromBackground">aniciu de servicios en primer planu dende\'l segundu planu</string>
+    <string name="permdesc_startForegroundServicesFromBackground">Permite qu\'una aplicación complementaria anicie servicios en primer planu dende\'l segundu planu.</string>
+    <string name="mic_access_on_toast">El micrófonu ta disponible</string>
+    <string name="mic_access_off_toast">El micrófonu ta bloquiáu</string>
+    <string name="concurrent_display_notification_name">Pantalla dual</string>
+    <string name="concurrent_display_notification_active_title">La pantalla dual ta activada</string>
+    <string name="concurrent_display_notification_active_content">«<xliff:g id="app_name" example="Camera app">%1$s</xliff:g>» ta usando dambes pantalles p\'amosar el conteníu</string>
+    <string name="concurrent_display_notification_thermal_title">El preséu ta mui caliente</string>
+    <string name="concurrent_display_notification_thermal_content">La pantalla dual nun ta disponible porque\'l preséu ta mui caliente</string>
+    <string name="concurrent_display_notification_power_save_title">La pantalla dual nun ta disponible</string>
+    <string name="concurrent_display_notification_power_save_content">La pantalla dual nun ta disponible porque l\'aforrador d\'enerxía ta activáu. Pues desactivar esta función en Configuración.</string>
+    <string name="device_state_notification_settings_button">Dir a Configuración</string>
     <string name="device_state_notification_turn_off_button">Desactivar</string>
+    <string name="keyboard_layout_notification_selected_title">Configuróse «<xliff:g id="device_name" example="Foobar USB Keyboard">%s</xliff:g>»</string>
+    <string name="keyboard_layout_notification_one_selected_message">La distribución del tecláu afitóse a «<xliff:g id="layout_1" example="English (US)">%s</xliff:g>». Toca pa camudala.</string>
+    <string name="keyboard_layout_notification_two_selected_message">La distribución del tecláu afitóse a «<xliff:g id="layout_1" example="English (US)">%1$s</xliff:g>» y «<xliff:g id="layout_2" example="German">%2$s</xliff:g>». Toca pa camudala.</string>
+    <string name="keyboard_layout_notification_three_selected_message">La distribución del tecláu afitóse a «<xliff:g id="layout_1" example="English (US)">%1$s</xliff:g>», «<xliff:g id="layout_2" example="German">%2$s</xliff:g>» y «<xliff:g id="layout_3" example="French">%3$s</xliff:g>». Toca pa camudala.</string>
+    <string name="keyboard_layout_notification_more_than_three_selected_message">La distribución del tecláu afitóse a «<xliff:g id="layout_1" example="English (US)">%1$s</xliff:g>», «<xliff:g id="layout_2" example="English (US)">%2$s</xliff:g>», «<xliff:g id="layout_3" example="French">%3$s</xliff:g>». Toca pa camudala.</string>
+    <string name="keyboard_layout_notification_multiple_selected_title">Teclaos físicos configuraos</string>
+    <string name="keyboard_layout_notification_multiple_selected_message">Toca pa ver los teclaos</string>
+    <string name="profile_label_work">Trabayu</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-cy/strings.xml b/overlay/frameworks/base/core/res/res/values-cy/strings.xml
index f6fdaef..a34b9e0 100644
--- a/overlay/frameworks/base/core/res/res/values-cy/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-cy/strings.xml
@@ -2004,6 +2004,7 @@
     <string name="zen_mode_default_weekends_name">Penwythnos</string>
     <string name="zen_mode_default_events_name">Digwyddiad</string>
     <string name="zen_mode_default_every_night_name">Yn cysgu</string>
+    <string name="zen_mode_implicit_deactivated">I ffwrdd</string>
     <string name="muted_by">Mae <xliff:g id="third_party">%1$s</xliff:g> yn distewi rhai seiniau</string>
     <string name="system_error_wipe_data">Mae yna broblem fewnol gyda dy ddyfais ac mae\'n bosib y bydd yn ansefydlog oni bai dy fod yn ail-osod i fel yr oedd yn gadael y ffatri.</string>
     <string name="system_error_manufacturer">Mae yna broblem fewnol gyda dy ddyfais. Cysyllta â\'r gwneuthurwr am fanylion.</string>
@@ -2062,7 +2063,6 @@
     <string name="app_blocked_title">Ap ddim ar gael</string>
     <string name="app_blocked_message">Nid yw <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> ar gael ar hyn o bryd.</string>
     <string name="app_streaming_blocked_title"><xliff:g id="activity" example="Permission dialog">%1$s</xliff:g> ddim ar gael</string>
-    <string name="app_streaming_blocked_title_for_permission_dialog">Angen caniatâd</string>
     <string name="app_streaming_blocked_title_for_camera_dialog">Camera ddim ar gael</string>
     <string name="app_streaming_blocked_title_for_fingerprint_dialog">Parhau ar ffôn</string>
     <string name="app_streaming_blocked_title_for_microphone_dialog">Meicroffon ddim ar gael</string>
@@ -2132,7 +2132,6 @@
     <string name="autofill_update_title">Diweddaru yn <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_type">Diweddaru <xliff:g id="type" example="Credit Card">%1$s</xliff:g> yn <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_2types">Diweddaru <xliff:g id="type" example="Password">%1$s</xliff:g> a <xliff:g id="type" example="Credit Card">%2$s</xliff:g> yn <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
-    <string name="autofill_update_title_with_3types">Diweddaru\'r eitemau hyn yn <b><xliff:g id="label" example="MyPass">%4$s</xliff:g></b>: <xliff:g id="type" example="Username">%1$s</xliff:g>, <xliff:g id="type" example="Password">%2$s</xliff:g>, a <xliff:g id="type" example="Credit Card">%3$s</xliff:g> ?</string>
     <string name="autofill_save_yes">Cadw</string>
     <string name="autofill_save_no">Dim diolch</string>
     <string name="autofill_save_notnow">Dim nawr</string>
@@ -2414,4 +2413,5 @@
     <string name="vdm_secure_window">Nid oes mynediad at hwn wrth ffrydio. Rho gynnig arni ar dy ffôn yn lle.</string>
     <string name="system_locale_title">Rhagosodiad y system</string>
     <string name="device_state_notification_turn_off_button">Troi i ffwrdd</string>
+    <string name="profile_label_work">Gwaith</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-fur-rIT/strings.xml b/overlay/frameworks/base/core/res/res/values-fur-rIT/strings.xml
index fa15af9..197525e 100644
--- a/overlay/frameworks/base/core/res/res/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-fur-rIT/strings.xml
@@ -19,6 +19,7 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="byteShort">B</string>
+    <string name="fileSizeSuffix"><xliff:g id="number" example="123">%1$s</xliff:g> <xliff:g id="unit" example="B">%2$s</xliff:g></string>
     <string name="untitled">&lt;Cence non&gt;</string>
     <string name="emptyPhoneNumber">(Nissun numar di telefon)</string>
     <string name="unknownName">No cognossût</string>
@@ -40,6 +41,8 @@
     <string name="mismatchPin">I PINs inserîts no corispuindin.</string>
     <string name="invalidPin">Scrîf un PIN che al vedi di 4 a 8 numars.</string>
     <string name="invalidPuk">Scrîf un PUK che al sedi di almancul 8 cifris.</string>
+    <string name="needPuk">La tô SIM e je blocade cul PUK. Inserìs il codiç PUK par sblocâle.</string>
+    <string name="needPuk2">Inserìs il PUK2 par sblocâ la SIM.</string>
     <string name="enablePin">Operazion lade strucje, ative il Bloc SIM/RUIM.</string>
     <plurals name="pinpuk_attempts">
         <item quantity="one">Tu âs ancjemò <xliff:g id="number">%d</xliff:g> tentatîf prime che la SIM si blochi.</item>
@@ -47,6 +50,7 @@
     </plurals>
     <string name="imei">IMEI</string>
     <string name="meid">MEID</string>
+    <string name="ClipMmi">ID di chel che ti clame in jentrade</string>
     <string name="ClirMmi">Plate ID di chel che al clame in jessude</string>
     <string name="ColpMmi">ID linie conetude</string>
     <string name="ColrMmi">Limitazion ID linie conetude</string>
@@ -67,6 +71,8 @@
     <string name="CLIRDefaultOffNextCallOff">ID di chel che al clame metût come predefinît a no limitât. Prossime clamade: no limitât</string>
     <string name="serviceNotProvisioned">Servizi no furnît.</string>
     <string name="CLIRPermanent">No tu puedis cambiâ la impostazion dal ID di chel che al clame.</string>
+    <string name="auto_data_switch_title">Dâts passâts su <xliff:g id="carrierDisplay" example="Verizon">%s</xliff:g></string>
+    <string name="auto_data_switch_content">Tu puedis cambiâ chest valôr plui indenant tes Impostazions.</string>
     <string name="RestrictedOnDataTitle">Nissun servizi di dâts mobii</string>
     <string name="RestrictedOnEmergencyTitle">Clamadis di emergjence no disponibilis</string>
     <string name="RestrictedOnNormalTitle">Nissun servizi vôs</string>
@@ -131,6 +137,7 @@
     <string name="wfcSpnFormat_wifi">Wi-Fi</string>
     <string name="wfcSpnFormat_wifi_calling_wo_hyphen">Clamadis Wi-Fi</string>
     <string name="wfcSpnFormat_vowifi">VoWifi</string>
+    <string name="wfcSpnFormat_wifi_call">Clamade WiFi</string>
     <string name="wifi_calling_off_summary">Off</string>
     <string name="wfc_mode_wifi_preferred_summary">Clamade midiant Wi-Fi</string>
     <string name="wfc_mode_cellular_preferred_summary">Clamade midiant rêt mobile</string>
@@ -206,6 +213,10 @@
         profîl di lavôr di restâ disativât par plui di <xliff:g id="number" example="3">%3$d</xliff:g> dîs.
     </string>
     <string name="personal_apps_suspended_turn_profile_on">Ative</string>
+    <string name="work_profile_telephony_paused_title">Clamadis e messaçs a son disativâts</string>
+    <string name="work_profile_telephony_paused_text">Tu âs metût in pause lis aplicazions di lavôr.
+        No tu ricevarâs clamadis telefonichis o messaçs di test.</string>
+    <string name="work_profile_telephony_paused_turn_on_button">Fin-pause aplic. di lavôr</string>
     <string name="me">Jo</string>
     <string name="power_dialog" product="tablet">Opzions tablet</string>
     <string name="power_dialog" product="tv">Opzions di Android TV</string>
@@ -310,6 +321,8 @@
     <string name="android_system_label">Sisteme Android</string>
     <string name="user_owner_label">Passe al profîl personâl</string>
     <string name="managed_profile_label">Passe al profîl di lavôr</string>
+    <string name="user_owner_app_label">Passe a <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> personâl</string>
+    <string name="managed_profile_app_label">Passe a <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> di lavôr</string>
     <string name="permgrouplab_contacts">Contats</string>
     <string name="permgroupdesc_contacts">acedi ai tiei contats</string>
     <string name="permgrouplab_location">Posizion</string>
@@ -438,16 +451,48 @@
       esecuzion di altris aplicazions.</string>
     <string name="permlab_systemAlertWindow">Cheste aplicazion e pues parâsi denant di altris aplicazions</string>
     <string name="permdesc_systemAlertWindow">Cheste aplicazion e pues parâsi parsore di altris aplicazions o altris parts dal schermi. Chest al pues interferî cu la normâl utilizazion di aplicazions e cambiâ l\'aspiet di altris aplicazions.</string>
+    <string name="permlab_hideOverlayWindows">platâ soreposizions di altris aplicazions</string>
+    <string name="permdesc_hideOverlayWindows">Cheste aplicazion e pues domandâ che il sisteme al plati lis soreposizions che a àn origjin di altris aplicazions, cussì che chês no vegnin mostradis sore di cheste aplicazion.</string>
     <string name="permlab_runInBackground">esecuzion in sotfont</string>
     <string name="permdesc_runInBackground">Cheste aplicazion e pues zirâ in sotfont. Chest al pues consumâ di plui la batarie.</string>
     <string name="permlab_useDataInBackground">doprâ dâts in sotfont</string>
     <string name="permdesc_useDataInBackground">Cheste aplicazion e pues doprâ dâts in sotfont. Chest al pues aumentâ il consum di dâts.</string>
+    <string name="permlab_schedule_exact_alarm">Programe azions temporizadis in mût precîs</string>
+    <string name="permdesc_schedule_exact_alarm">Cheste aplicazion e pues programâ il lavôr par che al sucedi ae ore desiderade. Chest al significhe ancje che la aplicazion e pues zirâ cuant che no tu stâs doprant il dispositîf in mût atîf.</string>
+    <string name="permlab_use_exact_alarm">Programe sveis o pro memoria di events</string>
+    <string name="permdesc_use_exact_alarm">Cheste aplicazion e pues programâ azions come sveis e pro memoria par dâti notifiche ae ore desiderade tal futûr. </string>
     <string name="permlab_persistentActivity">esecuzion continue de aplicazion</string>
     <string name="permdesc_persistentActivity" product="tablet">Al permet di fâ restâ in memorie part de aplicazion o dute interie. Chest al pues limitâ la memorie disponibile par altris aplicazions, morestant il tablet.</string>
     <string name="permdesc_persistentActivity" product="tv">Al permet di fâ restâ in memorie part de aplicazion o dute interie. Chest al pues limitâ la memorie disponibile par altris aplicazions, morestant il to dispositîf Android TV.</string>
     <string name="permdesc_persistentActivity" product="default">Al permet di fâ restâ in memorie part de aplicazion o dute interie. Chest al pues limitâ la memorie disponibile par altris aplicazions, morestant il telefon.</string>
     <string name="permlab_foregroundService">eseguî servizis in prin plan</string>
     <string name="permdesc_foregroundService">Al permet ae aplicazion di fâ ûs dai servizis in prin plan.</string>
+    <string name="permlab_foregroundServiceCamera">fâ zirâ un servizi in prin plan cul gjenar \"camera\" (fotocjamare)</string>
+    <string name="permdesc_foregroundServiceCamera">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"camera\" (fotocjamare)</string>
+    <string name="permlab_foregroundServiceConnectedDevice">fâ zirâ un servizi in prin plan cul gjenar \"connectedDevice\" (dispositîf conetût)</string>
+    <string name="permdesc_foregroundServiceConnectedDevice">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"connectedDevice\" (dispositîf conetût)</string>
+    <string name="permlab_foregroundServiceDataSync">fâ zirâ un servizi in prin plan cul gjenar \"dataSync\" (sincronizazion dâts)</string>
+    <string name="permdesc_foregroundServiceDataSync">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"dataSync\" (sincronizazion dâts)</string>
+    <string name="permlab_foregroundServiceLocation">fâ zirâ un servizi in prin plan cul gjenar \"location\" (posizion)</string>
+    <string name="permdesc_foregroundServiceLocation">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"location\" (posizion)</string>
+    <string name="permlab_foregroundServiceMediaPlayback">fâ zirâ un servizi in prin plan cul gjenar \"mediaPlayback\" (riproduzion multimediâl)</string>
+    <string name="permdesc_foregroundServiceMediaPlayback">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"mediaPlayback\" (riproduzion multimediâl)</string>
+    <string name="permlab_foregroundServiceMediaProjection">fâ zirâ un servizi in prin plan cul gjenar \"mediaProjection\" (proiezion multimediâl)</string>
+    <string name="permdesc_foregroundServiceMediaProjection">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"mediaProjection\" (proiezion multimediâl)</string>
+    <string name="permlab_foregroundServiceMicrophone">fâ zirâ un servizi in prin plan cul gjenar \"microphone\" (microfon)</string>
+    <string name="permdesc_foregroundServiceMicrophone">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"microphone\" (microfon)</string>
+    <string name="permlab_foregroundServicePhoneCall">fâ zirâ un servizi in prin plan cul gjenar \"phoneCall\" (clamade telefoniche)</string>
+    <string name="permdesc_foregroundServicePhoneCall">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"phoneCall\" (clamade telefoniche)</string>
+    <string name="permlab_foregroundServiceHealth">fâ zirâ un servizi in prin plan cul gjenar \"health\" (salût)</string>
+    <string name="permdesc_foregroundServiceHealth">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"health\" (salût)</string>
+    <string name="permlab_foregroundServiceRemoteMessaging">fâ zirâ un servizi in prin plan cul gjenar \"remoteMessaging\" (messaçs di lontan)</string>
+    <string name="permdesc_foregroundServiceRemoteMessaging">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"remoteMessaging\" (messaçs di lontan)</string>
+    <string name="permlab_foregroundServiceSystemExempted">fâ zirâ un servizi in prin plan cul gjenar \"systemExempted\" (sisteme esentât)</string>
+    <string name="permdesc_foregroundServiceSystemExempted">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"systemExempted\" (sisteme esentât)</string>
+    <string name="permlab_foregroundServiceFileManagement">fâ zirâ un servizi in prin plan cul gjenar \"fileManagement\" (gjestion files)</string>
+    <string name="permdesc_foregroundServiceFileManagement">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"fileManagement\" (gjestion files)</string>
+    <string name="permlab_foregroundServiceSpecialUse">fâ zirâ un servizi in prin plan cul gjenar \"specialUse\" (ûs speciâl)</string>
+    <string name="permdesc_foregroundServiceSpecialUse">Al permet ae aplicazion di doprâ i servizis in prin plan cul gjenar \"specialUse\" (ûs speciâl)</string>
     <string name="permlab_getPackageSize">misurâ il spazi di archiviazion de aplicazion</string>
     <string name="permdesc_getPackageSize">Al permet ae aplicaizion di recuperâ lis dimensions dal codiç, dai dâts e de cache</string>
     <string name="permlab_writeSettings">modificâ lis impostazions di sisteme</string>
@@ -537,6 +582,8 @@
     <string name="permdesc_recordAudio">Cheste aplicazion e pues regjistrâ audio doprant il microfon intant che tu le dopris.</string>
     <string name="permlab_recordBackgroundAudio">regjistrâ audio in sotfont</string>
     <string name="permdesc_recordBackgroundAudio">Cheste aplicazion e pues regjistrâ l\'audio doprant il microfon cuant che e vûl.</string>
+    <string name="permlab_detectScreenCapture">rilevâ acuisizion schermadis dai barcons des aplicazions</string>
+    <string name="permdesc_detectScreenCapture">Cheste aplicazion e vignarà informade se e ven fate une acuisizion de videade intant che la aplicazion e je in ûs.</string>
     <string name="permlab_sim_communication">mandâ comants ae SIM</string>
     <string name="permdesc_sim_communication">Al permet ae aplicazion di mandâ comandts ae SIM. Chest al è une vore pericolôs.</string>
     <string name="permlab_activityRecognition">ricognossi ativitât fisiche</string>
@@ -553,6 +600,12 @@
     <string name="permdesc_vibrate">Al permet ae aplicazion di controlâ la vibrazion.</string>
     <string name="permdesc_vibrator_state">Al permet ae aplicazion di acedi al stât de vibrazion.</string>
     <string name="permlab_callPhone">clamâ in mût diret i numars telefonics</string>
+    <string name="permdesc_callPhone">Al permet ae aplicazion di clamâ numars di telefon
+      cence il to intervent. Chest al pues puartâ a spesis o clamadis inspietadis.
+      Viôt che chest nol permet ae aplicazion di clamâ numars di emergjence.
+      Lis aplicazions malevulis a podaressin fâti spindi bêçs fasint clamadis cence
+      la tô conferme, o doprâ codiçs di operadôr che a podaressin deviâ in automatic
+      lis clamadis in jentrade suntun altri numar.</string>
     <string name="permlab_accessImsCallService">acedi al servizi pes clamadis IMS</string>
     <string name="permdesc_accessImsCallService">Al permet ae aplicazion di doprâ il servizi IMS par fâ clamadis cence il to intervent.</string>
     <string name="permlab_readPhoneState">lei la identitât e il stât dal telefon </string>
@@ -699,6 +752,8 @@
     </string>
     <string name="permlab_postNotification">mostrâ notifichis</string>
     <string name="permdesc_postNotification">Al permet ae aplicazion di mostrâ notifichis</string>
+    <string name="permlab_turnScreenOn">ativâ il schermi</string>
+    <string name="permdesc_turnScreenOn">Al permet ae aplicazion di ativâ il schermi.</string>
     <string name="permlab_useBiometric">ûs dal hardware biometric</string>
     <string name="permdesc_useBiometric">Al permet ae aplicazion di doprâ, pe autenticazion, l\'hardware biometric</string>
     <string name="permlab_manageFingerprint">gjestî hardware par impronts digjitâi</string>
@@ -721,6 +776,7 @@
     <string name="biometric_error_hw_unavailable">Hardware biometric no disponibil</string>
     <string name="biometric_error_user_canceled">Autenticazion anulade</string>
     <string name="biometric_not_recognized">No ricognossût</string>
+    <string name="biometric_face_not_recognized">Muse no ricognossude</string>
     <string name="biometric_error_canceled">Autenticazion anulade</string>
     <string name="biometric_error_device_not_secured">Nol è stât stabilît nissun pin, cumbinazion o password</string>
     <string name="biometric_error_generic">Erôr te autenticazion</string>
@@ -740,6 +796,7 @@
     <string-array name="fingerprint_acquired_vendor"/>
     <string name="fingerprint_error_not_match">Impront no ricognossût</string>
     <string name="fingerprint_udfps_error_not_match">Impront no ricognossût</string>
+    <string name="fingerprint_dialog_use_fingerprint_instead">Impussibil ricognossi la muse. Dopre l\'impront.</string>
     <string name="fingerprint_authenticated">Impront digjitâl autenticade</string>
     <string name="face_authenticated_no_confirmation_required">Muse autenticade</string>
     <string name="face_authenticated_confirmation_required">Muse autenticade, frache conferme</string>
@@ -764,6 +821,10 @@
     <string-array name="fingerprint_error_vendor"/>
     <string name="fingerprint_error_vendor_unknown">Alc al è lât strucj. Torne prove.</string>
     <string name="fingerprint_icon_content_description">Icone dal impront digjitâl</string>
+    <string name="device_unlock_notification_name">Sbloc dal dispositîf</string>
+    <string name="alternative_unlock_setup_notification_title">Prove a sblocâ intune altre maniere</string>
+    <string name="alternative_face_setup_notification_content">Dopre il sbloc cu la muse cuant che l\'impront nol ven ricognossût, come cuant che i dêts a son bagnâts</string>
+    <string name="alternative_fp_setup_notification_content">Dopre il sbloc cul impront cuant che la muse no ven ricognossude, come cuant che no je avonde lûs</string>
     <string name="face_recalibrate_notification_name">Sbloc cu la muse</string>
     <string name="face_recalibrate_notification_title">Probleme cul sbloc cu la muse</string>
     <string name="face_recalibrate_notification_content">Tocje par eliminiâ il model de tô muse, dopo torne zonte la tô muse</string>
@@ -803,6 +864,7 @@
     <string name="face_error_canceled">Operazion muse anulade.</string>
     <string name="face_error_user_canceled">Sbloc cu la muse anulât dal utent</string>
     <string name="face_error_lockout">Masse tentatîfs. Torne prove plui indenant.</string>
+    <string name="face_error_lockout_permanent">Masse tentatîfs. Sbloc cu la muse no disponibil.</string>
     <string name="face_error_lockout_screen_lock">Masse tentatîfs. Inserìs il bloc dal schermi.</string>
     <string name="face_error_unable_to_process">Impussibil verificâ la muse. Torne prove.</string>
     <string name="face_error_not_enrolled">No tu âs configurât il sbloc cu la muse.</string>
@@ -830,6 +892,8 @@
     <string name="permdesc_readMediaVideo">Al permet ae aplicazion di lei i files video de tô memorie di archivazion condividude.</string>
     <string name="permlab_readMediaImages">lei files di imagjin de memorie di archiviazion condividude</string>
     <string name="permdesc_readMediaImages">Al permet ae aplicazion di lei i files imagjin de tô memorie di archivazion condividude.</string>
+    <string name="permlab_readVisualUserSelect">lei de memorie di archiviazion condividude i files di imagjins e videos selezionâts dal utent</string>
+    <string name="permdesc_readVisualUserSelect">Al permet ae aplicazion di lei i files di videos e di imagjins che tu selezionis de tô memorie di archiviazion condividude.</string>
     <string name="permlab_sdcardWrite">modificâ o eliminâ i contignûts de tô memorie condividude</string>
     <string name="permdesc_sdcardWrite">Al permet ae aplicazion di scrivi i contignûts de tô memorie di archivazion condividude.</string>
     <string name="permlab_use_sip">fâ/ricevi clamadis SIP</string>
@@ -886,6 +950,8 @@
     <string name="permdesc_startViewAppFeatures">Al permet al titolâr di scomençâ a visualizâ lis informazions relativis aes funzionalitâts di une aplicazion.</string>
     <string name="permlab_highSamplingRateSensors">acedi ai dâts dai sensôrs a une frecuence di campionament elevade</string>
     <string name="permdesc_highSamplingRateSensors">Al permet ae aplicazion di campionâ i dâts dai sensôrs a une frecuence plui grande di 20 Hz</string>
+    <string name="permlab_updatePackagesWithoutUserAction">inzornâ la aplicazion cence la azion dal utent</string>
+    <string name="permdesc_updatePackagesWithoutUserAction">Al permet al possessôr di inzornâ la aplicazion che al à instalât in precedence cence azions de bande dal utent</string>
     <string name="policylab_limitPassword">Stabilìs lis regulis pes passwords</string>
     <string name="policydesc_limitPassword">Controle la lungjece e i caratars ametûts tes passwords e tai PINs dal bloc dal schermi.</string>
     <string name="policylab_watchLogin">Monitore i tentatîfs di sbloc dal schermi</string>
@@ -1076,6 +1142,15 @@
     <string name="lockscreen_password_wrong">Torne prove</string>
     <string name="lockscreen_storage_locked">Sbloche par ducj i dâts e lis funzionalitâts</string>
     <string name="faceunlock_multiple_failures">A son stâts superâts i tentatîfs massims di sbloc cu la muse</string>
+    <string name="lockscreen_missing_sim_message_short">Nissune SIM</string>
+    <string name="lockscreen_missing_sim_message" product="tablet">Nissune SIM tal tablet.</string>
+    <string name="lockscreen_missing_sim_message" product="tv">Nissune SIM tal to dispositîf Android TV.</string>
+    <string name="lockscreen_missing_sim_message" product="default">Nissune SIM tal telefon.</string>
+    <string name="lockscreen_missing_sim_instructions">Zonte une SIM.</string>
+    <string name="lockscreen_missing_sim_instructions_long">La SIM e mancje opûr no si rive a lei. Zonte une SIM.</string>
+    <string name="lockscreen_permanent_disabled_sim_message_short">SIM inusabile.</string>
+    <string name="lockscreen_permanent_disabled_sim_instructions">La tô SIM e je stade disativade in maniere definitive.\n
+    Contate il to furnidôr dal servizi cence fîi par vê une altre SIM.</string>
     <string name="lockscreen_transport_prev_description">Toc precedent</string>
     <string name="lockscreen_transport_next_description">Toc sucessîf</string>
     <string name="lockscreen_transport_pause_description">Pause</string>
@@ -1085,7 +1160,10 @@
     <string name="lockscreen_transport_ffw_description">Avanzament svelt</string>
     <string name="emergency_calls_only" msgid="2485604591272668370">Dome clamadis di emergjence</string>
     <string name="lockscreen_network_locked_message">Rêt blocade</string>
+    <string name="lockscreen_sim_puk_locked_message">La SIM e je blocade cul PUK.</string>
     <string name="lockscreen_sim_puk_locked_instructions">Viôt la vuide utent o contate il servizi clients.</string>
+    <string name="lockscreen_sim_locked_message">La SIM e je blocade.</string>
+    <string name="lockscreen_sim_unlock_progress_dialog_message">Daûr a sblocâ la SIM\u2026</string>
     <string name="lockscreen_too_many_failed_attempts_dialog_message">        Tu âs dissegnât mâl la tô cumbinazion di sbloc <xliff:g id="number">%1$d</xliff:g> voltis.
         \n\nTorne prove chi di <xliff:g id="number">%2$d</xliff:g> seconts.
     </string>
@@ -1359,6 +1437,11 @@
     <string name="not_checked">deselezionât</string>
     <string name="selected">selezionât</string>
     <string name="not_selected">no selezionât</string>
+    <string name="rating_label">{ rating, plural,
+        one {}=1 {Une stele su {max}}
+        other {# stelis su {max}}
+    }
+    </string>
     <string name="in_progress">in cors</string>
     <string name="whichApplication">Complete la azion doprant</string>
     <string name="whichApplicationNamed">Complete la azion doprant %1$s</string>
@@ -1532,7 +1615,10 @@
     <string name="sms_short_code_remember_undo_instruction">Tu puedis cambiâ cheste impostazion plui indenant in Impostazions\u00A0&gt;\u00A0Aplicazions</string>
     <string name="sms_short_code_confirm_always_allow">Permet simpri</string>
     <string name="sms_short_code_confirm_never_allow">No sta permeti mai</string>
+    <string name="sim_removed_title">SIM gjavade</string>
+    <string name="sim_removed_message">La rêt mobile no sarà disponibile fintremai che no tu tornis a inviâ cuntune SIM valide.</string>
     <string name="sim_done_button">Fat</string>
+    <string name="sim_added_title">SIM zontade</string>
     <string name="sim_added_message">Torne invie il dispositîf par acedi ae rêt mobile.</string>
     <string name="sim_restart_button">Torne invie</string>
     <string name="install_carrier_app_notification_title">Ativazion dal servizi mobil</string>
@@ -1556,6 +1642,7 @@
     <string name="usb_ptp_notification_title">PTP vie USB ativât</string>
     <string name="usb_tether_notification_title">Tethering USB ativât</string>
     <string name="usb_midi_notification_title">MIDI vie USB ativât</string>
+    <string name="usb_uvc_notification_title">Dispositîf colegât come Webcam</string>
     <string name="usb_accessory_notification_title">Acessori USB colegât</string>
     <string name="usb_notification_message">Tocje par vê plui opzions.</string>
     <string name="usb_power_notification_message">Daûr a ricjariâ il dispositîf colegât. Tocje par vê plui opzions.</string>
@@ -1586,6 +1673,9 @@
     <string name="decline_remote_bugreport_action">REFUDE</string>
     <string name="select_input_method">Sielç il metodi di imission</string>
     <string name="show_ime">Tegnilu sul schermi intant che la tastiere fisiche e je ative</string>
+    <string name="hardware">Dopre tastiere su schermi</string>
+    <string name="select_keyboard_layout_notification_title">Configure <xliff:g id="device_name" example="Foobar USB Keyboard">%s</xliff:g></string>
+    <string name="select_multiple_keyboards_layout_notification_title">Configure tastieris fisichis</string>
     <string name="select_keyboard_layout_notification_message">Tocje par selezionâ la lenghe e la disposizion</string>
     <string name="fast_scroll_alphabet">\u0020AÂBCÇDEÊFGHIÎJKLMNOÔPQRSTUÛVWXYZ</string>
     <string name="fast_scroll_numeric_alphabet">\u00200123456789AÂBCÇDEÊFGHIÎJKLMNOÔPQRSTUÛVWXYZ</string>
@@ -1816,6 +1906,7 @@
     <string name="default_audio_route_name" product="tv">TV</string>
     <string name="default_audio_route_name" product="default">Telefon</string>
     <string name="default_audio_route_name_dock_speakers">Cassis cun base</string>
+    <string name="default_audio_route_name_external_device">Dispositîf esterni</string>
     <string name="default_audio_route_name_headphones">Scufis</string>
     <string name="default_audio_route_name_usb">USB</string>
     <string name="default_audio_route_category_name">Sisteme</string>
@@ -1849,6 +1940,7 @@
     <string name="kg_puk_enter_puk_hint">Cumò la SIM e je disativade. Inserìs il codiç PUK par continuâ. Contate l\'operadôr pai detais.</string>
     <string name="kg_puk_enter_pin_hint">Inserìs il codiç PIN desiderât</string>
     <string name="kg_enter_confirm_pin_hint">Conferme il codiç PIN desiderât</string>
+    <string name="kg_sim_unlock_progress_dialog_message">Daûr a sblocâ la SIM\u2026</string>
     <string name="kg_password_wrong_pin_code">Codiç PIN sbaliât.</string>
     <string name="kg_invalid_sim_pin_hint">Scrîf un PIN che al vedi di 4 a 8 numars.</string>
     <string name="kg_invalid_sim_puk_hint">Il codiç PUK al à di vê 8 numars.</string>
@@ -1913,6 +2005,10 @@
     <string name="kg_reordering_delete_drop_target_text">Gjave</string>
     <string name="safe_media_volume_warning" product="default">       \"Alçâ il volum parsore dai nivei racomandâts?\n\nScoltâ a volums alts par periodis luncs al podarès fâ dam ae uldide.\"
     </string>
+    <string name="csd_dose_reached_warning" product="default">        \"Continuâ a scoltâ a volum alt?\n\nIl volum des scufis al è stât alt par plui timp di ce che al è conseât, chest al pues fâ mâl ae uldide\"
+    </string>
+    <string name="csd_momentary_exposure_warning" product="default">        \"Sun fuart rilevât\n\nIl volum des scufis al è stât plui alt di ce che al è conseât, chest al pues fâ mâl ae tô uldide\"
+    </string>
     <string name="accessibility_shortcut_warning_dialog_title">Doprâ la scurte al acès facilitât?</string>
     <string name="accessibility_shortcut_toogle_warning">        Cuant che la scurte e je ative, la pression di ducj i doi i botons dal volum par 3 seconts e inviarà une
         funzion di acès facilitât.
@@ -1953,10 +2049,14 @@
     <string name="done_accessibility_shortcut_menu_button">Fat</string>
     <string name="disable_accessibility_shortcut">Disative la scurte</string>
     <string name="leave_accessibility_shortcut_on">Dopre la scurte</string>
+    <string name="color_inversion_feature_name">Inversion dai colôrs</string>
+    <string name="color_correction_feature_name">Corezion dai colôrs</string>
     <string name="one_handed_mode_feature_name">Modalitât a une man</string>
     <string name="reduce_bright_colors_feature_name">Atenuazion extra</string>
+    <string name="hearing_aids_feature_name">Dispositîfs pe scolte</string>
     <string name="accessibility_shortcut_enabling_service">Tignûts fracâts i tascj dal volum. <xliff:g id="service_name" example="TalkBack">%1$s</xliff:g> ativât.</string>
     <string name="accessibility_shortcut_disabling_service">Tignûts fracâts i tascj dal volum. <xliff:g id="service_name" example="TalkBack">%1$s</xliff:g> disativât.</string>
+    <string name="accessibility_shortcut_spoken_feedback">Mole i tascj dal volum. Par ativâ<xliff:g id="service_name" example="TalkBack">%1$s</xliff:g>, frache e ten fracât di gnûf ducj i doi i tascj dal volum par 3 seconts.</string>
     <string name="accessibility_button_prompt_text">Sielç une funzion di doprâ cuant che tu tocjis il boton pal acès facilitât:</string>
     <string name="accessibility_gesture_prompt_text">Sielç une funzion di doprâ cul mot pal acès facilitât (scori in sù dal bas dal schermi cun doi dêts):</string>
     <string name="accessibility_gesture_3finger_prompt_text">Sielç une funzion di doprâ cul mot pal acès facilitât (scori in sù dal bas dal schermi cun trê dêts):</string>
@@ -2088,6 +2188,7 @@
     <string name="immersive_cling_description">Par lâ fûr, di parsore scor in jù.</string>
     <string name="immersive_cling_positive">Capît</string>
     <string name="display_rotation_camera_compat_toast_after_rotation">Volte par viodi miôr</string>
+    <string name="display_rotation_camera_compat_toast_in_multi_window">Vierç <xliff:g id="name" example="MyApp">%s</xliff:g> a plen schermi par viodi miôr</string>
     <string name="done_label">Fat</string>
     <string name="hour_picker_description">Cursôr circolâr pes oris</string>
     <string name="minute_picker_description">Cursôr circolâr pai minûts</string>
@@ -2099,6 +2200,7 @@
     <string name="managed_profile_label_badge"><xliff:g id="label" example="Email">%1$s</xliff:g> di lavôr</string>
     <string name="managed_profile_label_badge_2"><xliff:g id="label" example="Email">%1$s</xliff:g> di lavôr 2</string>
     <string name="managed_profile_label_badge_3"><xliff:g id="label" example="Email">%1$s</xliff:g> di lavôr 3</string>
+    <string name="clone_profile_label_badge"><xliff:g id="label" example="Messenger">%1$s</xliff:g> clon</string>
     <string name="time_placeholder">--</string>
     <string name="radial_numbers_typeface">sans-serif</string>
     <string name="sans_serif">sans-serif</string>
@@ -2170,6 +2272,7 @@
     <string name="zen_mode_default_weekends_name">Fin setemane</string>
     <string name="zen_mode_default_events_name">Event</string>
     <string name="zen_mode_default_every_night_name">In polse</string>
+    <string name="zen_mode_implicit_deactivated">Off</string>
     <string name="muted_by"><xliff:g id="third_party">%1$s</xliff:g> al sta cidinant cualchi sun</string>
     <string name="system_error_wipe_data">Il to dispositîf al à un probleme interni e al podarès jessi instabil fintremai che no tu fasis un ripristinament dai dâts di fabriche.</string>
     <string name="system_error_manufacturer">Il to dispositîf al à un probleme interni. Contate il produtôr pai detais.</string>
@@ -2216,6 +2319,8 @@
     <string name="search_language_hint">Scrîf il non de lenghe</string>
     <string name="language_picker_section_suggested">Sugjeridis</string>
     <string name="language_picker_regions_section_suggested">Sugjeridis</string>
+    <string name="language_picker_section_suggested_bilingual">Lenghis sugjeridis</string>
+    <string name="region_picker_section_suggested_bilingual">Regjons sugjeridis</string>
     <string name="language_picker_section_all">Dutis lis lenghis</string>
     <string name="region_picker_section_all">Dutis lis regjons</string>
     <string name="locale_search_menu">Cîr</string>
@@ -2224,12 +2329,13 @@
     </string>
     <string name="app_suspended_more_details">Plui informazions</string>
     <string name="app_suspended_unsuspend_message">Torne ative la aplicazion</string>
+    <string name="work_mode_off_title">Terminâ la pause des apl. di lavôr?</string>
+    <string name="work_mode_turn_on">Termine pause</string>
     <string name="work_mode_emergency_call_button">Emergjence</string>
     <string name="app_blocked_title">La aplicazion no je disponibile</string>
     <string name="app_blocked_message">        In chest moment <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> nol è disponibil.
     </string>
     <string name="app_streaming_blocked_title"><xliff:g id="activity" example="Permission dialog">%1$s</xliff:g> no disponibil</string>
-    <string name="app_streaming_blocked_title_for_permission_dialog">Permès necessari</string>
     <string name="app_streaming_blocked_title_for_camera_dialog">Fotocjamare no disponibile</string>
     <string name="app_streaming_blocked_title_for_fingerprint_dialog">Continue sul telefon</string>
     <string name="app_streaming_blocked_title_for_microphone_dialog">Microfon no disponibil</string>
@@ -2246,7 +2352,9 @@
     <string name="app_streaming_blocked_message_for_settings_dialog" product="tv">Nol è pussibil acedi a cheste aplicazion su <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prove sul to dispositîf Android TV.</string>
     <string name="app_streaming_blocked_message_for_settings_dialog" product="tablet">Nol è pussibil acedi a cheste aplicazion su <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prove sul to tablet.</string>
     <string name="app_streaming_blocked_message_for_settings_dialog" product="default">Nol è pussibil acedi a cheste aplicazion su <xliff:g id="device" example="Chromebook">%1$s</xliff:g>. Prove sul to telefon.</string>
+    <string name="deprecated_target_sdk_message">Cheste aplicazion e je stade fate par une version di Android plui vecje. Al è pussibil che no funzioni ben e che no includi lis ultimis protezions di sigurece e riservatece. Controle se al esist un inzornament, opûr contate il svilupadôr de aplicazion.</string>
     <string name="deprecated_target_sdk_app_store">Controle i inzornaments</string>
+    <string name="deprecated_abi_message">Cheste aplicazion no je compatibile cu la ultime version di Android. Controle se al esist un inzornament o contate il svilupadôr de aplicazion.</string>
     <string name="new_sms_notification_title">Tu âs gnûfs messaçs</string>
     <string name="new_sms_notification_content">Vierç la aplicazion dai SMS par viodi</string>
     <string name="profile_encrypted_title">Cualchi funzionalitât e podarès jessi limitade</string>
@@ -2299,7 +2407,6 @@
     <string name="autofill_update_title">Inzornâ in <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_type">Inzornâ <xliff:g id="type" example="Credit Card">%1$s</xliff:g> in <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_2types">Inzornâ <xliff:g id="type" example="Password">%1$s</xliff:g> e <xliff:g id="type" example="Credit Card">%2$s</xliff:g> in <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
-    <string name="autofill_update_title_with_3types">Inzornâ chescj elements in <b><xliff:g id="label" example="MyPass">%4$s</xliff:g></b>: <xliff:g id="type" example="Username">%1$s</xliff:g>, <xliff:g id="type" example="Password">%2$s</xliff:g> e <xliff:g id="type" example="Credit Card">%3$s</xliff:g> ?</string>
     <string name="autofill_save_yes">Salve</string>
     <string name="autofill_save_no">No graciis</string>
     <string name="autofill_save_notnow">No cumò</string>
@@ -2368,6 +2475,8 @@
     <string name="nas_upgrade_notification_learn_more_action">Plui informazions</string>
     <string name="nas_upgrade_notification_learn_more_content">In Android 12 lis notifichis avanzadis a àn sostituît lis notifichis adativis di Android. Cheste funzionalitât e mostre lis azions e lis rispuestis sugjeridis e e organize lis tôs notifichis.\n\nLis notifichis avanzadis a puedin acedi ai contignûts des notifichis, includudis lis informazions personâls come i nons dai contats e i messaçs. Cheste funzion e pues ancje scartâ o rispuindi aes notifichis, come par esempli rispuindi aes clamadis telefonichis e controlâ il No Sta Disturbâ.</string>
     <string name="dynamic_mode_notification_channel_name">Notifiche di informazion de modalitât Routine</string>
+    <string name="dynamic_mode_notification_title">Sparagn energjetic ativât</string>
+    <string name="dynamic_mode_notification_summary">Daûr a ridusi il consum di batarie par sprolungjâ la durade de batarie</string>
     <string name="battery_saver_notification_channel_name">Sparagn energjetic</string>
     <string name="battery_saver_off_notification_title">Sparagn energjetic disativât</string>
     <string name="battery_saver_charged_notification_summary" product="default">Il telefon al à avonde batarie. Lis funzionalitâts no son plui limitadis.</string>
@@ -2435,10 +2544,21 @@
     <string name="resolver_cant_access_work_apps_explanation">Nol è pussibil vierzi chest contignût cu lis aplicazions di lavôr</string>
     <string name="resolver_cant_share_with_personal_apps_explanation">Nol è pussibil condividi chest contignût cu lis aplicazions personâls</string>
     <string name="resolver_cant_access_personal_apps_explanation">Nol è pussibil vierzi chest contignût cu lis aplicazions personâls</string>
+    <string name="resolver_turn_on_work_apps">Lis aplicazions di lavôr a son in pause</string>
+    <string name="resolver_switch_on_work">Termine pause</string>
     <string name="resolver_no_work_apps_available">Nissune aplicazion di lavôr</string>
     <string name="resolver_no_personal_apps_available">Nissune aplicazion personâl</string>
+    <string name="miniresolver_open_work">Vierzi <xliff:g id="app" example="YouTube">%s</xliff:g> di lavôr?</string>
+    <string name="miniresolver_open_in_personal">Vierzi tal <xliff:g id="app" example="YouTube">%s</xliff:g> personâl?</string>
+    <string name="miniresolver_open_in_work">Vierzi tal <xliff:g id="app" example="YouTube">%s</xliff:g> di lavôr?</string>
+    <string name="miniresolver_call_in_work">Clamâ de aplicazion di lavôr?</string>
+    <string name="miniresolver_switch_to_work">Passâ ae aplicazion di lavôr?</string>
+    <string name="miniresolver_call_information">La tô organizazion ti permet di fâ clamadis dome cu lis aplicazions di lavôr</string>
+    <string name="miniresolver_sms_information">La tô organizazion ti permet di mandâ messaçs dome cu lis aplicazions di lavôr</string>
     <string name="miniresolver_use_personal_browser">Dopre il navigadôr personâl</string>
     <string name="miniresolver_use_work_browser">Dopre il navigadôr di lavôr</string>
+    <string name="miniresolver_call">Clame</string>
+    <string name="miniresolver_switch">Passe a</string>
     <string name="PERSOSUBSTATE_SIM_NETWORK_ENTRY">PIN di sbloc de rêt de SIM</string>
     <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ENTRY">PIN di sbloc dal sotinsiemi di rêt de SIM</string>
     <string name="PERSOSUBSTATE_SIM_CORPORATE_ENTRY">PIN di sbloc aziendâl de SIM</string>
@@ -2573,6 +2693,34 @@
     <string name="vdm_camera_access_denied" product="default">Dal to <xliff:g id="device" example="Chromebook">%1$s</xliff:g> nol è pussibil acedi ae fotocjamare dal telefon</string>
     <string name="vdm_camera_access_denied" product="tablet">Dal to <xliff:g id="device" example="Chromebook">%1$s</xliff:g> nol è pussibil acedi ae fotocjamare dal tablet</string>
     <string name="vdm_secure_window">Impussibil acedi a chescj contignûts intant de trasmission in streaming. Prove sul telefon.</string>
+    <string name="vdm_pip_blocked">Impussibil visualizâ il picture-in-picture intant di une trasmission</string>
     <string name="system_locale_title">Predefinît di sisteme</string>
+    <string name="default_card_name">SCHEDE <xliff:g id="cardNumber" example="1">%d</xliff:g></string>
+    <string name="permlab_companionProfileWatch">Permès par gjestî i orlois dal profîl de aplicazion di acompagnament dal orloi</string>
+    <string name="permdesc_companionProfileWatch">Al permet a une aplicazion di acompagnament di gjestî i orlois.</string>
+    <string name="permlab_observeCompanionDevicePresence">Osservâ la presince di dispositîfs di acompagnament</string>
+    <string name="permdesc_observeCompanionDevicePresence">Al permet a une aplicazion di acompagnament di osservâ la presince di dispositîfs di acompagnament cuant che i dispositîfs a son dongje o lontans.</string>
+    <string name="permlab_deliverCompanionMessages">Consegnâ messaçs di acompagnament</string>
+    <string name="permdesc_deliverCompanionMessages">Al permet a une aplicazion di acompagnament di consegnâ i messaçs di acompagnament a altris dispositîfs.</string>
+    <string name="permlab_startForegroundServicesFromBackground">Invie i servizis in prin plan dal sotfont</string>
+    <string name="permdesc_startForegroundServicesFromBackground">Al permet a une aplicazion di acompagnament di inviâ servizis in prin plan dal sotfont.</string>
+    <string name="mic_access_on_toast">Il microfon al è disponibil</string>
+    <string name="mic_access_off_toast">Il microfon al è blocât</string>
+    <string name="concurrent_display_notification_name">Dopli schermi</string>
+    <string name="concurrent_display_notification_active_title">Il dopli schermi al è atîf</string>
+    <string name="concurrent_display_notification_active_content">Utilizazion di ducj i doi i schermis de bande di <xliff:g id="app_name" example="Camera app">%1$s</xliff:g> par mostrâ il contignût</string>
+    <string name="concurrent_display_notification_thermal_title">Il dispositîf al è masse cjalt</string>
+    <string name="concurrent_display_notification_thermal_content">Il dopli schermi nol è disponibil parcè che il telefon si sta scjaldant masse</string>
+    <string name="concurrent_display_notification_power_save_title">Il dopli schermi nol è disponibil</string>
+    <string name="concurrent_display_notification_power_save_content">Il dopli schermi nol è disponibil parcè che il Sparagn energjetic al è atîf. Tu puedis disativâlu tes Impostaszions.</string>
+    <string name="device_state_notification_settings_button">Va tes impostazions</string>
     <string name="device_state_notification_turn_off_button">Disative</string>
+    <string name="keyboard_layout_notification_selected_title"><xliff:g id="device_name" example="Foobar USB Keyboard">%s</xliff:g> configurade</string>
+    <string name="keyboard_layout_notification_one_selected_message">Disposizion de tastiere metude a <xliff:g id="layout_1" example="English (US)">%s</xliff:g>. Tocje par cambiâ.</string>
+    <string name="keyboard_layout_notification_two_selected_message">Disposizion de tastiere metude a <xliff:g id="layout_1" example="English (US)">%1$s</xliff:g>, <xliff:g id="layout_2" example="German">%2$s</xliff:g>. Tocje par cambiâ.</string>
+    <string name="keyboard_layout_notification_three_selected_message">Disposizion de tastiere metude a <xliff:g id="layout_1" example="English (US)">%1$s</xliff:g>, <xliff:g id="layout_2" example="German">%2$s</xliff:g>, <xliff:g id="layout_3" example="French">%3$s</xliff:g>. Tocje par cambiâ.</string>
+    <string name="keyboard_layout_notification_more_than_three_selected_message">Disposizion de tastiere metude a <xliff:g id="layout_1" example="English (US)">%1$s</xliff:g>, <xliff:g id="layout_2" example="English (US)">%2$s</xliff:g>, <xliff:g id="layout_3" example="French">%3$s</xliff:g>\u2026 Tocje par cambiâ.</string>
+    <string name="keyboard_layout_notification_multiple_selected_title">Tastieris fisichis configuradis</string>
+    <string name="keyboard_layout_notification_multiple_selected_message">Tocje par viodi lis tastieris</string>
+    <string name="profile_label_work">Lavôr</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-gd/strings.xml b/overlay/frameworks/base/core/res/res/values-gd/strings.xml
index fc0b762..2456793 100644
--- a/overlay/frameworks/base/core/res/res/values-gd/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-gd/strings.xml
@@ -1858,6 +1858,7 @@
     <string name="zen_mode_default_weekends_name">Deireadh-seachdain</string>
     <string name="zen_mode_default_events_name">Tachartas</string>
     <string name="zen_mode_default_every_night_name">’Na chadal</string>
+    <string name="zen_mode_implicit_deactivated">Dheth</string>
     <string name="muted_by">Tha <xliff:g id="third_party">%1$s</xliff:g> a’ mùchadh cuid a dh’fhuaimean</string>
     <string name="system_error_wipe_data">Tha mearachd inntearnail aig an uidheam agad is dh’fhaoidte gum bi e cugallach gus an ath-shuidhich thu air bun-roghainnean an fhactaraidh e.</string>
     <string name="system_error_manufacturer">Tha mearachd inntearnail aig an uidheam agad. Cuir fios gun dèanadair agad airson mion-fhiosrachadh.</string>
@@ -1956,7 +1957,6 @@
     <string name="autofill_update_title">An ùraich thu e am broinn <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_type">An ùraich thu <xliff:g id="type" example="Credit Card">%1$s</xliff:g> am broinn <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_2types">An ùraich thu <xliff:g id="type" example="Password">%1$s</xliff:g> ’s <xliff:g id="type" example="Credit Card">%2$s</xliff:g> am broinn <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
-    <string name="autofill_update_title_with_3types">An ùraich thu na nithean seo am broinn <b><xliff:g id="label" example="MyPass">%4$s</xliff:g></b>: <xliff:g id="type" example="Username">%1$s</xliff:g>, <xliff:g id="type" example="Password">%2$s</xliff:g> ’s <xliff:g id="type" example="Credit Card">%3$s</xliff:g> ?</string>
     <string name="autofill_save_yes">Sàbhail</string>
     <string name="autofill_save_no">Na sàbhail</string>
     <string name="autofill_save_notnow">Chan ann an-dràsta</string>
@@ -2174,4 +2174,5 @@
     <string name="PERSOSUBSTATE_SIM_IMPI_SUCCESS">Chaidh a’ ghlas a thoirt far IMPI.</string>
     <string name="PERSOSUBSTATE_SIM_NS_SP_SUCCESS">Chaidh a’ ghlas a thoirt far fo-sheata an lìonraidh airson solaraiche na seirbheise.</string>
     <string name="device_state_notification_turn_off_button">Cuir dheth</string>
+    <string name="profile_label_work">Obair</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-kab-rDZ/strings.xml b/overlay/frameworks/base/core/res/res/values-kab-rDZ/strings.xml
index 8a99cd0..40de204 100644
--- a/overlay/frameworks/base/core/res/res/values-kab-rDZ/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-kab-rDZ/strings.xml
@@ -491,6 +491,7 @@
     <string name="toolbar_collapse_description">Ḍfes</string>
     <string name="zen_mode_feature_name">Ur yettcebbil ara</string>
     <string name="zen_mode_default_events_name">Tadyant</string>
+    <string name="zen_mode_implicit_deactivated">Insa</string>
     <string name="expand_button_content_description_collapsed">Snefli</string>
     <string name="expand_button_content_description_expanded">Ḍfes</string>
     <string name="floating_toolbar_open_overflow_description">Ugar n iɣewwaṛen</string>
@@ -579,4 +580,5 @@
     <string name="PERSOSUBSTATE_SIM_SIM_ERROR">Asuter n userreḥ n SIM ur yeddi ara.</string>
     <string name="PERSOSUBSTATE_RUIM_RUIM_ERROR">Asuter n userreḥ n RUIM ur yeddi ara.</string>
     <string name="device_state_notification_turn_off_button">Sens</string>
+    <string name="profile_label_work">Axeddim</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-ku/strings.xml b/overlay/frameworks/base/core/res/res/values-ku/strings.xml
index 424059b..30ed78e 100644
--- a/overlay/frameworks/base/core/res/res/values-ku/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-ku/strings.xml
@@ -1001,4 +1001,5 @@
     <string name="accessibility_system_action_home_label">ماڵ</string>
     <string name="accessibility_system_action_back_label">گەڕانەوە</string>
     <string name="resolver_work_tab">کار</string>
+    <string name="profile_label_work">کار</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-lb/strings.xml b/overlay/frameworks/base/core/res/res/values-lb/strings.xml
index efafb99..7153d52 100644
--- a/overlay/frameworks/base/core/res/res/values-lb/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-lb/strings.xml
@@ -1063,4 +1063,5 @@
     <string name="accessibility_system_action_home_label">Doheem</string>
     <string name="accessibility_system_action_back_label">Zréck</string>
     <string name="resolver_work_tab">Aarbecht</string>
+    <string name="profile_label_work">Aarbecht</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-sc-rIT/strings.xml b/overlay/frameworks/base/core/res/res/values-sc-rIT/strings.xml
index ec4dfa3..388aac6 100644
--- a/overlay/frameworks/base/core/res/res/values-sc-rIT/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-sc-rIT/strings.xml
@@ -1802,6 +1802,7 @@
     <string name="zen_mode_default_weekends_name">Fine de chida</string>
     <string name="zen_mode_default_events_name">Eventu</string>
     <string name="zen_mode_default_every_night_name">In pasu</string>
+    <string name="zen_mode_implicit_deactivated">Istudadu</string>
     <string name="muted_by"><xliff:g id="third_party">%1$s</xliff:g> est ponende unos cantos sonos a sa muda</string>
     <string name="system_error_wipe_data">B\'at unu problema internu cun su dispositivu tuo, diat pòdere èssere no istàbile finas a cando torras a is datos de fàbrica.</string>
     <string name="system_error_manufacturer">B\'at unu problema internu cun su dispositivu tuo. Cuntata s\'azienda de produtzione pro detàllios.</string>
@@ -1825,7 +1826,6 @@
     </string>
     <string name="work_mode_emergency_call_button">Emergèntzia</string>
     <string name="app_streaming_blocked_title"><xliff:g id="activity" example="Permission dialog">%1$s</xliff:g> no a disponimentu</string>
-    <string name="app_streaming_blocked_title_for_permission_dialog">Permissu netzessàriu</string>
     <string name="app_streaming_blocked_title_for_camera_dialog">Sa càmera no est a disponimentu</string>
     <string name="app_streaming_blocked_title_for_fingerprint_dialog">Sighi a su telèfonu</string>
     <string name="app_streaming_blocked_title_for_microphone_dialog">Su micròfonu no est a disponimentu</string>
@@ -1855,7 +1855,6 @@
     <string name="autofill_update_title">Boles atualizare su cuntenutu de &lt;xliff:g id="label" example="MyPass"&gt;%1$s&lt;/xliff:g&gt;&lt;/b&gt;?</string>
     <string name="autofill_update_title_with_type">Boles atualizare <xliff:g id="type" example="Credit Card">%1$s</xliff:g> in <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
     <string name="autofill_update_title_with_2types">Boles atualizare <xliff:g id="type" example="Password">%1$s</xliff:g> e <xliff:g id="type" example="Credit Card">%2$s</xliff:g> in <xliff:g id="label" example="MyPass">%3$s</xliff:g>?</string>
-    <string name="autofill_update_title_with_3types">Boles atualizare custos elementos in &lt;xliff:g id="label" example="MyPass"&gt;%4$s&lt;/xliff:g&gt;&lt;/b&gt;:&lt;xliff:g id="type" example="Username"&gt;%1$s&lt;/xliff:g&gt;, &lt;xliff:g id="type" example="Password"&gt;%2$s&lt;/xliff:g&gt;, e &lt;xliff:g id="type" example="Credit Card"&gt;%3$s&lt;/xliff:g&gt;?</string>
     <string name="autofill_save_yes">Sarva</string>
     <string name="autofill_save_no">No, gràtzias</string>
     <string name="autofill_save_notnow">No immoe</string>
@@ -1977,4 +1976,5 @@
     <string name="PERSOSUBSTATE_SIM_ICCID_SUCCESS">ICCID isblocadu.</string>
     <string name="PERSOSUBSTATE_SIM_IMPI_SUCCESS">IMPI isblocadu.</string>
     <string name="PERSOSUBSTATE_SIM_NS_SP_SUCCESS">Frunidura de servìtzios de su sutagrupu de rete isblocada.</string>
+    <string name="profile_label_work">Traballu</string>
 </resources>
diff --git a/overlay/frameworks/base/core/res/res/values-su/strings.xml b/overlay/frameworks/base/core/res/res/values-su/strings.xml
index 78eadc5..358a735 100644
--- a/overlay/frameworks/base/core/res/res/values-su/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-su/strings.xml
@@ -199,6 +199,7 @@
     <string-array name="face_error_vendor"/>
     <string name="ringtone_unknown">Teu dipikanyaho</string>
     <string name="confirm_battery_saver">Okéh</string>
+    <string name="zen_mode_implicit_deactivated">Pareum</string>
     <string name="notification_app_name_settings">Sétingan</string>
     <string name="notification_appops_camera_active">Kaméra</string>
     <string name="notification_appops_microphone_active">Mikrofon</string>
diff --git a/overlay/frameworks/base/core/res/res/values-ug/strings.xml b/overlay/frameworks/base/core/res/res/values-ug/strings.xml
index fbdeaa0..d424e7b 100644
--- a/overlay/frameworks/base/core/res/res/values-ug/strings.xml
+++ b/overlay/frameworks/base/core/res/res/values-ug/strings.xml
@@ -940,4 +940,5 @@
     <string name="accessibility_system_action_home_label">ئۆي</string>
     <string name="accessibility_system_action_back_label">قايت</string>
     <string name="resolver_work_tab">ئىش</string>
+    <string name="profile_label_work">ئىش</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-ast-rES/strings.xml
index fbedfb1..e73d27b 100644
--- a/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-ast-rES/strings.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
+    <string name="app_name">Comunicaciones de la operadora</string>
     <string name="android_system_label">Operadora telefónica</string>
     <string name="portal_notification_id">Los datos móviles escosaron</string>
     <string name="no_data_notification_id">Desactiváronse los datos móviles</string>
@@ -12,4 +13,10 @@
     <string name="ssl_error_warning">La rede a la que tentes de xunite tien problemes de seguranza.</string>
     <string name="ssl_error_example">Por exemplu, ye posible que la páxina d\'aniciu de sesión nun perteneza a la organización amosada.</string>
     <string name="ssl_error_continue">Siguir de toes toes pel restolador</string>
+    <string name="performance_boost_notification_channel">Aumentu del rindimientu</string>
+    <string name="performance_boost_notification_title">Opciones 5G de la operadora</string>
+    <string name="performance_boost_notification_detail">Visita\'l sitiu web de «%s» pa ver les opciones rellacionaes cola esperiencia na aplicación</string>
+    <string name="performance_boost_notification_button_not_now">Agora non</string>
+    <string name="performance_boost_notification_button_manage">Xestionar</string>
+    <string name="slice_purchase_app_label">Comprar un aumentu del rindimientu.</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-fur-rIT/strings.xml
index 8557372..86856cb 100644
--- a/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/CarrierDefaultApp/res/values-fur-rIT/strings.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
+    <string name="app_name">Comunicazions dal operadôr</string>
     <string name="android_system_label">Operadôr di telefonie mobile</string>
     <string name="portal_notification_id">Dâts mobii esaurîts</string>
     <string name="no_data_notification_id">I tiei dâts mobii a son stâts disativâts</string>
@@ -12,4 +13,10 @@
     <string name="ssl_error_warning">Tu stâs cirint di jentrâ suntune rêt che e à problemis di sigurece.</string>
     <string name="ssl_error_example">Par esempli, al è pussibil che la pagjine di acès no sedi de organizazion mostrade.</string>
     <string name="ssl_error_continue">Continue istès vie navigadôr</string>
+    <string name="performance_boost_notification_channel">Aument des prestazions</string>
+    <string name="performance_boost_notification_title">Opzions 5G dal to operadôr</string>
+    <string name="performance_boost_notification_detail">Visite il sît web di %s par viodi lis opzions pe tô esperience cu la aplicazion</string>
+    <string name="performance_boost_notification_button_not_now">No cumò</string>
+    <string name="performance_boost_notification_button_manage">Gjestìs</string>
+    <string name="slice_purchase_app_label">Compre un aument des prestazions</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-ast-rES/strings.xml
index 0c949ed..aa476cb 100644
--- a/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-ast-rES/strings.xml
@@ -15,9 +15,40 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_label">Xestor de preseos complementarios</string>
+    <string name="confirmation_title">¿Quies permitir que l\'aplicación &lt;strong&gt;<xliff:g id="app_name" example="Android Wear">%1$s</xliff:g>&lt;/strong&gt; acceda al preséu &lt;strong&gt;<xliff:g id="device_name" example="ASUS ZenWatch 2">%2$s</xliff:g>&lt;/strong&gt;?</string>
     <string name="profile_name_watch">reló</string>
+    <string name="chooser_title_non_profile">Escueyi un preséu pa que lu xestione &lt;strong&gt;<xliff:g id="app_name" example="Android Wear">%1$s</xliff:g>&lt;/strong&gt;</string>
+    <string name="chooser_title">Escueyi un perfil «<xliff:g id="profile_name" example="watch">%1$s</xliff:g>» pa configuralu</string>
+    <string name="summary_watch">Esta aplicación va poder sincronizar información, como\'l nome de los llamadores, y acceder a estos permisos nel preséu (<xliff:g id="device_name" example="phone">%1$s</xliff:g>)</string>
+    <string name="confirmation_title_glasses">¿Quies permitir a &lt;strong&gt;<xliff:g id="app_name" example="Android Wear">%1$s</xliff:g>&lt;/strong&gt; que xestione\'l preséu &lt;strong&gt;<xliff:g id="device_name" example="Glasses">%2$s</xliff:g>&lt;/strong&gt;?</string>
     <string name="profile_name_glasses">preséu</string>
+    <string name="summary_glasses">Esta aplicación va poder acceder a estos permisos del preséu (<xliff:g id="device_name" example="phone">%1$s</xliff:g>)</string>
+    <string name="helper_summary_app_streaming">«<xliff:g id="app_name" example="GMS">%1$s</xliff:g>» ta solicitanto permisu en nome del preséu «<xliff:g id="display_name" example="Chromebook">%2$s</xliff:g>» pa emitir aplicaciones ente los preseos</string>
+    <string name="helper_title_computer">Servicios de Google Play</string>
+    <string name="helper_summary_computer">«<xliff:g id="app_name" example="GMS">%1$s</xliff:g>» ta solicitanto permisu en nome del preséu «<xliff:g id="display_name" example="Chromebook">%2$s</xliff:g>» p\'acceder al conteníu multimedia y los avisos del teléfonu</string>
+    <string name="title_nearby_device_streaming">¿Quies permitir que\'l preséu &lt;strong&gt;<xliff:g id="device_name" example="NearbyStreamer">%1$s</xliff:g>&lt;/strong&gt; faiga esta aición?</string>
+    <string name="helper_summary_nearby_device_streaming">«<xliff:g id="app_name" example="NearbyStreamerApp">%1$s</xliff:g>» ta solicitanto permisu en nome del preséu «<xliff:g id="device_name" example="NearbyDevice">%2$s</xliff:g>» pa emitir aplicaciones y otres funciones del sistema a los preseos cercanos</string>
     <string name="profile_name_generic">preséu</string>
+    <string name="summary_generic">Esta aplicación va ser a sincronizar información, como\'l nome de los llamadores, ente\'l teléfonu y el preséu escoyíu</string>
     <string name="consent_yes">Permitir</string>
     <string name="consent_no">Nun permitir</string>
+    <string name="consent_cancel">Encaboxar</string>
+    <string name="permission_expand">Espander «<xliff:g id="permission_type" example="Notification">%1$s</xliff:g>»</string>
+    <string name="permission_collapse">Recoyer «<xliff:g id="permission_type" example="Notification">%1$s</xliff:g>»</string>
+    <string name="permission_sync_confirmation_title">¿Quies dar a les aplicaciones del preséu &lt;strong&gt;<xliff:g id="companion_device_name" example="Galaxy Watch 5">%1$s</xliff:g>&lt;/strong&gt; los mesmos permisos que tienen les del &lt;strong&gt;<xliff:g id="primary_device_name" example="Pixel 6">%2$s</xliff:g>&lt;/strong&gt;?</string>
+    <string name="permission_sync_summary">Esta aición pue incluyir l\'accesu al &lt;strong&gt;micrófonu&lt;/strong&gt;, la &lt;strong&gt;cámara&lt;/strong&gt; y la &lt;strong&gt;llocalización&lt;/strong&gt;, asina como a otros permisos sensibles del preséu &lt;strong&gt;<xliff:g id="companion_device_name" example="My Watch">%1$s</xliff:g>&lt;/strong&gt;.&lt;br/&gt;&lt;br/&gt;Pues camudar estos permisos cuando quieras na configuración del preséu &lt;strong&gt;<xliff:g id="companion_device_name" example="My Watch">%1$s</xliff:g>&lt;/strong&gt;.</string>
+    <string name="vendor_header_button_description">Más información</string>
+    <string name="permission_phone">Teléfonu</string>
+    <string name="permission_sms">SMS</string>
+    <string name="permission_contacts">Contautos</string>
+    <string name="permission_calendar">Calendariu</string>
+    <string name="permission_microphone">Micrófonu</string>
+    <string name="permission_call_logs">Rexistru de llamaes</string>
+    <string name="permission_nearby_devices">Preseos cercanos</string>
+    <string name="permission_notifications">Avisos</string>
+    <string name="permission_app_streaming">Aplicaciones</string>
+    <string name="permission_nearby_device_streaming">Emisión</string>
+    <string name="permission_nearby_device_streaming_summary">Emite aplicaciones y otres funciones del sistema dende\'l teléfonu</string>
+    <string name="device_type" product="default">teléfonu</string>
+    <string name="device_type" product="tablet">tableta</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-cy/strings.xml b/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-cy/strings.xml
index bb55bf5..c339375 100644
--- a/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-cy/strings.xml
+++ b/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-cy/strings.xml
@@ -26,8 +26,7 @@
     <string name="consent_no">Peidio â chaniatáu</string>
     <string name="consent_back">Nôl</string>
     <string name="permission_storage">Lluniau a chyfryngau</string>
-    <string name="permission_notification">Hysbysiadau</string>
+    <string name="permission_notifications">Hysbysiadau</string>
     <string name="permission_app_streaming">Apiau</string>
-    <string name="permission_notification_summary">Mae\u2019n gallu darllen pob hysbysiad, gan gynnwys gwybodaeth fel cysylltiadau, negeseuon a lluniau</string>
     <string name="permission_app_streaming_summary">Ffrydio apiau dy ffôn</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-fur-rIT/strings.xml
index 8db0c07..b5cb9c7 100644
--- a/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/CompanionDeviceManager/res/values-fur-rIT/strings.xml
@@ -15,19 +15,46 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_label">Gjestion dispositîfs associâts</string>
+    <string name="confirmation_title">Permeti ae aplicazion &lt;strong&gt;<xliff:g id="app_name" example="Android Wear">%1$s</xliff:g>&lt;/strong&gt; di acedi a &lt;strong&gt;<xliff:g id="device_name" example="ASUS ZenWatch 2">%2$s</xliff:g>&lt;/strong&gt;?</string>
     <string name="profile_name_watch">orloi</string>
+    <string name="chooser_title_non_profile">Sielç un dispositîf che al vegni gjestît di &lt;strong&gt;<xliff:g id="app_name" example="Android Wear">%1$s</xliff:g>&lt;/strong&gt;</string>
+    <string name="chooser_title">Sielç un <xliff:g id="profile_name" example="watch">%1$s</xliff:g> di configurâ</string>
+    <string name="summary_watch">Cheste aplicazion e varà il permès par sincronizâ informazions, come il non di cualchidun che al clame, e acedi a chescj permès sul to <xliff:g id="device_name" example="phone">%1$s</xliff:g></string>
+    <string name="confirmation_title_glasses">Permeti a &lt;strong&gt;<xliff:g id="app_name" example="Android Wear">%1$s</xliff:g>&lt;/strong&gt; di gjestî &lt;strong&gt;<xliff:g id="device_name" example="Glasses">%2$s</xliff:g>&lt;/strong&gt;?</string>
     <string name="profile_name_glasses">dispositîf</string>
+    <string name="summary_glasses">Cheste aplicazion e varà il permès par acedi a chescj permès sul to <xliff:g id="device_name" example="phone">%1$s</xliff:g></string>
     <string name="title_app_streaming">Permet a &lt;strong&gt;<xliff:g id="app_name" example="Exo">%1$s</xliff:g>&lt;/strong&gt; di acedi a cheste informazion dal to telefon</string>
     <string name="helper_title_app_streaming">Servizis inter-dispositîfs</string>
+    <string name="helper_summary_app_streaming"><xliff:g id="app_name" example="GMS">%1$s</xliff:g> e sta domandant il permès, par cont dal to <xliff:g id="display_name" example="Chromebook">%2$s</xliff:g>, par trasmeti aplicazions tra i tiei dispositîfs</string>
     <string name="title_computer">Permet a &lt;strong&gt;<xliff:g id="app_name" example="GMS">%1$s</xliff:g>&lt;/strong&gt; di acedi a cheste informazion dal to telefon</string>
     <string name="helper_title_computer">Servizis Google Play</string>
+    <string name="helper_summary_computer"><xliff:g id="app_name" example="GMS">%1$s</xliff:g> al sta domandant il permès, par cont dal to <xliff:g id="display_name" example="Chromebook">%2$s</xliff:g>, par acedi aes fotos, files multimediâi e notifichis dal to telefon</string>
+    <string name="title_nearby_device_streaming">Permeti a &lt;strong&gt;<xliff:g id="device_name" example="NearbyStreamer">%1$s</xliff:g>&lt;/strong&gt; di fâ cheste azion?</string>
+    <string name="helper_summary_nearby_device_streaming">La aplicazion <xliff:g id="app_name" example="NearbyStreamerApp">%1$s</xliff:g> e sta domandant un permès par cont dal to <xliff:g id="device_name" example="NearbyDevice">%2$s</xliff:g> par trasmeti aplicazions e altris funzionalitâts di sisteme ai dispositîfs tai contors</string>
     <string name="profile_name_generic">dispositîf</string>
+    <string name="summary_generic">Cheste aplicazion e rivarà a sincronizâ informazions, come il non di cualchidun che al clame, tra il to telefon e il dispositîf sielt</string>
     <string name="consent_yes">Permet</string>
     <string name="consent_no">No sta permeti</string>
+    <string name="consent_cancel">Anule</string>
     <string name="consent_back">Indaûr</string>
+    <string name="permission_expand">Slargjâ <xliff:g id="permission_type" example="Notification">%1$s</xliff:g></string>
+    <string name="permission_collapse">Strenzi <xliff:g id="permission_type" example="Notification">%1$s</xliff:g></string>
+    <string name="permission_sync_confirmation_title">Dâ aes aplicazions su &lt;strong&gt;<xliff:g id="companion_device_name" example="Galaxy Watch 5">%1$s</xliff:g>&lt;/strong&gt; i stes permès che a àn su &lt;strong&gt;<xliff:g id="primary_device_name" example="Pixel 6">%2$s</xliff:g>&lt;/strong&gt;?</string>
+    <string name="permission_sync_summary">Cheste operazion e podarès includi &lt;strong&gt;Microfon&lt;/strong&gt;, &lt;strong&gt;Fotocjamare&lt;/strong&gt;, &lt;strong&gt;acès ae Posizion&lt;/strong&gt; e altris permès sensibii su &lt;strong&gt;<xliff:g id="companion_device_name" example="My Watch">%1$s</xliff:g>&lt;/strong&gt;. &lt;br/&gt;&lt;br/&gt;Tu puedis cambiâ chescj  permès in cualsisei moment tes Impostazions su &lt;strong&gt;<xliff:g id="companion_device_name" example="My Watch">%1$s</xliff:g>&lt;/strong&gt;.</string>
+    <string name="vendor_header_button_description">Altris informazions</string>
+    <string name="permission_phone">Telefon</string>
+    <string name="permission_sms">SMS</string>
+    <string name="permission_contacts">Contats</string>
+    <string name="permission_calendar">Calendari</string>
+    <string name="permission_microphone">Microfon</string>
+    <string name="permission_call_logs">Regjistris clamadis</string>
+    <string name="permission_nearby_devices">Dispositîfs dongje</string>
     <string name="permission_storage">Fotos e multimedia</string>
-    <string name="permission_notification">Notifichis</string>
+    <string name="permission_notifications">Notifichis</string>
     <string name="permission_app_streaming">Aplicazions</string>
-    <string name="permission_notification_summary">Al pues lei dutis lis notifichis, includudis lis informazions come contats, messaçs e fotos</string>
+    <string name="permission_nearby_device_streaming">Trasmissions</string>
     <string name="permission_app_streaming_summary">Trasmet lis aplicazions dal to telefon</string>
+    <string name="permission_nearby_device_streaming_summary">Trasmeti aplicazions e altris funzions di sisteme dal to telefon</string>
+    <string name="device_type" product="default">telefon</string>
+    <string name="device_type" product="tablet">tablet</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/PackageInstaller/res/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/PackageInstaller/res/values-ast-rES/strings.xml
index 31f79d5..7db7b63 100644
--- a/overlay/frameworks/base/packages/PackageInstaller/res/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/PackageInstaller/res/values-ast-rES/strings.xml
@@ -44,6 +44,7 @@
         desconocíes</string>
     <string name="install_apps_user_restriction_dlg_text">Esti usuariu nun tien permisu pa instalar aplicaciones</string>
     <string name="ok">D\'acuerdu</string>
+    <string name="update_anyway">Anovar de toes toes</string>
     <string name="manage_applications">Xestionar aplics.</string>
     <string name="out_of_space_dlg_title">Ensin espaciu</string>
     <string name="out_of_space_dlg_text">«<xliff:g id="app_name">%1$s</xliff:g>» nun se pudo instalar. Llibera espaciu y volvi tentalo.</string>
@@ -63,14 +64,18 @@
     <string name="uninstall_update_text">¿Quies trocar la versión d\'esta aplicación pola de fábrica? Van desaniciase tolos datos.</string>
     <string name="uninstall_update_text_multiuser">¿Quies trocar la versión d\'esta aplicación pola de fábrica? Van desaniciase tolos datos. Esto afeuta a tolos usuarios del preséu, incluyíos los que tengan perfiles llaborales.</string>
     <string name="uninstall_keep_data">Caltener <xliff:g id="size" example="1.5MB">%1$s</xliff:g> de datos de l\'aplicación.</string>
+    <string name="uninstall_application_text_current_user_clone_profile">¿Quies desaniciar esta aplicación?</string>
+    <string name="uninstall_application_text_with_clone_instance">¿Quies desinstalar esta aplicación? Tamién va desaniciase\'l clon de: <xliff:g id="package_label">%1$s</xliff:g>.</string>
     <string name="uninstalling_notification_channel">Desinstalaciones n\'execución</string>
     <string name="uninstall_failure_notification_channel">Desinstalaciones fallíes</string>
     <string name="uninstalling">Desinstalando\u2026</string>
     <string name="uninstalling_app">Desinstalando «<xliff:g id="package_label">%1$s</xliff:g>»\u2026</string>
     <string name="uninstall_done">La desinstalación finó.</string>
     <string name="uninstall_done_app">Desinstalóse «<xliff:g id="package_label">%1$s</xliff:g>»</string>
+    <string name="uninstall_done_clone_app">Desanicióse\'l clon de: <xliff:g id="package_label">%1$s</xliff:g></string>
     <string name="uninstall_failed">Hebo un fallu na desinstalación.</string>
     <string name="uninstall_failed_app">Hebo un fallu al desinstalar «<xliff:g id="package_label">%1$s</xliff:g>».</string>
+    <string name="uninstalling_cloned_app">Desaniciando\'l clon de: <xliff:g id="package_label">%1$s</xliff:g>\u2026</string>
     <string name="uninstall_failed_device_policy_manager">Nun se pue desinstalar l\'aplicación
         activa del alministrador del preséu</string>
     <string name="uninstall_failed_device_policy_manager_of_user">Nun se pue desinstalar l\'aplicación
@@ -87,8 +92,6 @@
     <string name="manage_users">Xestionar los usuarios</string>
     <string name="uninstall_failed_msg">«<xliff:g id="app_name">%1$s</xliff:g>» nun se pue desinstalar.</string>
     <string name="Parse_error_dlg_text">Hebo un problema al analizar el paquete.</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
-    <string name="wear_not_allowed_dlg_text">Les aiciones de des/instalación nun son compatibles en Wear.</string>
     <string name="message_staging">Tresnando l\'aplicación…</string>
     <string name="app_name_unknown">Nome desconocíu</string>
     <string name="anonymous_source_warning" product="default">        Los datos personales y los del teléfonu son más
@@ -109,10 +112,13 @@
         de cualesquier dañu que se produza al preséu o de la
         perda de datos que resulte del usu de l\'aplicación.
     </string>
+    <string name="cloned_app_label">Clon de: <xliff:g id="package_label">%1$s</xliff:g></string>
     <string name="anonymous_source_continue">Siguir</string>
     <string name="external_sources_settings">Axustes</string>
     <string name="wear_app_channel">Des/instalación d\'aplicaciones de Wear</string>
     <string name="app_installed_notification_channel_description">Avisu d\'aplicación instalada</string>
     <string name="notification_installation_success_message">Instalóse correutamente</string>
     <string name="notification_installation_success_status">«<xliff:g id="appname" example="Package Installer">%1$s</xliff:g>» instalóse correutamente</string>
+    <string name="unarchive_action_required_continue">Siguir</string>
+    <string name="unarchive_settings_button">Axustes</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/PackageInstaller/res/values-cy/strings.xml b/overlay/frameworks/base/packages/PackageInstaller/res/values-cy/strings.xml
index 276cb48..e678358 100644
--- a/overlay/frameworks/base/packages/PackageInstaller/res/values-cy/strings.xml
+++ b/overlay/frameworks/base/packages/PackageInstaller/res/values-cy/strings.xml
@@ -78,8 +78,6 @@
     <string name="manage_users">Rheoli defnyddwyr</string>
     <string name="uninstall_failed_msg">Methwyd dadosod <xliff:g id="app_name">%1$s</xliff:g>.</string>
     <string name="Parse_error_dlg_text">Roedd problem wrth dosrannu\'r pecyn.</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
-    <string name="wear_not_allowed_dlg_text">Gosod/dadosod gweithredoedd na sy\'n gydnaws â Wear.</string>
     <string name="message_staging">Ap camau cadw…</string>
     <string name="app_name_unknown">Anhysbys</string>
     <string name="untrusted_external_source_warning" product="tablet">Am resymau diogelwch, dyw dy lechen ddim yn cael gosod apiau anhysbys o\'r ffynhonell hon. Gellir newid hyn yn Gosodiadau.</string>
@@ -94,4 +92,6 @@
     <string name="app_installed_notification_channel_description">Hysbysiad ap wedi\'i osod</string>
     <string name="notification_installation_success_message">Wedi\'i osod yn llwyddiannus</string>
     <string name="notification_installation_success_status">Wedi gosod \u201c<xliff:g id="appname" example="Package Installer">%1$s</xliff:g>\u201d yn llwyddiannus</string>
+    <string name="unarchive_action_required_continue">Parhau</string>
+    <string name="unarchive_settings_button">Gosodiadau</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/PackageInstaller/res/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/PackageInstaller/res/values-fur-rIT/strings.xml
index 0eac12c..7018a58 100644
--- a/overlay/frameworks/base/packages/PackageInstaller/res/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/PackageInstaller/res/values-fur-rIT/strings.xml
@@ -44,6 +44,7 @@
         cognossudis</string>
     <string name="install_apps_user_restriction_dlg_text">Chest utent nol à i permès par instalâ aplicazions</string>
     <string name="ok">Va ben</string>
+    <string name="update_anyway">Inzorne distès</string>
     <string name="manage_applications">Gjestìs aplicazions</string>
     <string name="out_of_space_dlg_title">Spazi esaurît</string>
     <string name="out_of_space_dlg_text">Nol è stât pussibil instalâ <xliff:g id="app_name">%1$s</xliff:g>. Libere un pôc di spazi e torne prove.</string>
@@ -64,14 +65,18 @@
     <string name="uninstall_update_text">Sostituî cheste aplicazion cu la version di fabriche? Ducj i dâts a vignaran gjavâts.</string>
     <string name="uninstall_update_text_multiuser">Sostituî cheste aplicazion cu la version di fabriche? Ducj i dâts a vignaran gjavâts. Chest al rivuarde ducj i utents di chest dispositîf, includûts chei cui profîi di lavôr.</string>
     <string name="uninstall_keep_data">Ten <xliff:g id="size" example="1.5MB">%1$s</xliff:g> di dâts di aplicazion.</string>
+    <string name="uninstall_application_text_current_user_clone_profile">Desideristu eliminâ cheste aplicazion?</string>
+    <string name="uninstall_application_text_with_clone_instance">Desideristu disinstalâ cheste aplicazion? Al vignarà eliminât ancje il clon di <xliff:g id="package_label">%1$s</xliff:g>.</string>
     <string name="uninstalling_notification_channel">Disinstalazions in esecuzion</string>
     <string name="uninstall_failure_notification_channel">Disinstalazions falidis</string>
     <string name="uninstalling">Daûr a disinstalâ\u2026</string>
     <string name="uninstalling_app">Daûr a disinstalâ <xliff:g id="package_label">%1$s</xliff:g>\u2026</string>
     <string name="uninstall_done">Disinstalazion completade.</string>
     <string name="uninstall_done_app"><xliff:g id="package_label">%1$s</xliff:g> disinstalât</string>
+    <string name="uninstall_done_clone_app">Clon di <xliff:g id="package_label">%1$s</xliff:g> eliminât</string>
     <string name="uninstall_failed">Disinstalazion lade strucje.</string>
     <string name="uninstall_failed_app">Disinstalazion di <xliff:g id="package_label">%1$s</xliff:g> lade strucje.</string>
+    <string name="uninstalling_cloned_app">Daûr a eliminâ il clon di <xliff:g id="package_label">%1$s</xliff:g>\u2026</string>
     <string name="uninstall_failed_device_policy_manager">Impussibil disinstalâ: il pachet al è un
         aministradôr di dispositîf atîf</string>
     <string name="uninstall_failed_device_policy_manager_of_user">Impussibil disinstalâ. Il pachet al è aminist.
@@ -86,12 +91,11 @@
     <string name="manage_users">Gjestìs utents</string>
     <string name="uninstall_failed_msg">Nol è stât pussibil disinstalâ <xliff:g id="app_name">%1$s</xliff:g>.</string>
     <string name="Parse_error_dlg_text">Al è vignût fûr un probleme tal analizâ il pachet.</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
-    <string name="wear_not_allowed_dlg_text">Lis azions Instale/Disinstale no son supuartadis su Wear.</string>
     <string name="message_staging">Preparazion de aplicazion…</string>
     <string name="app_name_unknown">No cognossût</string>
     <string name="untrusted_external_source_warning" product="tablet">Pe tô sigurece, pal moment il to tablet nol à i permès par instalâ aplicazions no cognossudis di cheste origjin. Tu puedis cambiâ cheste opzion tes Impostazions.</string>
     <string name="untrusted_external_source_warning" product="tv">Pe tô sigurece, pal moment la tô TV no à i permès par instalâ aplicazions no cognossudis di cheste origjin. Tu puedis cambiâ cheste opzion tes Impostazions.</string>
+    <string name="untrusted_external_source_warning" product="watch">Pe tô sigurece, pal moment il to orloi nol à i permès par instalâ aplicazions no cognossudis di cheste origjin. Tu puedis cambiâ cheste opzion tes Impostazions.</string>
     <string name="untrusted_external_source_warning" product="default">Pe tô sigurece, pal moment il to telefon nol à i permès par instalâ aplicazions no cognossudis di cheste origjin. Tu puedis cambiâ cheste opzion tes Impostazions.</string>
     <string name="anonymous_source_warning" product="default">        Il to telefon e i tiei dâts personâi a son plui vulnerabii
         ai atacs di aplicazions no cognossudis. Se tu instalis cheste
@@ -108,10 +112,13 @@
         aplicazion tu acetis di jessi responsabil di eventuâi dams
         ae tô TV o de eventuâl pierdite di dâts dovude al lôr ûs.
     </string>
+    <string name="cloned_app_label">Clon di <xliff:g id="package_label">%1$s</xliff:g></string>
     <string name="anonymous_source_continue">Continue</string>
     <string name="external_sources_settings">Impostazions</string>
     <string name="wear_app_channel">Instalazion/disinstalazion aplicaz. wear</string>
     <string name="app_installed_notification_channel_description">Notifiche di aplicazion instalade</string>
     <string name="notification_installation_success_message">Instalade cun sucès</string>
     <string name="notification_installation_success_status">Aplicazion \u201c<xliff:g id="appname" example="Package Installer">%1$s</xliff:g>\u201d instalade cun sucès</string>
+    <string name="unarchive_action_required_continue">Continue</string>
+    <string name="unarchive_settings_button">Impostazions</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/PackageInstaller/res/values-gd/strings.xml b/overlay/frameworks/base/packages/PackageInstaller/res/values-gd/strings.xml
index a6230ea..f49a798 100644
--- a/overlay/frameworks/base/packages/PackageInstaller/res/values-gd/strings.xml
+++ b/overlay/frameworks/base/packages/PackageInstaller/res/values-gd/strings.xml
@@ -81,8 +81,6 @@
     <string name="manage_users">Stiùir na cleachdaichean</string>
     <string name="uninstall_failed_msg">Cha b’ urrainn dhuinn <xliff:g id="app_name">%1$s</xliff:g> a dhì-stàladh.</string>
     <string name="Parse_error_dlg_text">Bha duilgheadas le parsadh na pacaid.</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
-    <string name="wear_not_allowed_dlg_text">Cha chuir Wear taic ri gnìomhan stàlaidh/dì-stàlaidh.</string>
     <string name="message_staging">Ag ullachadh na h-aplacaid…</string>
     <string name="app_name_unknown">Chan eil fhios</string>
     <string name="anonymous_source_warning" product="default">        Tha am fòn ’s an dàta pearsanta agad nas so-leònta
@@ -106,4 +104,6 @@
     <string name="app_installed_notification_channel_description">Brath air stàladh aplacaid</string>
     <string name="notification_installation_success_message">Chaidh a stàladh</string>
     <string name="notification_installation_success_status">Chaidh “<xliff:g id="appname" example="Package Installer">%1$s</xliff:g>” a stàladh</string>
+    <string name="unarchive_action_required_continue">Air adhart</string>
+    <string name="unarchive_settings_button">Roghainnean</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/arrays.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/arrays.xml
index bfd440f..5818aba 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/arrays.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/arrays.xml
@@ -61,6 +61,17 @@
         <item>Activóse con peñeres</item>
         <item>Activóse</item>
     </string-array>
+    <string-array name="bt_hci_snoop_log_filters_entries">
+        <item>Dexar namás les testeres d\'ACL</item>
+        <item>Peñerar los paquetes multimedia A2DP</item>
+        <item>Peñerar la canal RFCOMM</item>
+    </string-array>
+    <string-array name="bt_hci_snoop_log_profile_filter_entries">
+        <item>Desactivóse</item>
+        <item>Rellena con una cadena de caráuteres</item>
+        <item>Dexa namás les testeres</item>
+        <item>Quita completamente</item>
+    </string-array>
     <string-array name="bluetooth_avrcp_versions">
         <item>AVRCP 1.5 (por defeutu)</item>
         <item>AVRCP 1.3</item>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/strings.xml
index 2754ee8..c23d930 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-ast-rES/strings.xml
@@ -77,6 +77,7 @@
     <string name="bluetooth_battery_level"><xliff:g id="battery_level_as_percentage">%1$s</xliff:g> de batería</string>
     <string name="bluetooth_battery_level_untethered">E: <xliff:g id="battery_level_as_percentage" example="25%">%1$s</xliff:g> de batería, D: <xliff:g id="battery_level_as_percentage" example="25%">%2$s</xliff:g> de batería</string>
     <string name="bluetooth_active_no_battery_level">N\'activo</string>
+    <string name="bluetooth_saved_device">Guardóse</string>
     <string name="bluetooth_profile_a2dp">Audiu multimedia</string>
     <string name="bluetooth_profile_headset">Llamaes telefóniques</string>
     <string name="bluetooth_profile_opp">Tresferencia de ficheros</string>
@@ -87,6 +88,9 @@
     <string name="bluetooth_profile_sap">Accesu a la SIM</string>
     <string name="bluetooth_profile_a2dp_high_quality">Audiu HD: <xliff:g id="codec_name">%1$s</xliff:g></string>
     <string name="bluetooth_profile_a2dp_high_quality_unknown_codec">Audiu HD</string>
+    <string name="bluetooth_profile_hearing_aid">Audífonos</string>
+    <string name="bluetooth_profile_le_audio">Audiu LE</string>
+    <string name="bluetooth_hearing_aid_profile_summary_connected">Conectóse a los audífonos</string>
     <string name="bluetooth_a2dp_profile_summary_connected">Conectóse al audiu multimedia</string>
     <string name="bluetooth_headset_profile_summary_connected">Conectóse al audiu del teléfonu</string>
     <string name="bluetooth_opp_profile_summary_connected">Conectóse al sirvidor de tresferencia de ficheros</string>
@@ -103,6 +107,7 @@
     <string name="bluetooth_headset_profile_summary_use_for">Úsase pal audiu del teléfonu</string>
     <string name="bluetooth_opp_profile_summary_use_for">Úsase pa la tresferencia de ficheros</string>
     <string name="bluetooth_hid_profile_summary_use_for">Úsase pa la entrada</string>
+    <string name="bluetooth_hearing_aid_profile_summary_use_for">Úsase pa los audífonos</string>
     <string name="bluetooth_pairing_accept">Empareyar</string>
     <string name="bluetooth_pairing_accept_all_caps">EMPAREYAR</string>
     <string name="bluetooth_pairing_decline">Encaboxar</string>
@@ -196,6 +201,7 @@
     <string name="choose_profile">Escoyeta d\'un perfil</string>
     <string name="category_personal">Personal</string>
     <string name="category_work">Llaboral</string>
+    <string name="category_clone">Clonación</string>
     <string name="development_settings_title">Opciones pa desendolcadores</string>
     <string name="development_settings_enable">Activar les opciones pa desendolcadores</string>
     <string name="development_settings_summary">Afita les opciones pal desendolcu d\'aplicaciones</string>
@@ -243,7 +249,7 @@
     <string name="oem_unlock_enable">Desbloquéu d\'OEM</string>
     <string name="oem_unlock_enable_summary">Permite desbloquiar el cargador d\'arrinque</string>
     <string name="confirm_enable_oem_unlock_title">¿Quies permitir el desbloquéu d\'OEM?</string>
-    <string name="confirm_enable_oem_unlock_text">ALVERTENCIA: les carauterístiques de proteición del preséu nun van funcionar mentanto esti axuste tea activáu.</string>
+    <string name="confirm_enable_oem_unlock_text">ALVERTENCIA: les funciones de proteición del preséu nun van funcionar mentanto esti axuste tea activáu.</string>
     <string name="mock_location_app">Esbillar l\'aplicación de llocalización ficticia</string>
     <string name="mock_location_app_not_set">Nun s\'afitó l\'aplicación de llocalización ficticia</string>
     <string name="mock_location_app_set">Aplicación de llocalización ficticia: <xliff:g id="app_name">%1$s</xliff:g></string>
@@ -310,8 +316,8 @@
     <string name="verify_apps_over_usb_summary">Comprueba les aplicaciones instalaes per ADB/ADT pa detectar comportamientos peligrosos.</string>
     <string name="bluetooth_show_devices_without_names_summary">Los preseos Bluetooth van apaecer ensin el nome (namás la direición MAC)</string>
     <string name="bluetooth_disable_absolute_volume_summary">Desactiva la función del volume absolutu del Bluetooth nel casu d\'haber problemes colos preseos remotos, como un volume peraltu o una falta de control.</string>
-    <string name="bluetooth_enable_gabeldorsche_summary">Activa la pila de carauterístiques de Bluetooth «Gabeldorsche».</string>
-    <string name="enhanced_connectivity_summary">Activa la carauterística «Conectividá ameyorada».</string>
+    <string name="bluetooth_enable_gabeldorsche_summary">Activa la pila de funciones de Bluetooth «Gabeldorsche».</string>
+    <string name="enhanced_connectivity_summary">Activa la función «Conectividá ameyorada».</string>
     <string name="enable_terminal_title">Terminal llocal</string>
     <string name="enable_terminal_summary">Activa l\'aplicación «Terminal» qu\'ufre accesu a la shell llocal</string>
     <string name="hdcp_checking_title">Comprobación HDCP</string>
@@ -338,6 +344,8 @@
     <string name="pointer_location_summary">Una superposición de pantalla qu\'amuesa los datos táctiles</string>
     <string name="show_touches">Amosar los toques</string>
     <string name="show_touches_summary">Amuesa un indicador onde se faen los toques</string>
+    <string name="show_key_presses">Amosar los calcos de les tecles</string>
+    <string name="show_key_presses_summary">Amuesa una rempuesta visual de les tecles físiques primíes</string>
     <string name="show_screen_updates">Anovamientos de superficie</string>
     <string name="show_screen_updates_summary">Relluma toles superficies de les ventanes al anovales</string>
     <string name="show_hw_screen_updates">Anov. de visualización</string>
@@ -355,6 +363,8 @@
     <string name="debug_layout_summary">Amuesa les llendes de los clips, los márxenes, etc.</string>
     <string name="force_rtl_layout_all_locales">Forciar el diseñu «derecha-esquierda»</string>
     <string name="force_rtl_layout_all_locales_summary">Forcia\'l diseñu «derecha-esquierda» en toles locales</string>
+    <string name="transparent_navigation_bar">Barra de navegación tresparente</string>
+    <string name="transparent_navigation_bar_summary">Fai que\'l color del fondu de la barra de navegación seya tresparente por defeutu</string>
     <string name="force_msaa">Forciar el MSAA x4</string>
     <string name="force_msaa_summary">Activa\'l MSAA x4 nes aplicaciones d\'OpenGL ES 2.0</string>
     <string name="show_non_rect_clip">Depurar les operaciones de recorte que nun son rectangulares</string>
@@ -434,12 +444,6 @@
     <string name="power_remaining_less_than_duration">Tiempu que queda: menos de <xliff:g id="threshold">%1$s</xliff:g> (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_more_than_subtext">Tiempu que queda: más de <xliff:g id="time_remaining">%1$s</xliff:g> (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_only_more_than_subtext">Tiempu que queda: más de <xliff:g id="time_remaining">%1$s</xliff:g></string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="default">El teléfonu pue apagase pronto</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="tablet">La tableta pue apagase pronto</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="device">El preséu pue apagase pronto</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="default">El teléfonu pue apagase pronto (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="tablet">La tableta pue apagase pronto (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="device">El preséu pue apagase pronto (<xliff:g id="level">%1$s</xliff:g>)</string>
     <string name="power_charging"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="state">%2$s</xliff:g></string>
     <string name="power_remaining_charging_duration_only"><xliff:g id="time">%1$s</xliff:g> pa completar la carga</string>
     <string name="power_charging_duration"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="time">%2$s</xliff:g> pa completar la carga</string>
@@ -492,6 +496,7 @@
     <string name="accessibility_manual_zen_less_time">Menos tiempu.</string>
     <string name="cancel">Encaboxar</string>
     <string name="next">Siguiente</string>
+    <string name="back">Atrás</string>
     <string name="okay">Velocidá aceptable</string>
     <string name="alarms_and_reminders_label">Alarmes y recordatorios</string>
     <string name="alarms_and_reminders_title">Alarmes y recordatorios</string>
@@ -509,7 +514,17 @@
     <string name="zen_mode_forever">Hasta desactivar esta opción</string>
     <string name="time_unit_just_now">Puramente agora</string>
     <string name="media_transfer_this_device_name" product="default">Esti teléfonu</string>
+    <string name="media_transfer_dock_speaker_device_name">Altavoces de la base</string>
+    <string name="media_transfer_external_device_name">Preséu esternu</string>
+    <string name="media_transfer_default_device_name">Preséu conectáu</string>
     <string name="media_transfer_this_phone">Esti teléfonu</string>
+    <string name="media_output_status_unknown_error">Nun se pue reproducir nesti preséu</string>
+    <string name="media_output_status_require_premium">Anueva la cuenta pa cambiar</string>
+    <string name="media_output_status_not_support_downloads">Equí nun se puen reproducir les descargues</string>
+    <string name="media_output_status_try_after_ad">Volvi probar dempués del anunciu</string>
+    <string name="media_output_status_device_in_low_power_mode">Esconsoña\'l preséu pa reproducir equí</string>
+    <string name="media_output_status_unauthorized">El preséu nun tien l\'aprobación pa reproducir</string>
+    <string name="media_output_status_track_unsupported">Equí nun se pue reproducir esti conteníu multimedia</string>
     <string name="profile_connect_timeout_subtext">Hebo un problema al conectar. Apaga y volvi prender el preséu</string>
     <string name="media_transfer_wired_device_name">Preséu d\'audiu con cable</string>
     <string name="help_label">Ayuda y opiniones</string>
@@ -534,6 +549,9 @@
     <string name="user_add_user_title">¿Quies amestar un usuariu?</string>
     <string name="user_add_user_message_long">Pues compartir esti preséu con otres persones pente la creación d\'usuarios adicionales. Cada usuariu tien el so espaciu que puen personalizar con aplicaciones, fondos de pantalla y más coses. Los usuarios tamién pue configurar los axustes del preséu, como\'l Wi\u2011Fi, qu\'afeuta a tol mundu.\n\nCuando amiestes un usuariu nuevu, esta persona va tener de configurar el so espaciu.\n\nCualesquier usuariu pue anovar les aplicaciones de los demás. Sicasí, ye posible que los axustes y servicios d\'accesibilidá nun puedan tresferise al usuariu nuevu.</string>
     <string name="user_add_user_message_short">Cuando amiestes un usuariu, esti tien de configurar el so espaciu.\n\nCualesquier usuariu pue anovar les aplicaciones de los demás usuarios. </string>
+    <string name="user_grant_admin_title">¿Quies convertir esti usuariu n\'alministrador?</string>
+    <string name="user_grant_admin_message">Los alministradores tienen privilexos especiales qu\'otros usuarios nun tienen. Un alministrador pue xestionar tolos usuarios, anovar o reafitar el preséu, modificar la configuración, ver toles aplicaciones instalaes y conceder o revocar privilexos d\'alministrador a otros usuarios.</string>
+    <string name="user_grant_admin_button">Convertir n\'alministrador</string>
     <string name="user_setup_dialog_title">¿Configurar l\'usuariu agora?</string>
     <string name="user_setup_dialog_message">Asegúrate de que la persona pue acceder al preséu y configurar el so espaciu</string>
     <string name="user_setup_profile_dialog_message">¿Quies configurar un perfil agora?</string>
@@ -551,6 +569,8 @@
     <string name="user_nickname">Nomatu</string>
     <string name="guest_new_guest">Amestar un convidáu</string>
     <string name="guest_exit_guest">Quitar al convidáu</string>
+    <string name="grant_admin">Sí, convertir n\'alministrador</string>
+    <string name="not_grant_admin">Non, nun convertir n\'alministrador</string>
     <string name="cached_apps_freezer_device_default">Comportamientu predetermináu</string>
     <string name="cached_apps_freezer_disabled">Desactivóse</string>
     <string name="cached_apps_freezer_enabled">Activóse</string>
@@ -570,4 +590,5 @@
     <string name="data_connection_5ge_html" translate="false"> &lt;i&gt;5G &lt;small&gt;E&lt;/small&gt;&lt;/i&gt; </string>
     <string name="data_connection_carrier_wifi">W+</string>
     <string name="keyboard_layout_default_label">Por defeutu</string>
+    <string name="font_scale_percentage"> <xliff:g id="percentage">%1$d</xliff:g>%%</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-cy/arrays.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-cy/arrays.xml
index 4514ec9..fc00d97 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-cy/arrays.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-cy/arrays.xml
@@ -269,4 +269,10 @@
         <item>Ffynhonnell Sain</item>
         <item>MIDI</item>
     </string-array>
+    <string-array name="grammatical_gender_values">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+    </string-array>
 </resources>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-cy/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-cy/strings.xml
index ddb0111..a0f5cba 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-cy/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-cy/strings.xml
@@ -77,6 +77,7 @@
     <string name="bluetooth_battery_level"><xliff:g id="battery_level_as_percentage">%1$s</xliff:g> batri</string>
     <string name="bluetooth_battery_level_untethered">Ch: <xliff:g id="battery_level_as_percentage" example="25%">%1$s</xliff:g> batri, D: <xliff:g id="battery_level_as_percentage" example="25%">%2$s</xliff:g> batri</string>
     <string name="bluetooth_active_no_battery_level">Gweithredol</string>
+    <string name="bluetooth_saved_device">Wedi ei gofio</string>
     <string name="bluetooth_hearing_aid_left_active">Gweithredol, chwith yn unig</string>
     <string name="bluetooth_hearing_aid_right_active">Gweithredol, dde yn unig</string>
     <string name="bluetooth_hearing_aid_left_and_right_active">Gweithredol, dde a chwith</string>
@@ -85,8 +86,6 @@
     <string name="bluetooth_profile_opp">Trosglwyddo ffeiliau</string>
     <string name="bluetooth_profile_hid">Dyfeisiau mewnbwn</string>
     <string name="bluetooth_profile_pan">Mynediad at y rhyngrwyd</string>
-    <string name="bluetooth_profile_pbap">Rhannu cysylltiadau a hanes galwadau</string>
-    <string name="bluetooth_profile_pbap_summary">Defyddio ar gyfer rhannu cysylltiadau a hanes galwadau</string>
     <string name="bluetooth_profile_pan_nap">Rhannu cysylltiad i\'r rhyngrwyd</string>
     <string name="bluetooth_profile_map">Negeseuon Testun</string>
     <string name="bluetooth_profile_sap">Mynediad SIM</string>
@@ -384,7 +383,6 @@
     <string name="force_resizable_activities_summary">Gwneud pob gweithgaredd yn ailfeintiol ar gyfer aml-ffenestr, beth bynnag eu gwerth maniffest.</string>
     <string name="enable_freeform_support">Galluogi ffenestri ffurfrydd</string>
     <string name="enable_freeform_support_summary">Galluogi cefnogaeth ar gyfer ffenestri ffurfrydd arbrofol.</string>
-    <string name="desktop_mode">Modd bwrdd gwaith</string>
     <string name="local_backup_password_title">Cyfrinair cadw wrth gefn i gyfrifiadur</string>
     <string name="local_backup_password_summary_none">Dyw copïau llawn wrth gefn i gyfrifiadur ddim yn cael eu diogelu ar hyn o bryd.</string>
     <string name="local_backup_password_summary_change">Tapia i newid neu dynnu\'r cyfrinair ar gyfer cadw popeth wrth gefn ar gyfrifiadur.</string>
@@ -448,12 +446,6 @@
     <string name="power_remaining_less_than_duration">Llai na <xliff:g id="time_remaining">%1$s</xliff:g> yn weddill (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_more_than_subtext">Mwy na <xliff:g id="time_remaining">%1$s</xliff:g> yn weddill (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_only_more_than_subtext">Mwy na <xliff:g id="time_remaining">%1$s</xliff:g> yn weddill</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="default">Gallai\'r ffôn diffodd yn fuan</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="tablet">Gallai\'r llechen diffodd yn fuan</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="device">Gallai\'r ddyfais diffodd yn fuan</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="default">Gallai\'r ffôn diffodd yn fuan (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="tablet">Gallai\'r llechen diffodd yn fuan (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="device">Gallai\'r ddyfais diffodd yn fuan (<xliff:g id="level">%1$s</xliff:g>)</string>
     <string name="power_charging"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="state">%2$s</xliff:g></string>
     <string name="power_remaining_charging_duration_only"><xliff:g id="time">%1$s</xliff:g> nes yn llawn</string>
     <string name="power_charging_duration"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="time">%2$s</xliff:g> nes yn llawn</string>
@@ -504,13 +496,6 @@
     <string name="ims_reg_status_not_registered">"Heb gofrestru"</string>
     <string name="status_unavailable">Dim ar gael</string>
     <string name="wifi_status_mac_randomized">MAC wedi\'i osod ar hap</string>
-    <string name="wifi_tether_connected_summary">        {count, plural,
-=0    {0 dyfeisiau wedi\'u cysylltu}
-            =1    {1 dyfais wedi\'i chysylltu}
-            two {# ddyfais wedi\'u cysylltu}
-other {# dyfais wedi\'u cysylltu}
-        }
-    </string>
     <string name="accessibility_manual_zen_more_time">Mwy o amser.</string>
     <string name="accessibility_manual_zen_less_time">Llai o amser.</string>
     <string name="cancel">Diddymu</string>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-eo/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-eo/strings.xml
index 2b7b03e..daac4a3 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-eo/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-eo/strings.xml
@@ -28,6 +28,7 @@
     <string name="wifi_remembered">Konservita</string>
     <string name="wifi_disconnected">Malkonektita</string>
     <string name="bluetooth_disconnected">Malkonektita</string>
+    <string name="bluetooth_saved_device">Konservita</string>
     <string name="bluetooth_pairing_decline">Nuligi</string>
     <string name="data_usage_uninstalled_apps">Forigitaj aplikaĵoj</string>
     <string name="data_usage_uninstalled_apps_users">Forigitaj aplikaĵoj kaj uzantoj</string>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/arrays.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/arrays.xml
index eed4c69..2c72848 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/arrays.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/arrays.xml
@@ -61,6 +61,17 @@
         <item>Ativât cun filtri</item>
         <item>Ativât</item>
     </string-array>
+    <string-array name="bt_hci_snoop_log_filters_entries">
+        <item>Lasse dome lis intestazions ACL</item>
+        <item>Filtre i pachets multimediâi A2DP</item>
+        <item>Filtre il canâl RFCOMM</item>
+    </string-array>
+    <string-array name="bt_hci_snoop_log_profile_filter_entries">
+        <item>Disative</item>
+        <item>Jemple cuntune stringhe di caratars</item>
+        <item>Lasse dome la intestazion</item>
+        <item>Gjave dal dut</item>
+    </string-array>
     <string-array name="bluetooth_avrcp_versions">
         <item>AVRCP 1.5 (predefinît)</item>
         <item>AVRCP 1.3</item>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/strings.xml
index 52555a5..a630fb3 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-fur-rIT/strings.xml
@@ -70,6 +70,7 @@
     <string name="bluetooth_battery_level"><xliff:g id="battery_level_as_percentage">%1$s</xliff:g> di batarie</string>
     <string name="bluetooth_battery_level_untethered">Ç: batarie al <xliff:g id="battery_level_as_percentage" example="25%">%1$s</xliff:g>, D: batarie al <xliff:g id="battery_level_as_percentage" example="25%">%2$s</xliff:g></string>
     <string name="bluetooth_active_no_battery_level">Atîf</string>
+    <string name="bluetooth_saved_device">Salvât</string>
     <string name="bluetooth_hearing_aid_left_active">Ative, dome a çampe</string>
     <string name="bluetooth_hearing_aid_right_active">Ative, dome a diestre</string>
     <string name="bluetooth_hearing_aid_left_and_right_active">Ative, a çampe e a diestre</string>
@@ -78,13 +79,14 @@
     <string name="bluetooth_profile_opp">Trasferiment files</string>
     <string name="bluetooth_profile_hid">Dispositîf di input</string>
     <string name="bluetooth_profile_pan">Acès a internet</string>
-    <string name="bluetooth_profile_pbap">Condivision contats e cronologjie clamadis</string>
-    <string name="bluetooth_profile_pbap_summary">Dopre par condivision di contats e cronologjie clamadis</string>
     <string name="bluetooth_profile_pan_nap">Condivision conession internet</string>
     <string name="bluetooth_profile_map">Messaçs di test</string>
     <string name="bluetooth_profile_sap">Acès ae SIM</string>
     <string name="bluetooth_profile_a2dp_high_quality">Audio HD: <xliff:g id="codec_name">%1$s</xliff:g></string>
     <string name="bluetooth_profile_a2dp_high_quality_unknown_codec">Audio HD</string>
+    <string name="bluetooth_profile_hearing_aid">Aparâts acustics</string>
+    <string name="bluetooth_profile_le_audio">Audio LE</string>
+    <string name="bluetooth_hearing_aid_profile_summary_connected">Colegât ai aparâts acustics</string>
     <string name="bluetooth_le_audio_profile_summary_connected">Conetût a audio LE</string>
     <string name="bluetooth_a2dp_profile_summary_connected">Colegât al audio multimdiâl</string>
     <string name="bluetooth_headset_profile_summary_connected">Colegât al audio dal telefon</string>
@@ -102,6 +104,7 @@
     <string name="bluetooth_headset_profile_summary_use_for">Doprâ pal audio dal telefon</string>
     <string name="bluetooth_opp_profile_summary_use_for">Doprâ pal trasferiment files</string>
     <string name="bluetooth_hid_profile_summary_use_for">Doprâ pal input</string>
+    <string name="bluetooth_hearing_aid_profile_summary_use_for">Doprâ pai aparâts acustics</string>
     <string name="bluetooth_le_audio_profile_summary_use_for">Dopre par LE_AUDIO</string>
     <string name="bluetooth_pairing_accept">Associe</string>
     <string name="bluetooth_pairing_accept_all_caps">ASSOCIE</string>
@@ -196,6 +199,7 @@
     <string name="choose_profile">Sielç un profîl</string>
     <string name="category_personal">Personâl</string>
     <string name="category_work">Lavôr</string>
+    <string name="category_clone">Clon</string>
     <string name="development_settings_title">Opzions pal svilupadôr</string>
     <string name="development_settings_enable">Abilite lis opzions pal svilupadôr</string>
     <string name="development_settings_summary">Stabilìs lis opzions pal disvilup des aplicazions</string>
@@ -338,6 +342,8 @@
     <string name="pointer_location_summary">Soreposizion dal schermi che al mostre i dâts atuâi des tocjadis</string>
     <string name="show_touches">Mostre tocjadis</string>
     <string name="show_touches_summary">Mostre lis rispuestis visivis pes tocjadis</string>
+    <string name="show_key_presses">Mostre pressions tascj</string>
+    <string name="show_key_presses_summary">Mostre la retroazion visive pes pressions fisichis dai tascj</string>
     <string name="show_screen_updates">Mostre i inzornaments de superficie</string>
     <string name="show_screen_updates_summary">Lampe dutis lis superficiis dal barcon cuant che si inzornin</string>
     <string name="show_hw_screen_updates">Mostre i inzornaments de viodude</string>
@@ -355,6 +361,8 @@
     <string name="debug_layout_summary">Mostre limits dal ritai, margjins e v.i.</string>
     <string name="force_rtl_layout_all_locales">Sfuarce direzion disposizion RTL(DAÇ)</string>
     <string name="force_rtl_layout_all_locales_summary">Sfuarce la direzion de disposizion dal schermi a RTL (di drete a çampe) par dutis lis localizazions</string>
+    <string name="transparent_navigation_bar">Sbare di navigazion trasparente</string>
+    <string name="transparent_navigation_bar_summary">Rint trasparent, tant che impostazion predefinide, il colôr dal fonts de sbare di navigazion</string>
     <string name="window_blurs">Permet fûr fûcs a nivel di barcon</string>
     <string name="force_msaa">Sfuarce MSAA 4x</string>
     <string name="force_msaa_summary">Ative il MSAA 4x tes aplicazions OpenGL ES 2.0</string>
@@ -383,7 +391,6 @@
     <string name="force_resizable_activities_summary">Fâs in mût che dutis lis ativitâts si podedin ridimensionâ pai barcons multiplis, in mût indipendent dai valôrs dal manifest.</string>
     <string name="enable_freeform_support">Abilite i barcons a forme libare</string>
     <string name="enable_freeform_support_summary">Abilite il supuart pai barcons a forme libare sperimentâi.</string>
-    <string name="desktop_mode">Modalitât scritori</string>
     <string name="local_backup_password_title">Password backup computer</string>
     <string name="local_backup_password_summary_none">I backups complets dal computer locâl al moment no son protets</string>
     <string name="local_backup_password_summary_change">Tocje par cambiâ o gjavâla password pai backups complets dal computer</string>
@@ -448,12 +455,6 @@
     <string name="power_remaining_less_than_duration">Cjarie residue: mancul di <xliff:g id="threshold">%1$s</xliff:g> (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_more_than_subtext">Timp residui: plui di <xliff:g id="time_remaining">%1$s</xliff:g> (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_only_more_than_subtext">Timp residui: plui di <xliff:g id="time_remaining">%1$s</xliff:g></string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="default">Il telefon al podarès distudâsi chi di pôc</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="tablet">Il tablet al podarès distudâsi chi di pôc</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="device">Il dispositîf al podarès distudâsi chi di pôc</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="default">Il telefon al podarès distudâsi chi di pôc (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="tablet">Il tablet al podarès distudâsi chi di pôc (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="device">Il dispositîf al podarès distudâsi chi di pôc (<xliff:g id="level">%1$s</xliff:g>)</string>
     <string name="power_charging"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="state">%2$s</xliff:g></string>
     <string name="power_remaining_charging_duration_only"><xliff:g id="time">%1$s</xliff:g> pe ricjarie complete</string>
     <string name="power_charging_duration"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="time">%2$s</xliff:g> pe ricjarie complete</string>
@@ -508,16 +509,11 @@
     <string name="ims_reg_status_not_registered">"No regjistrât"</string>
     <string name="status_unavailable">No disponibil</string>
     <string name="wifi_status_mac_randomized">La direzion MAC e je casuâl</string>
-    <string name="wifi_tether_connected_summary">        {count, plural,
-            one {}=0    {0 dispositîf conetût}
-            =1    {1 dispositîf conetût}
-            other {# dispositîfs conetûts}
-        }
-    </string>
     <string name="accessibility_manual_zen_more_time">Plui timp.</string>
     <string name="accessibility_manual_zen_less_time">Mancul timp.</string>
     <string name="cancel">Anule</string>
     <string name="next">Indenant</string>
+    <string name="back">Indaûr</string>
     <string name="save">Salve</string>
     <string name="okay">Va ben</string>
     <string name="done">Fat</string>
@@ -544,7 +540,17 @@
     <string name="time_unit_just_now">Juste cumò</string>
     <string name="media_transfer_this_device_name" product="default">Chest telefon</string>
     <string name="media_transfer_this_device_name" product="tablet">Chest tablet</string>
+    <string name="media_transfer_dock_speaker_device_name">Casse cun base</string>
+    <string name="media_transfer_external_device_name">Dispositîf esterni</string>
+    <string name="media_transfer_default_device_name">Dispositîf colegât</string>
     <string name="media_transfer_this_phone">Chest telefon</string>
+    <string name="media_output_status_unknown_error">Impussibil meti in riproduzion su chest dispositîf</string>
+    <string name="media_output_status_require_premium">Inzorne l\'account par cambiâ</string>
+    <string name="media_output_status_not_support_downloads">Impussibil riprodusi i files discjariâts achì</string>
+    <string name="media_output_status_try_after_ad">Torne prove dopo de publicitât</string>
+    <string name="media_output_status_device_in_low_power_mode">Svee il dispositîf par riprodusi achì</string>
+    <string name="media_output_status_unauthorized">Dispositîf no aprovât pe riproduzion</string>
+    <string name="media_output_status_track_unsupported">Impussibil riprodusi chest contignût multimediâl achì</string>
     <string name="profile_connect_timeout_subtext">Probleme di conession. Distude il dispositîf e torne impiilu</string>
     <string name="media_transfer_wired_device_name">Dispositîf audio cun fîl</string>
     <string name="help_label">Jutori e valutazions</string>
@@ -569,6 +575,9 @@
     <string name="user_add_user_title">Zontâ un gnûf utent?</string>
     <string name="user_add_user_message_long">Tu puedis condividi chest dispositîf cun altris personis creant altris utents. Ogni utent al à il so spazi, che al pues jessi personalizât cun aplicazions, fonts e vie indenant. I utents a puedin ancje regolâ lis impostazions dal dispositîf come il Wi\u2011Fi che a tocjin ducj.\n\nCuant che tu zontis un gnûf utent, chê persone e scugne configurâ il so spazi. Al è pussibil che lis impostazions e i servizis di acès facilitât no vegnin trasferîts al gnûf utent.</string>
     <string name="user_add_user_message_short">Cuant che tu zontis un gnûf utent, che persone e à di configurâ il so spazi.\n\nDucj i utents a puedin inzornâ lis aplicazions di ducj i altris utents. </string>
+    <string name="user_grant_admin_title">Rindi chest utent un aministradôr?</string>
+    <string name="user_grant_admin_message">I aministradôrs a àn privileçs speciâi che altris utents no àn. Un aministradôr al pues gjestî ducj i utents, inzornâ o ripristinâ chest dispositîf, modificâ impostazions, viodi dutis lis aplicazions instaladis e concedi o gjavâ privileçs di aministradôr a chei altri utents.</string>
+    <string name="user_grant_admin_button">Rint aministradôr</string>
     <string name="user_setup_dialog_title">Configurâ l\'utent daurman?</string>
     <string name="user_setup_dialog_message">Verifiche che chê persone e sedi disponibile a cjapâ in man il dispositîf e configurâ il so spazi</string>
     <string name="user_setup_profile_dialog_message">Configurâ il profîl daurman?</string>
@@ -602,6 +611,8 @@
     <string name="guest_exit_dialog_title">Lâ fûr de modalitât ospit?</string>
     <string name="guest_exit_dialog_message">Chest al eliminarà
         lis aplicazions e i dâts de session ospit atuâl</string>
+    <string name="grant_admin">Sì, rindiju aministradôrs</string>
+    <string name="not_grant_admin">No, no sta rindiju aministradôrs</string>
     <string name="guest_exit_dialog_button">Jes</string>
     <string name="guest_exit_dialog_title_non_ephemeral">Salvâ la ativitât ospit?</string>
     <string name="guest_exit_dialog_message_non_ephemeral">Tu puedis salvâ la ativitât de
@@ -666,10 +677,11 @@
     <string name="allow_turn_screen_on">Permet di impiâ il schermi</string>
     <string name="allow_turn_screen_on_description">Permet a une aplicazion di impiâ il schermi. Se chest permès al ven concedût, la aplicazion e podarès impiâ il schermi a cualsisei ore cence la tô autorizazion esplicite.</string>
     <string name="bt_le_audio_broadcast_dialog_title">Interompi la trasmission di <xliff:g id="app_name" example="App Name 1">%1$s</xliff:g>?</string>
-    <string name="bt_le_audio_broadcast_dialog_sub_title">Se tu trasmetis <xliff:g id="switchApp" example="App Name 2">%1$s</xliff:g> o tu cambis la jessude, la trasmission corinte si interomparà</string>
+    <string name="bt_le_audio_broadcast_dialog_sub_title">Se tu trasmetis <xliff:g id="switchApp" example="App Name 2">%1$s</xliff:g> o tu cambiis la jessude, la trasmission corinte si interomparà</string>
     <string name="bt_le_audio_broadcast_dialog_switch_app">Trasmeti <xliff:g id="switchApp" example="App Name 2">%1$s</xliff:g></string>
     <string name="bt_le_audio_broadcast_dialog_different_output">Cambie jessude</string>
     <string name="back_navigation_animation">Animazions preditivis par Indaûr</string>
     <string name="back_navigation_animation_summary">Ative lis animazions di sisteme pal mot Indaûr preditîf.</string>
     <string name="back_navigation_animation_dialog">Cheste impostazion e ative lis animazions di sisteme pal mot Indaûr preditîf. E domande di meti il metodi \"enableOnBackInvokedCallback\" a true tal file manifest di dutis lis aplicazions.</string>
+    <string name="font_scale_percentage"> <xliff:g id="percentage">%1$d</xliff:g> %%</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-gd/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-gd/strings.xml
index 550a2e5..d47fa77 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-gd/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-gd/strings.xml
@@ -70,6 +70,7 @@
     <string name="bluetooth_battery_level"><xliff:g id="battery_level_as_percentage">%1$s</xliff:g> a bhataraidh</string>
     <string name="bluetooth_battery_level_untethered">Clì: <xliff:g id="battery_level_as_percentage" example="25%">%1$s</xliff:g> dhen bhataraidh, Deas: <xliff:g id="battery_level_as_percentage" example="25%">%2$s</xliff:g> dhen bhataraidh</string>
     <string name="bluetooth_active_no_battery_level">Gnìomhach</string>
+    <string name="bluetooth_saved_device">Air a shàbhaladh</string>
     <string name="bluetooth_profile_a2dp">Fuaim nam meadhanan</string>
     <string name="bluetooth_profile_headset">Gairmean fòn</string>
     <string name="bluetooth_profile_opp">Tar-chur fhaidhlichean</string>
@@ -426,12 +427,6 @@
     <string name="power_remaining_less_than_duration">Tha nas lugha na <xliff:g id="threshold">%1$s</xliff:g> air fhàgail (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_more_than_subtext">Tha barrachd air <xliff:g id="time_remaining">%1$s</xliff:g> air fhàgail (<xliff:g id="level">%2$s</xliff:g>)</string>
     <string name="power_remaining_only_more_than_subtext">Tha barrachd air <xliff:g id="time_remaining">%1$s</xliff:g> air fhàgail</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="default">Tha dùil gun dèid am fòn a chur dheth a dh’aithghearr</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="tablet">Tha dùil gun dèid an tablaid a chur dheth a dh’aithghearr</string>
-    <string name="power_remaining_duration_only_shutdown_imminent" product="device">Tha dùil gun dèid an t-uidheam a chur dheth a dh’aithghearr</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="default">Tha dùil gun dèid am fòn a chur dheth a dh’aithghearr (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="tablet">Tha dùil gun dèid an tablaid a chur dheth a dh’aithghearr (<xliff:g id="level">%1$s</xliff:g>)</string>
-    <string name="power_remaining_duration_shutdown_imminent" product="device">Tha dùil gun dèid an t-uidheam a chur dheth a dh’aithghearr (<xliff:g id="level">%1$s</xliff:g>)</string>
     <string name="power_charging"><xliff:g id="level">%1$s</xliff:g> – <xliff:g id="state">%2$s</xliff:g></string>
     <string name="battery_info_status_unknown">Neo-aithnichte</string>
     <string name="battery_info_status_charging">’Ga theàirrdseadh</string>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-kab-rDZ/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-kab-rDZ/strings.xml
index bba6950..94a5fd6 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-kab-rDZ/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-kab-rDZ/strings.xml
@@ -31,6 +31,7 @@
     <string name="bluetooth_disconnected">Ur yeqqin ara</string>
     <string name="bluetooth_connecting">Tuqna\u2026</string>
     <string name="bluetooth_active_no_battery_level">Urmid</string>
+    <string name="bluetooth_saved_device">Yettwasekles</string>
     <string name="bluetooth_profile_opp">Asiweḍ n ifuyla</string>
     <string name="bluetooth_profile_hid">Ibenk n tuffɣa</string>
     <string name="bluetooth_profile_pan">Anekcum ɣer Internet</string>
diff --git a/overlay/frameworks/base/packages/SettingsLib/res/values-sc-rIT/strings.xml b/overlay/frameworks/base/packages/SettingsLib/res/values-sc-rIT/strings.xml
index 4fc9d57..e345bf5 100644
--- a/overlay/frameworks/base/packages/SettingsLib/res/values-sc-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/SettingsLib/res/values-sc-rIT/strings.xml
@@ -33,6 +33,7 @@
     <string name="bluetooth_disconnecting">Iscolleghende·si\u2026</string>
     <string name="bluetooth_connecting">Connetende·si\u2026</string>
     <string name="bluetooth_pairing">Assotziende·si\u2026</string>
+    <string name="bluetooth_saved_device">Sarvadu</string>
     <string name="bluetooth_hearing_aid_right_active">Ativu, isceti dereta</string>
     <string name="bluetooth_profile_opp">Tràmuda de archìvios</string>
     <string name="bluetooth_profile_hid">Dispositivu de intrada</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-ast-rES/strings.xml
index f9d7812..59de6aa 100644
--- a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-ast-rES/strings.xml
@@ -28,7 +28,6 @@
     <string name="keyguard_plugged_in"><xliff:g id="percentage">%s</xliff:g> • En carga</string>
     <string name="keyguard_plugged_in_charging_fast"><xliff:g id="percentage">%s</xliff:g> • En carga, rápida</string>
     <string name="keyguard_plugged_in_charging_slowly"><xliff:g id="percentage">%s</xliff:g> • En carga, lenta</string>
-    <string name="keyguard_instructions_when_pattern_disabled">Primi «Menú» pa desbloquiar.</string>
     <string name="keyguard_network_locked_message">Rede bloquiada</string>
     <string name="keyguard_accessibility_pin_area">Área del PIN</string>
     <string name="keyguard_accessibility_password">Contraseña del preséu</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-cy/strings.xml b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-cy/strings.xml
index 7ed4a77..2b51e3a 100644
--- a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-cy/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-cy/strings.xml
@@ -30,10 +30,7 @@
     <string name="keyguard_plugged_in_charging_fast"><xliff:g id="percentage">%s</xliff:g> • Yn gwefru\'n gyflym</string>
     <string name="keyguard_plugged_in_charging_slowly"><xliff:g id="percentage">%s</xliff:g> • Yn gwefru\'n araf</string>
     <string name="keyguard_plugged_in_charging_limited"><xliff:g id="percentage">%s</xliff:g> • Gwefru wedi\u2019i optimeiddio i warchod y batri</string>
-    <string name="keyguard_instructions_when_pattern_disabled">Gwasga Dewislen i ddatgloi.</string>
     <string name="keyguard_network_locked_message">Rhwydwaith wedi\'i gloi</string>
-    <string name="keyguard_permanent_disabled_sim_instructions">Mae dy SIM wedi cael ei ddadactifadu yn barhaol.\n
-    Cysyllta â dy ddarparwr gwasanaeth symudol am SIM arall.</string>
     <string name="keyguard_accessibility_pin_area">Maes PIN</string>
     <string name="keyguard_accessibility_password">Cyfrinair y ddyfais</string>
     <string name="keyguard_accessibility_sim_pin_area">Maes PIN SIM</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-fur-rIT/strings.xml
index 101be07..d9eaba2 100644
--- a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-fur-rIT/strings.xml
@@ -21,7 +21,9 @@
     <string name="keyguard_enter_your_pin">Inserìs il to PIN</string>
     <string name="keyguard_enter_pin">Inserìs il PIN</string>
     <string name="keyguard_enter_your_pattern">Inserìs la tô cumbinazion</string>
+    <string name="keyguard_enter_pattern">Dissegne la cumbinazion</string>
     <string name="keyguard_enter_your_password">Inserìs la tô password</string>
+    <string name="keyguard_enter_password">Inserìs password</string>
     <string name="keyguard_sim_error_message_short">Schede no valide.</string>
     <string name="keyguard_charged">Cjariât</string>
     <string name="keyguard_plugged_in_wireless"><xliff:g id="percentage" example="20%">%s</xliff:g> • Ricjarie cence fîi</string>
@@ -30,8 +32,13 @@
     <string name="keyguard_plugged_in_charging_fast"><xliff:g id="percentage">%s</xliff:g> • Ricjarie rapide</string>
     <string name="keyguard_plugged_in_charging_slowly"><xliff:g id="percentage">%s</xliff:g> • Ricjarie lente</string>
     <string name="keyguard_plugged_in_charging_limited"><xliff:g id="percentage">%s</xliff:g> • Ricjarie otimizade par protezi la batarie</string>
-    <string name="keyguard_instructions_when_pattern_disabled">Frache Menù par sblocâ.</string>
+    <string name="keyguard_plugged_in_incompatible_charger"><xliff:g id="percentage">%s</xliff:g> • Probleme cul acessori pe ricjarie</string>
     <string name="keyguard_network_locked_message">Rêt blocade</string>
+    <string name="keyguard_missing_sim_message_short">Nissune SIM</string>
+    <string name="keyguard_permanent_disabled_sim_message_short">SIM inusabile.</string>
+    <string name="keyguard_sim_locked_message">La SIM e je blocade.</string>
+    <string name="keyguard_sim_puk_locked_message">La SIM e je blocade cul PUK.</string>
+    <string name="keyguard_sim_unlock_progress_dialog_message">Daûr a sblocâ la SIM\u2026</string>
     <string name="keyguard_accessibility_pin_area">Aree dal PIN</string>
     <string name="keyguard_accessibility_password">Password dal dispositîf</string>
     <string name="keyguard_accessibility_sim_pin_area">Aree dal PIN de SIM</string>
@@ -42,8 +49,38 @@
     <string name="error_disable_esim_msg">Nol è pussibil disabilitâ la eSIM par vie di un erôr.</string>
     <string name="keyboardview_keycode_enter">Invie</string>
     <string name="kg_wrong_pattern">Cumbinazion sbaliade</string>
+    <string name="kg_wrong_pattern_try_again">Cumbinazion sbaliade. Torne prove.</string>
     <string name="kg_wrong_password">Password sbaliade</string>
+    <string name="kg_wrong_password_try_again">Password sbaliade. Torne prove.</string>
     <string name="kg_wrong_pin">PIN sbaliât</string>
+    <string name="kg_wrong_pin_try_again">PIN sbaliât. Torne prove.</string>
+    <string name="kg_wrong_input_try_fp_suggestion">O sbloche cul impront</string>
+    <string name="kg_fp_not_recognized">Impront no ricognossût</string>
+    <string name="bouncer_face_not_recognized">Muse no ricognossude</string>
+    <string name="kg_bio_try_again_or_pin">Torne prove o inserìs il PIN</string>
+    <string name="kg_bio_try_again_or_password">Torne prove o inserìs la password</string>
+    <string name="kg_bio_try_again_or_pattern">Torne prove o dissegne la cumbinazion</string>
+    <string name="kg_bio_too_many_attempts_pin">Dopo masse tentatîfs al covente il PIN</string>
+    <string name="kg_bio_too_many_attempts_password">Dopo masse tentatîfs e covente la password</string>
+    <string name="kg_bio_too_many_attempts_pattern">Dopo masse tentatîfs e covente la cumbinazion</string>
+    <string name="kg_unlock_with_pin_or_fp">Sbloche cul PIN o cul impront</string>
+    <string name="kg_unlock_with_password_or_fp">Sbloche cu la password o cul impront</string>
+    <string name="kg_unlock_with_pattern_or_fp">Sbloche cu la cumbinazion o cul impront</string>
+    <string name="kg_prompt_after_dpm_lock">Par vê plui sigurece, il disp. al è stât blocât dai criteris di lavôr</string>
+    <string name="kg_prompt_after_user_lockdown_pin">Al covente il PIN dopo il bloc</string>
+    <string name="kg_prompt_after_user_lockdown_password">E covente la password dopo il bloc</string>
+    <string name="kg_prompt_after_user_lockdown_pattern">E covente la cumbinazion dopo il bloc</string>
+    <string name="kg_prompt_unattended_update">L\'inzornament si instalarà cuant che il dispositîf nol sarà doprât</string>
+    <string name="kg_prompt_pin_auth_timeout">Necessarie plui sigurece. Il PIN nol è stât doprât di un pôc.</string>
+    <string name="kg_prompt_password_auth_timeout">Necessarie plui sigurece. La password no je stade doprade di un pôc.</string>
+    <string name="kg_prompt_pattern_auth_timeout">Necessarie plui sigurece. La cumbinazion no je stade doprade di un pôc.</string>
+    <string name="kg_prompt_auth_timeout">Necessarie plui sigurece. Il dispositîf nol è stât sblocât di un pôc.</string>
+    <string name="kg_face_locked_out">Impussibil sblocâ cu la muse. Masse tentatîfs.</string>
+    <string name="kg_fp_locked_out">Impussibil sblocâ cul impront. Masse tentatîfs</string>
+    <string name="kg_trust_agent_disabled">L\'agjent di fiducie nol è disponibil</string>
+    <string name="kg_primary_auth_locked_out_pin">Masse tentatîfs cun PIN sbaliât</string>
+    <string name="kg_primary_auth_locked_out_pattern">Masse tentatîfs cun cumbinazion sbaliade</string>
+    <string name="kg_primary_auth_locked_out_password">Masse tentatîfs cun password sbaliade</string>
     <string name="kg_too_many_failed_attempts_countdown">{count, plural,
         one {}=1 {Torne prove ca di # secont.}
         other {Torne prove ca di # seconts.}
@@ -56,6 +93,7 @@
     <string name="kg_puk_enter_puk_hint_multi">La SIM \"<xliff:g id="carrier" example="CARD 1">%1$s</xliff:g>\" cumò e je disativade. Inserìs il codiç PUK par continuâ. Contate l\'operadôr pai detais.</string>
     <string name="kg_puk_enter_pin_hint">Inserìs il codiç PIN desiderât</string>
     <string name="kg_enter_confirm_pin_hint">Conferme il codiç PIN desiderât</string>
+    <string name="kg_sim_unlock_progress_dialog_message">Daûr a sblocâ la SIM\u2026</string>
     <string name="kg_invalid_sim_pin_hint">Scrîf un PIN che al vedi di 4 a 8 numars.</string>
     <string name="kg_invalid_sim_puk_hint">Il codiç PUK al à di vê 8 numars o plui.</string>
     <string name="kg_too_many_failed_pin_attempts_dialog_message">        Tu âs sbaliât di inserî il to PIN <xliff:g id="number">%1$d</xliff:g> voltis.
@@ -81,6 +119,9 @@
     <string name="kg_password_puk_failed">Operazion PUK de SIM falide!</string>
     <string name="accessibility_ime_switch_button" msgid="5032926134740456424">Cambie metodi di imission</string>
     <string name="airplane_mode">Modalitât avion</string>
+    <string name="kg_prompt_reason_restart_pattern">Cumbinazion necessarie dopo che il dispositîf al torne a inviâsi</string>
+    <string name="kg_prompt_reason_restart_pin">Il PIN al è necessari dopo che il dispositîf al torne a inviâsi</string>
+    <string name="kg_prompt_reason_restart_password">La password e je necessarie dopo che il dispositîf al torne a inviâsi</string>
     <string name="kg_prompt_reason_timeout_pattern">Cumbinazion obligatorie par vê plui sigurece</string>
     <string name="kg_prompt_reason_timeout_pin">PIN obligatori par vê plui sigurece</string>
     <string name="kg_prompt_reason_timeout_password">Password obligatorie par vê plui sigurece</string>
@@ -100,4 +141,10 @@
     <string name="clock_title_bubble">Bufule</string>
     <string name="clock_title_analog">Analogjic</string>
     <string name="keyguard_unlock_to_continue">Sbloche il dispositîf par continuâ</string>
+    <string name="kg_prompt_unattended_update_pin">Inserìs il PIN par instalâ l\'inzornament plui indevant</string>
+    <string name="kg_prompt_unattended_update_password">Inserìs la password par instalâ l\'inzornament plui indevant</string>
+    <string name="kg_prompt_unattended_update_pattern">Dissegne la cumbinazion par instalâ l\'inzornament plui indevant</string>
+    <string name="kg_prompt_after_update_pin">Dispositîf inzornât. Inserìs il PIN par continuâ.</string>
+    <string name="kg_prompt_after_update_password">Dispositîf inzornât. Inserìs la password par continuâ.</string>
+    <string name="kg_prompt_after_update_pattern">Dispositîf inzornât. Dissegne la cumbinazion par continuâ.</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-gd/strings.xml b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-gd/strings.xml
index c902913..a67368f 100644
--- a/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-gd/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res-keyguard/values-gd/strings.xml
@@ -28,7 +28,6 @@
     <string name="keyguard_plugged_in"><xliff:g id="percentage">%s</xliff:g> • ’Ga theàirrdseadh</string>
     <string name="keyguard_plugged_in_charging_fast"><xliff:g id="percentage">%s</xliff:g> • ’Ga theàirrdseadh gu luath</string>
     <string name="keyguard_plugged_in_charging_slowly"><xliff:g id="percentage">%s</xliff:g> • ’Ga theàirrdseadh gu mall</string>
-    <string name="keyguard_instructions_when_pattern_disabled">Brùth air “Clàr-taice” airson a ghlas a thoirt uaithe.</string>
     <string name="keyguard_network_locked_message">Lìonra glaiste</string>
     <string name="keyguard_accessibility_pin_area">Raon a’ PIN</string>
     <string name="keyguard_accessibility_password">Facal-faire an uidheim</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res-product/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/SystemUI/res-product/values-ast-rES/strings.xml
index 0907a84..b9d1054 100644
--- a/overlay/frameworks/base/packages/SystemUI/res-product/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res-product/values-ast-rES/strings.xml
@@ -19,8 +19,10 @@
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="dock_alignment_slow_charging" product="default">Coloca bien el preséu na base pa cargalu más rápido</string>
     <string name="dock_alignment_not_charging" product="default">Coloca bien el preséu na base pa cargalu ensin filos</string>
-    <string name="inattentive_sleep_warning_message" product="tv">El preséu d\'Android TV va apagase pronto. Primi un botón pa que siga prendíu.</string>
+    <string name="inattentive_sleep_warning_message" product="tv">El preséu Android TV va apagase pronto. Primi un botón pa que siga prendíu.</string>
     <string name="inattentive_sleep_warning_message" product="default">El preséu va apagase pronto. Primi un botón pa que siga prendíu.</string>
+    <string name="keyguard_missing_sim_message" product="tablet">Nun hai nenguna SIM na tableta.</string>
+    <string name="keyguard_missing_sim_message" product="default">Nun hai nenguna SIM nel teléfonu.</string>
     <string name="kg_invalid_confirm_pin_hint" product="default">Los códigos PIN nun concasen</string>
     <string name="kg_failed_attempts_almost_at_wipe" product="tablet">       Tentesti de desbloquiar incorreutamente la tableta <xliff:g id="number">%1$d</xliff:g> vegaes.
        Dempués de <xliff:g id="number">%2$d</xliff:g> intentos fallíos más,
@@ -74,6 +76,24 @@
        va pidísete que desbloquies el teléfonu con una cuenta de corréu electrónicu.\n\n
        Volvi tentalo en <xliff:g id="number">%3$d</xliff:g> segundos.
     </string>
+    <string name="thermal_shutdown_title" product="default">El teléfonu apagóse pola calor</string>
+    <string name="thermal_shutdown_title" product="device">El preséu apagóse pola calor</string>
+    <string name="thermal_shutdown_title" product="tablet">La tableta apagóse pola calor</string>
+    <string name="thermal_shutdown_message" product="default">El teléfonu yá funciona con normalidá.\nToca pa consiguir más información</string>
+    <string name="thermal_shutdown_message" product="device">El preséu yá funciona con normalidá.\nToca pa consiguir más información</string>
+    <string name="thermal_shutdown_message" product="tablet">La tableta yá funciona con normalidá.\nToca pa consiguir más información</string>
+    <string name="thermal_shutdown_dialog_message" product="default">El teléfonu taba mui caliente y apagóse pa esfrecer. Agora funciona con normalidá.\n\nYe posible que vuelva calecer muncho si:\n\t•Uses aplicaciones que consumen munchos recursos (como xuegos, reproductores o aplicaciones de navegación)\n\t•Baxar o xubir ficheros grandes\n\t•Lu uses con temperatures altes</string>
+    <string name="thermal_shutdown_dialog_message" product="device">El preséu taba mui caliente y apagóse pa esfrecer. Agora funciona con normalidá.\n\nYe posible que vuelva calecer muncho si:\n\t•Uses aplicaciones que consumen munchos recursos (como xuegos, reproductores o aplicaciones de navegación)\n\t•Baxar o xubir ficheros grandes\n\t•Lu uses con temperatures altes</string>
+    <string name="thermal_shutdown_dialog_message" product="tablet">La tableta taba mui caliente y apagóse pa esfrecer. Agora funciona con normalidá.\n\nYe posible que vuelva calecer muncho si:\n\t•Uses aplicaciones que consumen munchos recursos (como xuegos, reproductores o aplicaciones de navegación)\n\t•Baxar o xubir ficheros grandes\n\t•La uses con temperatures altes</string>
+    <string name="high_temp_title" product="default">El teléfonu ta caleciendo</string>
+    <string name="high_temp_title" product="device">El preséu ta caleciendo</string>
+    <string name="high_temp_title" product="tablet">La tableta ta caleciendo</string>
+    <string name="high_temp_notif_message" product="default">Dalgunes funciones puen tar llendaes mentanto\'l teléfonu esfrez.\nToca pa consiguir más información</string>
+    <string name="high_temp_notif_message" product="device">Dalgunes funciones puen tar llendaes mentanto\'l preséu esfrez.\nToca pa consiguir más información</string>
+    <string name="high_temp_notif_message" product="tablet">Dalgunes funciones puen tar llendaes mentanto la tableta esfrez.\nToca pa consiguir más información</string>
+    <string name="high_temp_dialog_message" product="default">El teléfonu va tentar d\'esfrecer automáticamente. Pues siguir usándolu, más ye posible que funcione más lentu.\n\nNamás qu\'esfreza, va funcionar con normalidá.</string>
+    <string name="high_temp_dialog_message" product="device">El preséu va tentar d\'esfrecer automáticamente. Pues siguir usándolu, más ye posible que funcione más lentu.\n\nNamás qu\'esfreza, va funcionar con normalidá.</string>
+    <string name="high_temp_dialog_message" product="tablet">La tableta va tentar d\'esfrecer automáticamente. Pues siguir usándola, más ye posible que funcione más lenta.\n\nNamás qu\'esfreza, va funcionar con normalidá.</string>
     <string name="global_action_lock_message" product="default">Desbloquia\'l teléfonu pa ver más opciones</string>
     <string name="global_action_lock_message" product="tablet">Desbloquia la tableta pa ver más opciones</string>
     <string name="global_action_lock_message" product="device">Desbloquia\'l preséu pa ver más opciones</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res-product/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/SystemUI/res-product/values-fur-rIT/strings.xml
index 92e52b9..17e421d 100644
--- a/overlay/frameworks/base/packages/SystemUI/res-product/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res-product/values-fur-rIT/strings.xml
@@ -21,6 +21,8 @@
     <string name="dock_alignment_not_charging" product="default">Met ben il telefon par ricjariâ cence fîi</string>
     <string name="inattentive_sleep_warning_message" product="tv">Il dispositîf Android TV si distudarà ca di pôc; frache un boton par tignîlu impiât.</string>
     <string name="inattentive_sleep_warning_message" product="default">Il dispositîf si distudarà ca di pôc; frache par tignîlu impiât.</string>
+    <string name="keyguard_missing_sim_message" product="tablet">Nissune SIM tal tablet.</string>
+    <string name="keyguard_missing_sim_message" product="default">Nissune SIM tal telefon.</string>
     <string name="kg_invalid_confirm_pin_hint" product="default">I codiçs PIN no corispuindin</string>
     <string name="kg_failed_attempts_almost_at_wipe" product="tablet">       Tu âs cirût di sblocâ il tablet cun <xliff:g id="number">%1$d</xliff:g> tentatîfs sbaliâts.
        Ancjemò <xliff:g id="number">%2$d</xliff:g> tentatîfs sbaliâts e chest tablet
@@ -74,6 +76,24 @@
        ti vignarà domandât di sblocâ il to telefon doprant un account di e-mail.\n\n
        Torne prove chi di <xliff:g id="number">%3$d</xliff:g> seconts.
     </string>
+    <string name="thermal_shutdown_title" product="default">Telefon distudât par vie dal calôr</string>
+    <string name="thermal_shutdown_title" product="device">Dispositîf distudât par vie dal calôr</string>
+    <string name="thermal_shutdown_title" product="tablet">Tablet distudât par vie dal calôr</string>
+    <string name="thermal_shutdown_message" product="default">Cumò il telefon al funzione in mût normâl.\nTocje par vê plui informazions</string>
+    <string name="thermal_shutdown_message" product="device">Cumò il dispositîf al funzione in mût normâl.\nTocje par vê plui informazions</string>
+    <string name="thermal_shutdown_message" product="tablet">Cumò il tablet al funzione in mût normâl.\nTocje par vê plui informazions</string>
+    <string name="thermal_shutdown_dialog_message" product="default">Il telefon al jere masse cjalt, duncje al è stât distudât par disfredâlu. Cumò al sta funzionant in mût normâl.\n\nAl è pussibil che il telefon al deventi masse cjalt se tu:\n\t• Tu dopris aplicazions che a consumin une vore di risorsis (come zûcs, video o aplicazions pe navigazion)\n\t• Tu discjamis o tu cjariis in rêt files grancj\n\t• Tu dopris il telefon dulà che al fâs tant cjalt</string>
+    <string name="thermal_shutdown_dialog_message" product="device">Il dispositîf al jere masse cjalt, duncje al è stât distudât par sfredâlu. Cumò al sta funzionant in maniere normâl.\n\nIl dispositîf al podarès deventâ masse cjalt se tu:\n\t• Tu dopris aplicazions che a consumin une vore di risorsis (come zûcs, videos o aplicazions pe navigazion)\n\t• Tu discjamis o tu cjariis in rêt files grancj\n\t• Tu dopris il dispositîf dulà che al fâs tant cjalt</string>
+    <string name="thermal_shutdown_dialog_message" product="tablet">Il tablet al jere masse cjalt, duncje al è stât distudât par disfredâlu. Cumò al sta funzionant in mût normâl.\n\nAl è pussibil che il tablet al deventi masse cjalt se tu:\n\t• Tu dopris aplicazions che a consumin une vore di risorsis (come zûcs, video o aplicazions pe navigazion)\n\t• Tu discjamis o tu cjariis in rêt files grancj\n\t• Tu dopris il tablet dulà che al fâs tant cjalt</string>
+    <string name="high_temp_title" product="default">Il telefon si sta scjaldant</string>
+    <string name="high_temp_title" product="device">Il dispositîf si sta scjaldant</string>
+    <string name="high_temp_title" product="tablet">Il tablet si sta scjaldant</string>
+    <string name="high_temp_notif_message" product="default">Cualchi funzionalitât limitade intant che il telefon si disfrede.\nTocje par vê plui informazions</string>
+    <string name="high_temp_notif_message" product="device">Cualchi funzionalitât limitade intant che il dispositîf si disfrede.\nTocje par vê plui informazions</string>
+    <string name="high_temp_notif_message" product="tablet">Cualchi funzionalitât limitade intant che il tablet si disfrede.\nTocje par vê plui informazions</string>
+    <string name="high_temp_dialog_message" product="default">Il telefon al cirarà in automatic di disfredâsi. Tu podarâs ancjemò doprâlu, ma al sarà plui lent.\n\nUne volte disfredât, al funzionarà in mût normâl.</string>
+    <string name="high_temp_dialog_message" product="device">Il dispositîf al cirarà in automatic di disfredâsi. Tu podarâs ancjemò doprâlu, ma al sarà plui lent.\n\nUne volte disfredât, al funzionarà in mût normâl.</string>
+    <string name="high_temp_dialog_message" product="tablet">Il tablet al cirarà in automatic di disfredâsi. Tu podarâs ancjemò doprâlu, ma al sarà plui lent.\n\nUne volte disfredât, al funzionarà in mût normâl.</string>
     <string name="security_settings_sfps_enroll_find_sensor_message" product="tablet">Il sensôr di impront al è sul boton par impiâ. Al è il boton plac dongje dal boton rialçât dal volum, sul flanc dal tablet.</string>
     <string name="security_settings_sfps_enroll_find_sensor_message" product="device">Il sensôr di impront al è sul boton par impiâ. Al è il boton plac dongje dal boton rialçât dal volum, sul flanc dal dispositîf.</string>
     <string name="security_settings_sfps_enroll_find_sensor_message" product="default">Il sensôr di impront al è sul boton par impiâ. Al è il boton plac dongje dal boton rialçât dal volum, sul flanc dal telefon.</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-ast-rES/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-ast-rES/strings.xml
index df597cf..6c3e533 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-ast-rES/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-ast-rES/strings.xml
@@ -172,6 +172,8 @@
     <string name="quick_settings_dnd_label">Nun molestar</string>
     <string name="quick_settings_bluetooth_label">Bluetooth</string>
     <string name="quick_settings_bluetooth_detail_empty_text">Nun hai preseos empareyaos disponibles</string>
+    <string name="pair_new_bluetooth_devices">Empareyamientu d\'un preséu nuevu</string>
+    <string name="quick_settings_bluetooth_device_connected">Conectóse</string>
     <string name="quick_settings_bluetooth_secondary_label_battery_level"><xliff:g id="battery_level_as_percentage">%s</xliff:g> de batería</string>
     <string name="quick_settings_bluetooth_secondary_label_audio">Audiu</string>
     <string name="quick_settings_bluetooth_secondary_label_headset">Cascos</string>
@@ -190,7 +192,6 @@
     <string name="quick_settings_casting">En tresmisión</string>
     <string name="quick_settings_cast_device_default_name">Preséu ensin nome</string>
     <string name="quick_settings_cast_detail_empty_text">Nun hai nengún preséu disponible</string>
-    <string name="quick_settings_cast_no_wifi">La Wi\u2011Fi nun ta conectada</string>
     <string name="quick_settings_brightness_dialog_title">Brillu</string>
     <string name="quick_settings_done">Fecho</string>
     <string name="quick_settings_close_user_panel">Zarrar</string>
@@ -226,6 +227,13 @@
     <string name="quick_settings_nfc_on">El NFC ta habilitáu</string>
     <string name="quick_settings_screen_record_start">Comienzu</string>
     <string name="quick_settings_screen_record_stop">Parar</string>
+    <string name="qs_record_issue_start">Comienzu</string>
+    <string name="qs_record_issue_stop">Parar</string>
+    <string-array name="qs_record_issue_types">
+        <item>Performance</item>
+        <item>User Interface</item>
+        <item>Batería</item>
+    </string-array>
     <string name="quick_step_accessibility_toggle_overview">Alternar «Vista xeneral»</string>
     <string name="zen_priority_introduction">Nun va molestate nengún soníu nin vibración, quitante los de los recordatorios, les alarmes, los eventos y les llamaes qu\'especifiques. Vas siguir sintiendo tolo que decidas reproducir, como los vídeos, la música y los xuegos.</string>
     <string name="zen_alarms_introduction">Nun va molestate nengún soníu nin vibración, quitante los de les alarmes. Vas siguir sintiendo tolo que decidas reproducir, como los vídeos, la música y los xuegos.</string>
@@ -248,6 +256,8 @@
     <string name="interruption_level_priority_twoline">Namás con\n
 prioridá</string>
     <string name="interruption_level_alarms_twoline">Namás\nalarmes</string>
+    <string name="button_to_remove_widget">Quitar</string>
+    <string name="hub_mode_editing_exit_button_text">Fecho</string>
     <string name="accessibility_multi_user_switch_switcher">Cambiar d\'usuariu</string>
     <string name="guest_exit_guest_dialog_message">Van desaniciase toles aplicaciones y tolos datos d\'esta sesión.</string>
     <string name="guest_wipe_session_title">¡Volvi afayate, convidáu!</string>
@@ -360,12 +370,12 @@
     <string name="accessibility_status_bar_hotspot">Puntu Wi-Fi</string>
     <string name="accessibility_managed_profile">Perfil llaboral</string>
     <string name="tuner_warning_title">Diversión namás pa dalgunes persones</string>
-    <string name="tuner_warning">«Afinador de la IU del sistema» ufre más formes d\'axustar y personalizar la interfaz d\'usuariu d\'Android. Estes carauterístiques esperimentales puen camudar, desapaecer o dexar de funcionar nes versiones futures. Sigui con curiáu.</string>
-    <string name="tuner_persistent_warning">Estes carauterístiques esperimentales puen camudar, desapaecer o dexar de funcionar nes versiones futures. Sigui con curiáu.</string>
+    <string name="tuner_warning">«Afinador de la IU del sistema» ufre más formes d\'axustar y personalizar la interfaz d\'usuariu d\'Android. Estes funciones esperimentales puen camudar, desapaecer o dexar de funcionar nes versiones futures. Sigui con curiáu.</string>
+    <string name="tuner_persistent_warning">Estes funciones esperimentales puen camudar, desapaecer o dexar de funcionar nes versiones futures. Sigui con curiáu.</string>
     <string name="got_it">Entendílo</string>
     <string name="tuner_toast">¡Norabona! Amestóse «Afinador de la IU del sistema» a «Axustes»</string>
     <string name="remove_from_settings">Quitar d\'«Axustes»</string>
-    <string name="remove_from_settings_prompt">¿Quies quitar «Afinador de la IU del sistema» d\'«Axustes» y dexar d\'usar toles sos carauterístiques?</string>
+    <string name="remove_from_settings_prompt">¿Quies quitar «Afinador de la IU del sistema» d\'«Axustes» y dexar d\'usar toles sos funciones?</string>
     <string name="enable_bluetooth_title">¿Quies habilitar el Bluetooth?</string>
     <string name="enable_bluetooth_message">Pa conectar el tecláu a la tableta, primero tienes d\'habilitar el Bluetooth.</string>
     <string name="enable_bluetooth_confirmation_ok">Habilitar</string>
@@ -423,10 +433,6 @@
     <string name="keyboard_key_button_template">Botón «<xliff:g id="name">%1$s</xliff:g>»</string>
     <string name="keyboard_key_home">Aniciu</string>
     <string name="keyboard_key_back">Atrás</string>
-    <string name="keyboard_key_dpad_up">Arriba</string>
-    <string name="keyboard_key_dpad_down">Abaxo</string>
-    <string name="keyboard_key_dpad_left">Esquierda</string>
-    <string name="keyboard_key_dpad_right">Derecha</string>
     <string name="keyboard_key_dpad_center">Centru</string>
     <string name="keyboard_key_tab">Tabulador</string>
     <string name="keyboard_key_space">Espaciu</string>
@@ -455,11 +461,13 @@
     <string name="keyboard_shortcut_group_system_switch_input">Cambiar la distribución del tecláu</string>
     <string name="keyboard_shortcut_search_category_system">Sistema</string>
     <string name="keyboard_shortcut_search_category_input">Entrada</string>
+    <string name="group_system_access_system_settings">Abrir los axustes</string>
     <string name="group_system_lock_screen">Pantalla de bloquéu</string>
     <string name="keyboard_shortcut_group_input">Entrada</string>
     <string name="keyboard_shortcut_group_applications">Aplicaciones</string>
-    <string name="keyboard_shortcut_group_applications_assist">Asistencia</string>
+    <string name="keyboard_shortcut_group_applications_browser">Restolador</string>
     <string name="keyboard_shortcut_group_applications_contacts">Contautos</string>
+    <string name="keyboard_shortcut_group_applications_email">Corréu electrónicu</string>
     <string name="keyboard_shortcut_group_applications_sms">SMS</string>
     <string name="keyboard_shortcut_group_applications_music">Música</string>
     <string name="keyboard_shortcut_group_applications_calendar">Calendariu</string>
@@ -591,9 +599,12 @@
     <string name="auto_saver_text">Activa la función si prevés que la batería pue escosar</string>
     <string name="no_auto_saver_action">Non, gracies</string>
     <string name="heap_dump_tile_name">Volquiar pila SysUI</string>
+    <string name="ongoing_privacy_dialog_a11y_title">N\'usu</string>
     <string name="ongoing_privacy_chip_content_multiple_apps">Aplicaciones que tán usando: <xliff:g id="types_list" example="camera, location">%s</xliff:g>.</string>
     <string name="ongoing_privacy_dialog_separator">,\u0020</string>
     <string name="ongoing_privacy_dialog_last_separator">\u0020y\u0020</string>
+    <string name="ongoing_privacy_dialog_attribution_label">(<xliff:g id="attribution_label" example="For Wallet">%s</xliff:g>)</string>
+    <string name="ongoing_privacy_dialog_attribution_proxy_label">(<xliff:g id="attribution_label" example="For Wallet">%1$s</xliff:g>  \u2022 <xliff:g id="proxy_label" example="Maps, and Assistant">%2$s</xliff:g>)</string>
     <string name="privacy_type_camera">cámara</string>
     <string name="privacy_type_location">llocalización</string>
     <string name="privacy_type_microphone">micrófonu</string>
@@ -633,6 +644,7 @@
     <string name="controls_dialog_remove">Quitar</string>
     <string name="controls_dialog_message">«<xliff:g id="app" example="System UI">%s</xliff:g>» suxer esti control</string>
     <string name="controls_settings_dialog_neutral_button">Non, gracies</string>
+    <string name="controls_settings_dialog_positive_button">Sí</string>
     <string name="controls_pin_use_alphanumeric">El PIN contién lletres o símbolos</string>
     <string name="controls_pin_verify">Verifica «<xliff:g id="device" example="Backdoor lock">%s</xliff:g>»</string>
     <string name="controls_pin_wrong">El PIN ye incorreutu</string>
@@ -648,6 +660,8 @@
     <string name="controls_media_seekbar_description"><xliff:g id="elapsed_time" example="1:30">%1$s</xliff:g> de <xliff:g id="total_time" example="3:00">%2$s</xliff:g></string>
     <string name="controls_media_button_play">Reproducir</string>
     <string name="controls_media_button_pause">Posar</string>
+    <string name="controls_media_button_prev">Pista anterior</string>
+    <string name="controls_media_button_next">Pista siguiente</string>
     <string name="controls_media_smartspace_rec_title">Reproducir</string>
     <string name="media_transfer_undo">Desfacer</string>
     <string name="controls_error_timeout">Inactivu. Revisa l\'aplicación</string>
@@ -663,6 +677,7 @@
     <string name="media_output_dialog_group">Grupu</string>
     <string name="media_output_dialog_single_device">Esbillóse 1 preséu</string>
     <string name="media_output_dialog_multiple_devices">Esbilláronse <xliff:g id="count" example="2">%1$d</xliff:g> preseos</string>
+    <string name="media_output_dialog_accessibility_seekbar">Volume</string>
     <string name="media_output_end_session_dialog_stop">Parar</string>
     <string name="media_output_broadcast_dialog_save">Guardar</string>
     <string name="select_conversation_title">Widgets de conversación</string>
@@ -693,6 +708,7 @@
     <string name="log_access_confirmation_learn_more">Saber más</string>
     <string name="rear_display_bottom_sheet_cancel">Encaboxar</string>
     <string name="call_from_work_profile_close">Encaboxar</string>
+    <string name="dismiss_dialog">Escartar</string>
     <string name="privacy_dialog_done_button">Fecho</string>
     <string name="privacy_dialog_collapse_action">Contrayer</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-cy/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-cy/strings.xml
index 558c1fd..b9b8c13 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-cy/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-cy/strings.xml
@@ -219,6 +219,9 @@
     <string name="quick_settings_dnd_label">Dim Tarfu</string>
     <string name="quick_settings_bluetooth_label">Bluetooth</string>
     <string name="quick_settings_bluetooth_detail_empty_text">Dim dyfeisiau wedi\'u paru ar gael</string>
+    <string name="pair_new_bluetooth_devices">Paru â dyfais newydd</string>
+    <string name="see_all_bluetooth_devices">Gweld y cwbl</string>
+    <string name="quick_settings_bluetooth_device_connected">Wedi cysylltu</string>
     <string name="quick_settings_bluetooth_secondary_label_battery_level"><xliff:g id="battery_level_as_percentage">%s</xliff:g> batri</string>
     <string name="quick_settings_bluetooth_secondary_label_audio">Sain</string>
     <string name="quick_settings_bluetooth_secondary_label_headset">Clustffonau</string>
@@ -244,7 +247,6 @@
     <string name="quick_settings_casting">Yn bwrw</string>
     <string name="quick_settings_cast_device_default_name">Dyfais dienw</string>
     <string name="quick_settings_cast_detail_empty_text">Dim dyfeisiau ar gael</string>
-    <string name="quick_settings_cast_no_wifi">Wi\u2011Fi heb gysylltu</string>
     <string name="quick_settings_brightness_dialog_title">Disgleirdeb</string>
     <string name="quick_settings_inversion_label">Gwrthdroad lliwiau</string>
     <string name="quick_settings_color_correction_label">Cywiriad lliw</string>
@@ -293,6 +295,14 @@
     <string name="quick_settings_screen_record_label">Recordio\u2019r sgrin</string>
     <string name="quick_settings_screen_record_start">Dechrau</string>
     <string name="quick_settings_screen_record_stop">Stopio</string>
+    <string name="qs_record_issue_start">Dechrau</string>
+    <string name="qs_record_issue_stop">Stopio</string>
+    <string name="qs_record_issue_dropdown_screenrecord">Recordio\u2019r sgrin</string>
+    <string-array name="qs_record_issue_types">
+        <item>Performance</item>
+        <item>User Interface</item>
+        <item>Batri</item>
+    </string-array>
     <string name="quick_settings_onehanded_label">Modd un llaw</string>
     <string name="sensor_privacy_start_use_mic_dialog_title">Dadrwystro meicroffon y ddyfais?</string>
     <string name="sensor_privacy_start_use_camera_dialog_title">Dadrwystro camera\u2019r dyfais?</string>
@@ -356,6 +366,8 @@
     <string name="keyguard_indication_charging_time_fast"><xliff:g id="percentage">%2$s</xliff:g> • Yn gwefru\u2019n gyflym • Llawn mewn <xliff:g id="charging_time_left" example="4 hr, 2 min">%1$s</xliff:g></string>
     <string name="keyguard_indication_charging_time_slowly"><xliff:g id="percentage">%2$s</xliff:g> • Yn gwefru\u2019n araf • Llawn mewn <xliff:g id="charging_time_left" example="4 hr, 2 min">%1$s</xliff:g></string>
     <string name="keyguard_indication_charging_time_dock"><xliff:g id="percentage" example="20%">%2$s</xliff:g> • Yn gwefru • Llawn mewn <xliff:g id="charging_time_left" example="4 hr, 2 min">%1$s</xliff:g></string>
+    <string name="button_to_remove_widget">Tynnu</string>
+    <string name="hub_mode_editing_exit_button_text">Cwblhau</string>
     <string name="accessibility_multi_user_switch_switcher">Newid defnyddiwr</string>
     <string name="accessibility_multi_user_list_switcher">dewislen tynnu i lawr</string>
     <string name="guest_exit_guest_dialog_message">Caiff holl apiau a data\'r sesiwn hon eu dileu.</string>
@@ -609,10 +621,6 @@
     <string name="keyboard_key_button_template">Botwm <xliff:g id="name">%1$s</xliff:g></string>
     <string name="keyboard_key_home">Cartref</string>
     <string name="keyboard_key_back">Nôl</string>
-    <string name="keyboard_key_dpad_up">I fyny</string>
-    <string name="keyboard_key_dpad_down">I lawr</string>
-    <string name="keyboard_key_dpad_left">Chwith</string>
-    <string name="keyboard_key_dpad_right">De</string>
     <string name="keyboard_key_dpad_center">Canol</string>
     <string name="keyboard_key_tab">Tab</string>
     <string name="keyboard_key_space">Bwlch</string>
@@ -642,11 +650,13 @@
     <string name="keyboard_shortcut_group_system_switch_input">Newid gosodiad y bysellfwrdd</string>
     <string name="keyboard_shortcut_search_category_system">System</string>
     <string name="keyboard_shortcut_search_category_input">Mewnbwn</string>
+    <string name="group_system_access_system_settings">Agor gosodiadau</string>
     <string name="group_system_lock_screen">Sgrin cloi</string>
     <string name="keyboard_shortcut_group_input">Mewnbwn</string>
     <string name="keyboard_shortcut_group_applications">Apiau</string>
-    <string name="keyboard_shortcut_group_applications_assist">Cymorth</string>
+    <string name="keyboard_shortcut_group_applications_browser">Porwr</string>
     <string name="keyboard_shortcut_group_applications_contacts">Cysylltiadau</string>
+    <string name="keyboard_shortcut_group_applications_email">Ebost</string>
     <string name="keyboard_shortcut_group_applications_sms">SMS</string>
     <string name="keyboard_shortcut_group_applications_music">Cerddoriaeth</string>
     <string name="keyboard_shortcut_group_applications_calendar">Calendr</string>
@@ -1084,6 +1094,7 @@
     <string name="camera_and_microphone_blocked_dream_overlay_content_description">Camera a meicroffon wedi\u2019u rhwystro</string>
     <string name="microphone_blocked_dream_overlay_content_description">Meicroffon wedi\u2019i rwystro</string>
     <string name="priority_mode_dream_overlay_content_description">Modd blaenoriaeth ymlaen</string>
+    <string name="dismiss_dialog">Diystyru</string>
     <string name="privacy_dialog_done_button">Cwblhau</string>
     <string name="privacy_dialog_collapse_action">Lleihau</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-eo/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-eo/strings.xml
index 459fb08..cbfbb4f 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-eo/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-eo/strings.xml
@@ -24,6 +24,7 @@
     <string name="quick_settings_location_label">Loko</string>
     <string name="quick_settings_user_title">Uzanto</string>
     <string name="quick_settings_close_user_panel">Fermi</string>
+    <string name="button_to_remove_widget">Forigi</string>
     <string name="user_remove_user_remove">Forigi</string>
     <string name="notification_section_header_alerting">Sciigoj</string>
     <string name="volume_panel_dialog_settings_button">Agordoj</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-fur-rIT/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-fur-rIT/strings.xml
index ee7e99b..ab075af 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-fur-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-fur-rIT/strings.xml
@@ -50,6 +50,7 @@
     <string name="usb_debugging_always">Permet simpri di chest computer</string>
     <string name="usb_debugging_allow">Permet</string>
     <string name="usb_debugging_secondary_user_title">Debug USB no permetût</string>
+    <string name="usb_debugging_secondary_user_message">L\'utent che al moment al è jentrât su chest dispositîf nol pues ativâ il debug USB. Par doprâ cheste funzion, passe a un utent aministradôr.</string>
     <string name="hdmi_cec_set_menu_language_title">Desideristu cambiâ la lenghe di sisteme cu la lenghe <xliff:g id="language" example="German">%1$s</xliff:g>?</string>
     <string name="hdmi_cec_set_menu_language_description">Rivade di un altri dispositîf la richieste di cambiâ la lenghe di sisteme</string>
     <string name="hdmi_cec_set_menu_language_accept">Cambie lenghe</string>
@@ -59,12 +60,14 @@
     <string name="wifi_debugging_always">Permet simpri su cheste rêt</string>
     <string name="wifi_debugging_allow">Permet</string>
     <string name="wifi_debugging_secondary_user_title">Debug wireless no consintût</string>
+    <string name="wifi_debugging_secondary_user_message">L\'utent che al moment al è jentrât su chest dispositîf nol pues ativâ il debug wireless. Par doprâ cheste funzion, passe a un utent aministradôr.</string>
     <string name="usb_contaminant_title">Puarte USB disabilitade</string>
     <string name="usb_contaminant_message">Par protezi il to dispositîf dai licuits e de porcarie, la puarte USB e je stade disabilitade e no tu rivarâs a rilevâ nissun acessori.\n\nCuant che e sarà a puest e tu podarâs tornâ a doprâle, tu ricevarâs une notifiche.</string>
     <string name="usb_port_enabled">Puarte USB abilitade par rilevâ cjariadôrs e acessoris</string>
     <string name="usb_disable_contaminant_detection">Abilite USB</string>
     <string name="learn_more">Plui informazions</string>
     <string name="global_action_screenshot">Schermade</string>
+    <string name="global_action_smart_lock_disabled">Slungje sbloc disativât</string>
     <string name="remote_input_image_insertion_text">e je stade inviade une imagjin</string>
     <string name="screenshot_saving_title">Daûr a salvâ la schermade\u2026</string>
     <string name="screenshot_saving_work_profile_title">Daûr a salvâ la schermade sul profîl di lavôr\u2026</string>
@@ -91,10 +94,13 @@
     <string name="screenshot_default_files_app_name">Files</string>
     <string name="screenshot_detected_template"><xliff:g id="appName" example="Google Chrome">%1$s</xliff:g> al à rilevât cheste schermade.</string>
     <string name="screenshot_detected_multiple_template"><xliff:g id="appName" example="Google Chrome">%1$s</xliff:g> e altris aplicazions viertis a àn rilevât cheste schermade.</string>
+    <string name="app_clips_save_add_to_note">Zonte a une note</string>
     <string name="screenrecord_title">Regjistradôr di schermi</string>
     <string name="screenrecord_background_processing_label">Elaboraz. resgjistraz. schermi</string>
     <string name="screenrecord_channel_description">Notifiche continue di une session di regjistrazion dal schermi</string>
     <string name="screenrecord_permission_dialog_title">Scomençâ la regjistrazion?</string>
+    <string name="screenrecord_permission_dialog_warning_entire_screen">Intant che tu stâs regjistrant, Android al à acès a dut ce che al è visibil su schermi o che al ven riprodot sul dispositîf. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
+    <string name="screenrecord_permission_dialog_warning_single_app">Intant che tu stâs regjistrant une aplicazion, Android al à acès a dut ce che al ven mostrât o che al ven riprodot su chê aplicazion. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
     <string name="screenrecord_permission_dialog_continue">Scomence la regjistrazion</string>
     <string name="screenrecord_audio_label">Regjistre audio</string>
     <string name="screenrecord_device_audio_label">Audio dal dispositîf</string>
@@ -109,7 +115,10 @@
     <string name="screenrecord_share_label">Condivît</string>
     <string name="screenrecord_save_title">Regjistrazion di schermi salvade</string>
     <string name="screenrecord_save_text">Tocje par viodi</string>
+    <string name="screenrecord_save_error">Erôr tal salvâ la regjistrazion dal schermi</string>
     <string name="screenrecord_start_error">Erôr tal scomençâ a regjistrâ il schermi</string>
+    <string name="immersive_cling_title">Visualizazion a plen schermi</string>
+    <string name="immersive_cling_description">Par lâ fûr, di parsore scor in jù.</string>
     <string name="immersive_cling_positive">Capît</string>
     <string name="accessibility_back">Indaûr</string>
     <string name="accessibility_home">Inizi</string>
@@ -140,6 +149,7 @@
     <string name="biometric_dialog_tap_confirm_with_face_alt_2">Muse ricognossude. Frache par continuâ.</string>
     <string name="biometric_dialog_tap_confirm_with_face_alt_3">Muse ricognossude. Frache la icone Sbloche par continuâ.</string>
     <string name="biometric_dialog_authenticated">Autenticât</string>
+    <string name="biometric_dialog_cancel_authentication">Anule autenticazion</string>
     <string name="biometric_dialog_use_pin">Dopre PIN</string>
     <string name="biometric_dialog_use_pattern">Dopre cumbinazion</string>
     <string name="biometric_dialog_use_password">Dopre password</string>
@@ -159,7 +169,21 @@
     <string name="biometric_dialog_last_pin_attempt_before_wipe_profile">Se al prossim tentatîf tu inserissis un PIN sbaliât, il to profîl di lavôr e i siei dâts a vignaran eliminâts.</string>
     <string name="biometric_dialog_last_password_attempt_before_wipe_profile">Se al prossim tentatîf tu inserissis une password sbaliade, il to profîl di lavôr e i siei dâts a vignaran eliminâts.</string>
     <string name="biometric_re_enroll_dialog_confirm">Configure</string>
+    <string name="biometric_re_enroll_dialog_cancel">No cumò</string>
+    <string name="biometric_re_enroll_notification_content">Chest al è necessari par miorâ la sigurece e lis prestazions</string>
+    <string name="fingerprint_re_enroll_notification_title">Torne configure il sbloc cul impront</string>
+    <string name="fingerprint_re_enroll_notification_name">Sbloc cul impront</string>
+    <string name="fingerprint_re_enroll_dialog_title">Configure il sbloc cul impront</string>
+    <string name="fingerprint_re_enroll_dialog_content">Par configurâ il sbloc cul impront, lis tôs imagjins e i modei dal to impront corint a vignaran eliminâts.\n\nDopo de eliminazion, tu varâs di tornâ a configurâ il sbloc cul impront par podê doprâ l\'impront par sblocâ il telefon o verificâ la tô identitât.</string>
+    <string name="fingerprint_re_enroll_dialog_content_singular">Par configurâ il sbloc cul impront, lis tôs imagjins e il model dal to impront corint a vignaran eliminâts.\n\nDopo de eliminazion, tu varâs di tornâ a configurâ il sbloc cul impront par podê doprâ l\'impront par sblocâ il telefon o verificâ la tô identitât.</string>
+    <string name="fingerprint_reenroll_failure_dialog_content">Impussibil configurâ il sbloc cul impront. Va tes Impostazions e torne prove.</string>
+    <string name="face_re_enroll_notification_title">Torne configure il sbloc cu la muse</string>
+    <string name="face_re_enroll_notification_name">Sbloc cu la muse</string>
+    <string name="face_re_enroll_dialog_title">Configure il sbloc cu la muse</string>
+    <string name="face_re_enroll_dialog_content">Par tornâ a configurâ il sbloc cu la muse, il model atuâl de muse al vignarà eliminât.\n\nTu varâs di configurâ di gnûf cheste funzionalitât par doprâ la tô muse pal sbloc dal telefon.</string>
+    <string name="face_reenroll_failure_dialog_content">Impussibil configurâ il sbloc cu la muse. Va tes impostazions e torne prove.</string>
     <string name="fingerprint_dialog_touch_sensor">Tocje il sensôr di impronts digjitâi</string>
+    <string name="fingerprint_dialog_authenticated_confirmation">Frache la icone Sbloche par continuâ</string>
     <string name="fingerprint_dialog_use_fingerprint_instead">Impussibil ricognossi la muse. Dopre l\'impront.</string>
     <string name="keyguard_face_failed_use_fp">@string/fingerprint_dialog_use_fingerprint_instead</string>
     <string name="keyguard_face_failed">Muse no ricognossude</string>
@@ -220,10 +244,14 @@
     <string name="quick_settings_dnd_label">No Sta Disturbâ</string>
     <string name="quick_settings_bluetooth_label">Bluetooth</string>
     <string name="quick_settings_bluetooth_detail_empty_text">Nissun dispositîf associât diponibil</string>
+    <string name="pair_new_bluetooth_devices">Associe gnûf dispositîf</string>
+    <string name="see_all_bluetooth_devices">Viôt dutis</string>
+    <string name="quick_settings_bluetooth_device_connected">Conetût</string>
     <string name="quick_settings_bluetooth_secondary_label_battery_level"><xliff:g id="battery_level_as_percentage">%s</xliff:g> di batarie</string>
     <string name="quick_settings_bluetooth_secondary_label_audio">Audio</string>
     <string name="quick_settings_bluetooth_secondary_label_headset">Scufis</string>
     <string name="quick_settings_bluetooth_secondary_label_input">Input</string>
+    <string name="quick_settings_bluetooth_secondary_label_hearing_aids">Aparâts acustics</string>
     <string name="quick_settings_bluetooth_secondary_label_transient">Daûr a ativâ…</string>
     <string name="quick_settings_rotation_unlocked_label">Rotazion automatiche</string>
     <string name="accessibility_quick_settings_rotation">Rotazion automatiche schermi</string>
@@ -245,7 +273,6 @@
     <string name="quick_settings_casting">In trasmission</string>
     <string name="quick_settings_cast_device_default_name">Dispositîf cence non</string>
     <string name="quick_settings_cast_detail_empty_text">Nissun dispositîf disponibil</string>
-    <string name="quick_settings_cast_no_wifi">Wi\u2011Fi no conetût</string>
     <string name="quick_settings_brightness_dialog_title">Luminositât</string>
     <string name="quick_settings_inversion_label">Inversion dai colôrs</string>
     <string name="quick_settings_color_correction_label">Corezion dai colôrs</string>
@@ -273,6 +300,7 @@
     <string name="quick_settings_cellular_detail_data_limit">Limit a <xliff:g id="data_limit" example="2.0 GB">%s</xliff:g></string>
     <string name="quick_settings_cellular_detail_data_warning">Avîs a <xliff:g id="data_limit" example="2.0 GB">%s</xliff:g></string>
     <string name="quick_settings_work_mode_label">Aplicazions di lavôr</string>
+    <string name="quick_settings_work_mode_paused_state">In pause</string>
     <string name="quick_settings_night_display_label">Lûs noturne</string>
     <string name="quick_settings_night_secondary_label_on_at_sunset">Ative al tramont</string>
     <string name="quick_settings_night_secondary_label_until_sunrise">Fin al cricâ dal dì</string>
@@ -292,7 +320,19 @@
     <string name="quick_settings_screen_record_label">Regjistrazion schermi</string>
     <string name="quick_settings_screen_record_start">Scomence</string>
     <string name="quick_settings_screen_record_stop">Ferme</string>
+    <string name="qs_record_issue_start">Scomence</string>
+    <string name="qs_record_issue_stop">Ferme</string>
+    <string name="qs_record_issue_dropdown_screenrecord">Regjistrazion schermi</string>
+    <string-array name="qs_record_issue_types">
+        <item>Performance</item>
+        <item>User Interface</item>
+        <item>Batarie</item>
+    </string-array>
     <string name="quick_settings_onehanded_label">Modalitât a une man</string>
+    <string name="quick_settings_contrast_label">Contrast</string>
+    <string name="quick_settings_contrast_standard">Standard</string>
+    <string name="quick_settings_contrast_medium">Medi</string>
+    <string name="quick_settings_contrast_high">Alt</string>
     <string name="sensor_privacy_start_use_mic_dialog_title">Sblocâ il microfon dal dispositîf?</string>
     <string name="sensor_privacy_start_use_camera_dialog_title">Sblocâ la fotocjamare dal dispositîf?</string>
     <string name="sensor_privacy_start_use_mic_camera_dialog_title">Sblocâ il microfon e la fotocjamare dal dispositîf?</string>
@@ -317,6 +357,28 @@
     </string>
     <string name="sensor_privacy_mic_camera_unblocked_toast_content">        Disponibii microfon e fotocjamare
     </string>
+    <string name="sensor_privacy_mic_turned_on_dialog_title">        Microfon ativât
+    </string>
+    <string name="sensor_privacy_mic_turned_off_dialog_title">        Microfon disativât
+    </string>
+    <string name="sensor_privacy_mic_unblocked_dialog_content">        Il microfon al è ativât par dutis lis aplicazions e i servizis.
+    </string>
+    <string name="sensor_privacy_mic_blocked_no_exception_dialog_content">        L\'acès al microfon al è disativât par dutis lis aplicazions e i servizis.
+        Tu puedis ativâ l\'acès al microfon in Impostazions &gt; Riservatece &gt; Microfon.
+    </string>
+    <string name="sensor_privacy_mic_blocked_with_exception_dialog_content">        L\'acès al microfon al è disativât par dutis lis aplicazions e i servizis.
+        Tu puedis cambiâ cheste configurazion in Impostazions &gt; Riservatece &gt; Microfon.
+    </string>
+    <string name="sensor_privacy_camera_turned_on_dialog_title">        Fotocjamare ativade
+    </string>
+    <string name="sensor_privacy_camera_turned_off_dialog_title">        Fotocjamare disativade
+    </string>
+    <string name="sensor_privacy_camera_unblocked_dialog_content">        La fotocjamare e je ativade par dutis lis aplicazions e i servizis.
+    </string>
+    <string name="sensor_privacy_camera_blocked_dialog_content">        La fotocjamare e je ativade par dutis lis aplicazions e i servizis.
+    </string>
+    <string name="sensor_privacy_htt_blocked_dialog_content">Par doprâ il boton dal microfon, ative l\'acès al microfon in Impostazions.</string>
+    <string name="sensor_privacy_dialog_open_settings">Vierç Impostazions</string>
     <string name="media_seamless_other_device">Altri dispositîf</string>
     <string name="quick_step_accessibility_toggle_overview">Comute panoramiche</string>
     <string name="zen_priority_introduction">Nissun sun o vibrazion ti disturbarà, gjavâts i pro memoria, lis sveis, i events e lis clamadis che tu specifichis tu. Tu rivarâs a scoltâ dut ce che tu sielzis di riprodusi, includûts musichis, videos e zûcs.</string>
@@ -336,6 +398,7 @@
     <string name="keyguard_face_successful_unlock">Sbocât cu la muse</string>
     <string name="keyguard_face_successful_unlock_alt1">Muse ricognossude</string>
     <string name="keyguard_retry">Scor in sù par tornâ a provâ</string>
+    <string name="accesssibility_keyguard_retry">Scor in sù par tornâ a provâ il sbloc cu la muse</string>
     <string name="require_unlock_for_nfc">Sbloche par doprâ il NFC</string>
     <string name="do_disclosure_generic">Chest dispositîf al aparten ae tô organizazion</string>
     <string name="do_disclosure_with_name">Chest dispositîf al aparten a <xliff:g id="organization_name" example="Foo, Inc.">%s</xliff:g></string>
@@ -355,6 +418,8 @@
     <string name="keyguard_indication_charging_time_fast"><xliff:g id="percentage">%2$s</xliff:g> • In ricjarie rapide • Plene ca di <xliff:g id="charging_time_left" example="4 hr, 2 min">%1$s</xliff:g></string>
     <string name="keyguard_indication_charging_time_slowly"><xliff:g id="percentage">%2$s</xliff:g> • In ricjarie lente • Plene ca di <xliff:g id="charging_time_left" example="4 hr, 2 min">%1$s</xliff:g></string>
     <string name="keyguard_indication_charging_time_dock"><xliff:g id="percentage" example="20%">%2$s</xliff:g> • Ricjarie • Plene ca di <xliff:g id="charging_time_left" example="4 hr, 2 min">%1$s</xliff:g></string>
+    <string name="button_to_remove_widget">Gjave</string>
+    <string name="hub_mode_editing_exit_button_text">Fat</string>
     <string name="accessibility_multi_user_switch_switcher">Cambie utent</string>
     <string name="accessibility_multi_user_list_switcher">menù a tirâ jù</string>
     <string name="guest_exit_guest_dialog_message">Dutis lis aplicazions e i dâts in cheste session a vignaran eliminâts.</string>
@@ -381,8 +446,23 @@
     <string name="screen_share_permission_dialog_option_entire_screen">Dut il schermi</string>
     <string name="screen_share_permission_dialog_option_single_app">Une singule aplicazion</string>
     <string name="screen_share_permission_app_selector_title">Condivît o regjistre une aplicazion</string>
+    <string name="media_projection_entry_app_permission_dialog_title">Scomençâ a regjistrâ o trasmeti cun <xliff:g id="app_seeking_permission" example="Meet">%s</xliff:g>?</string>
+    <string name="media_projection_entry_app_permission_dialog_warning_entire_screen">Cuant che tu stâs condividint, regjistrant o trasmetint, <xliff:g id="app_seeking_permission" example="Meet">%s</xliff:g> al à acès a dut ce che al è visibil su schermi o che al ven riprodot sul dispositîf. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
+    <string name="media_projection_entry_app_permission_dialog_warning_single_app">Cuant che tu stâs condividint, regjistrant o trasmetint une aplicazion, <xliff:g id="app_seeking_permission" example="Meet">%s</xliff:g> al à acès a dut ce che al ven mostrât o che al ven riprodot su chê aplicazion. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
     <string name="media_projection_entry_app_permission_dialog_continue">Scomence</string>
+    <string name="media_projection_entry_app_permission_dialog_single_app_disabled"><xliff:g id="app_name" example="Meet">%1$s</xliff:g> al à disativât cheste opzion</string>
+    <string name="media_projection_entry_cast_permission_dialog_title">Scomençâ a trasmeti?</string>
+    <string name="media_projection_entry_cast_permission_dialog_warning_entire_screen">Cuant che tu stâs trasmetint, Android al à acès a dut ce che al è visibil su schermi o che al ven riprodot sul dispositîf. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
+    <string name="media_projection_entry_cast_permission_dialog_warning_single_app">Cuant che tu stâs trasmetint une aplicazion, Android al à acès a dut ce che al ven mostrât o che al ven riprodot su chê aplicazion. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
+    <string name="media_projection_entry_cast_permission_dialog_continue">Scomence a trasmeti</string>
+    <string name="media_projection_entry_generic_permission_dialog_title">Scomençâ a condividi?</string>
+    <string name="media_projection_entry_generic_permission_dialog_warning_entire_screen">Cuant che tu stâs condividint, regjistrant o trasmetint, Android al à acès a dut ce che al è visibil su schermi o che al ven riprodot sul dispositîf. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
+    <string name="media_projection_entry_generic_permission_dialog_warning_single_app">Cuant che tu stâs condividint, regjistrant o trasmetint une aplicazion, Android al à acès a dut ce che al ven mostrât o che al ven riprodot su chê aplicazion. Duncje sta atent cun robis come lis passwords, i detais di paiament, i messaçs, lis fotos e cun audio e video.</string>
     <string name="media_projection_entry_generic_permission_dialog_continue">Scomence</string>
+    <string name="media_projection_task_switcher_text">La condivision e ven metude in pause cuant che tu passis a altris aplicazions</string>
+    <string name="media_projection_task_switcher_action_switch">Condivît invezit cheste aplicazion</string>
+    <string name="media_projection_task_switcher_action_back">Torne a chê prime</string>
+    <string name="media_projection_task_switcher_notification_channel">Passaç tra aplicazions</string>
     <string name="screen_capturing_disabled_by_policy_dialog_title">Blocade dal tô aministradôr di IT</string>
     <string name="screen_capturing_disabled_by_policy_dialog_description">La acuisizion de schermade e je disativade da lis politichis dal dispositîf</string>
     <string name="clear_all_notifications_text">Nete dut</string>
@@ -431,6 +511,7 @@
     <string name="monitoring_description_ca_certificate">Une autoritât di certificazion e je stade instalade su chest dispositîf. Il trafic de tô rêt sigure al podarès jessi monitorât o modificât.</string>
     <string name="monitoring_description_management_network_logging">Il to aministradôr al à ativât il regjistri di rêt, che al monitore il trafic sul to dispositîf.</string>
     <string name="monitoring_description_managed_profile_network_logging">Il to aministradôr al à ativât la regjistrazion dai events di rêt, che e monitore il trafic tal to profîl di lavôr ma no tal to personâl.</string>
+    <string name="monitoring_description_named_vpn">Chest dispositîf al è conetût a internet midiant <xliff:g id="vpn_app" example="Foo VPN App">%1$s</xliff:g>. Il to furnidôr di VPN al pues viodi la tô ativitât in rêt, includûts i dâts di navigazion e lis e-mails.</string>
     <string name="monitoring_description_managed_device_named_vpn">Chest dispositîf al è conetût a internet midiant <xliff:g id="vpn_app" example="Foo VPN App">%1$s</xliff:g>. Il to aministradôr di IT al pues viodi la tô ativitât in rêt, includûts i dâts di navigazion e lis e-mails.</string>
     <string name="monitoring_description_two_named_vpns">Chest dispositîf al è conetût a internet midiant <xliff:g id="vpn_app" example="Foo VPN App">%1$s</xliff:g> e <xliff:g id="vpn_app" example="Bar VPN App">%2$s</xliff:g>. Il to aministradôr di IT al pues viodi la tô ativitât in rêt, includûts i dâts di navigazion e lis e-mails.</string>
     <string name="monitoring_description_managed_profile_named_vpn">Lis tôs aplicazions di lavôr a son conetudis a internet midiant <xliff:g id="vpn_app" example="Foo VPN App">%1$s</xliff:g>. Il to aministradôr di IT e il furnidôr di VPN a puedin viodi la tô ativitât in rêt, includûts i dâts di navigazion e lis e-mails.</string>
@@ -448,6 +529,11 @@
     <string name="volume_odi_captions_hint_disable">disabilite</string>
     <string name="sound_settings">Sunarie e vibrazion</string>
     <string name="volume_panel_dialog_settings_button">Impostazions</string>
+    <string name="csd_lowered_title" product="default">Volum sbassât a un nivel plui sigûr</string>
+    <string name="csd_system_lowered_text" product="default">Il volum des scufis al è stât alt par plui timp di ce che al è conseât</string>
+    <string name="csd_500_system_lowered_text" product="default">Il volum des scufis al à superât il limit di sigurece par cheste setemane</string>
+    <string name="csd_button_keep_listening" product="default">Continue a scoltâ</string>
+    <string name="csd_button_lower_volume" product="default">Sbasse il volum</string>
     <string name="screen_pinning_title">La aplicazion e je fissade</string>
     <string name="screen_pinning_description">Chest al ten la schermade in prin plan fintant che no tu le sblochis. Tocje e ten fracât Indaûr e Panoramiche par sblocâle.</string>
     <string name="screen_pinning_description_recents_invisible">Chest al ten la schermade in prin plan fintremai che no tu le sblochis. Tocje e ten fracât Indaûr e Inizi par sblocâle.</string>
@@ -553,6 +639,7 @@
     <string name="inline_ok_button">Apliche</string>
     <string name="inline_turn_off_notifications">Disative lis notifichis</string>
     <string name="notification_silence_title">Cidin</string>
+    <string name="notification_alert_title">Predefinide</string>
     <string name="notification_automatic_title">Automatic</string>
     <string name="notification_channel_summary_low">Nissun sun o vibrazion</string>
     <string name="notification_conversation_summary_low">Nissun sun o vibrazion e al somee plui in bas te sezion des conversazions</string>
@@ -605,10 +692,6 @@
     <string name="keyboard_key_button_template">Boton <xliff:g id="name">%1$s</xliff:g></string>
     <string name="keyboard_key_home">Inizi</string>
     <string name="keyboard_key_back">Indaûr</string>
-    <string name="keyboard_key_dpad_up">Sù</string>
-    <string name="keyboard_key_dpad_down">Jù</string>
-    <string name="keyboard_key_dpad_left">Çampe</string>
-    <string name="keyboard_key_dpad_right">Diestre</string>
     <string name="keyboard_key_dpad_center">Centri</string>
     <string name="keyboard_key_tab">Tab</string>
     <string name="keyboard_key_space">Spazi</string>
@@ -636,16 +719,28 @@
     <string name="keyboard_shortcut_group_system_notifications">Notifichis</string>
     <string name="keyboard_shortcut_group_system_shortcuts_helper">Scurtis di tastiere</string>
     <string name="keyboard_shortcut_group_system_switch_input">Cambie disposizion de tastiere</string>
+    <string name="keyboard_shortcut_search_list_title">Scurtis</string>
+    <string name="keyboard_shortcut_search_list_hint">Cîr scurtis</string>
+    <string name="keyboard_shortcut_search_list_no_result">Nissune scurte cjatade</string>
     <string name="keyboard_shortcut_search_category_system">Sisteme</string>
     <string name="keyboard_shortcut_search_category_input">Input</string>
+    <string name="keyboard_shortcut_search_category_open_apps">Vierç aplicazions</string>
+    <string name="keyboard_shortcut_search_category_current_app">Aplicazion atuâl</string>
+    <string name="group_system_access_system_settings">Vierç lis impostazions</string>
     <string name="group_system_lock_screen">Bloc dal schermi</string>
+    <string name="keyboard_shortcut_group_system_multitasking">Multitasking di sisteme</string>
     <string name="keyboard_shortcut_group_input">Input</string>
+    <string name="input_access_emoji">Acedi ai emoji</string>
+    <string name="input_access_voice_typing">Acedi ae scriture vocâl</string>
     <string name="keyboard_shortcut_group_applications">Aplicazions</string>
-    <string name="keyboard_shortcut_group_applications_assist">Assistence</string>
+    <string name="keyboard_shortcut_group_applications_browser">Navigadôr</string>
     <string name="keyboard_shortcut_group_applications_contacts">Contats</string>
+    <string name="keyboard_shortcut_group_applications_email">E-mail</string>
     <string name="keyboard_shortcut_group_applications_sms">SMS</string>
     <string name="keyboard_shortcut_group_applications_music">Musiche</string>
     <string name="keyboard_shortcut_group_applications_calendar">Calendari</string>
+    <string name="keyboard_shortcut_group_applications_calculator">Calcoladorie</string>
+    <string name="keyboard_shortcut_group_applications_maps">Mapis</string>
     <string name="volume_and_do_not_disturb">No Sta Disturbâ</string>
     <string name="volume_dnd_silent">Scurte dai botons dal volum</string>
     <string name="battery">Batarie</string>
@@ -810,19 +905,47 @@
     <string name="magnification_controls_title">Controi barcon di ingrandiment</string>
     <string name="accessibility_control_zoom_in">Ingrandìs</string>
     <string name="accessibility_control_zoom_out">Impiçulìs</string>
-    <string name="accessibility_control_move_up">Môf in sù</string>
-    <string name="accessibility_control_move_down">Môf in jù</string>
+    <string name="accessibility_control_move_up">Môf insù</string>
+    <string name="accessibility_control_move_down">Môf injù</string>
     <string name="accessibility_control_move_left">Môf a çampe</string>
     <string name="accessibility_control_move_right">Môf a diestre</string>
+    <string name="accessibility_control_increase_window_width">Aumente largjece dal ingrandidôr</string>
+    <string name="accessibility_control_decrease_window_width">Diminuìs largjece dal ingrandidôr</string>
+    <string name="accessibility_control_increase_window_height">Aumente altece dal ingrandidôr</string>
+    <string name="accessibility_control_decrease_window_height">Diminuìs altece dal ingrandidôr</string>
     <string name="magnification_mode_switch_description">Comutazion ingrandiment</string>
     <string name="magnification_mode_switch_state_full_screen">Ingrandìs dut il schermi</string>
     <string name="magnification_mode_switch_state_window">Ingrandìs part dal schermi</string>
+    <string name="magnification_open_settings_click_label">Vierç impostazions ingrandiment</string>
+    <string name="magnification_close_settings_click_label">Siere impostazions ingradiment</string>
+    <string name="magnification_exit_edit_mode_click_label">Jes de modalitât modifiche</string>
+    <string name="magnification_drag_corner_to_resize">Strissine il cjanton par ridimensionâ</string>
+    <string name="accessibility_allow_diagonal_scrolling">Permet scoriment diagonâl</string>
     <string name="accessibility_resize">Ridimensione</string>
+    <string name="accessibility_change_magnification_type">Cambie gjenar di ingrandiment</string>
+    <string name="accessibility_magnification_end_resizing">Finìs ridimensionament</string>
+    <string name="accessibility_magnification_top_handle">Mantie superiôr</string>
+    <string name="accessibility_magnification_left_handle">Mantie di çampe</string>
+    <string name="accessibility_magnification_right_handle">Mantie di diestre</string>
+    <string name="accessibility_magnification_bottom_handle">Mantie inferiôr</string>
+    <string name="accessibility_magnification_settings_panel_description">Impostazions di ingrandiment</string>
+    <string name="accessibility_magnifier_size">Dimension ingrandidôr</string>
+    <string name="accessibility_magnification_zoom">Zoom</string>
+    <string name="accessibility_magnification_medium">Medi</string>
+    <string name="accessibility_magnification_small">Piçul</string>
+    <string name="accessibility_magnification_large">Grant</string>
+    <string name="accessibility_magnification_fullscreen">Plen schermi</string>
     <string name="accessibility_magnification_done">Fat</string>
     <string name="accessibility_magnifier_edit">Modifiche</string>
+    <string name="accessibility_magnification_magnifier_window_settings">Impostazions dal barcon pal ingrandiment</string>
     <string name="accessibility_floating_button_migration_tooltip">Tocje par vierzi lis funzions di acès facilitât. Personalize o sostituìs chest boton tes Impostazions.\n\n<annotation id="link">Viôt impostazions</annotation></string>
     <string name="accessibility_floating_button_docking_tooltip">Sposte il boton tal ôr par platâlu in mût temporani</string>
     <string name="accessibility_floating_button_undo">Disfe</string>
+    <string name="accessibility_floating_button_undo_message_label_text">Scurte di <xliff:g id="feature name" example="Magnification">%s</xliff:g> gjavade</string>
+    <string name="accessibility_floating_button_undo_message_number_text">{count, plural,
+        one {}=1 {# scurte gjavade}
+        other {# scurtis gjavadis}
+    }</string>
     <string name="accessibility_floating_button_action_move_top_left">Sposte in alt a çampe</string>
     <string name="accessibility_floating_button_action_move_top_right">Sposte in alt a diestre</string>
     <string name="accessibility_floating_button_action_move_bottom_left">Sposte in bas a çampe</string>
@@ -848,11 +971,14 @@
     <string name="accessibility_control_change_unfavorite">gjavâ l\'element dai preferîts</string>
     <string name="accessibility_control_move">Sposte te posizion <xliff:g id="number" example="1">%d</xliff:g></string>
     <string name="controls_favorite_default_title">Controi</string>
+    <string name="controls_favorite_subtitle">Sielç i controi dal dispositîf par acedi daurman</string>
     <string name="controls_favorite_rearrange">Ten fracât e strissine par rangjâ i controi</string>
     <string name="controls_favorite_removed">Ducj i controi gjavâts</string>
     <string name="controls_favorite_toast_no_changes">Modifichis no salvadis</string>
     <string name="controls_favorite_see_other_apps">Viôt atris aplicazions</string>
+    <string name="controls_favorite_rearrange_button">Torne rangje</string>
     <string name="controls_favorite_add_controls">Zonte controi</string>
+    <string name="controls_favorite_back_to_editing">Torne ae modifiche</string>
     <string name="controls_favorite_load_error">Nol è stât pussibil cjariâ i controi. Verifiche la aplicazion <xliff:g id="app" example="System UI">%s</xliff:g> par controlâ che lis impostazions de aplicazion no sedin cambiadis.</string>
     <string name="controls_favorite_load_none">Controi compatibii no disponibii</string>
     <string name="controls_favorite_other_zone_header">Altri</string>
@@ -874,8 +1000,10 @@
     <string name="controls_pin_instructions_retry">Prove un altri PIN</string>
     <string name="controls_confirmation_message">Conferme modifiche par <xliff:g id="device" example="Backdoor lock">%s</xliff:g></string>
     <string name="controls_structure_tooltip">Scor par viodi altri</string>
+    <string name="retry_face">Torne prove autenticazion cu la muse</string>
     <string name="controls_seeding_in_progress">Daûr a cjariâ i conseis</string>
     <string name="controls_media_title">Multimedia</string>
+    <string name="controls_media_close_session">Platâ chest control multimediâl par <xliff:g id="app_name" example="Foo Music App">%1$s</xliff:g>?</string>
     <string name="controls_media_active_session">Nol è pussibil platâ la session multimediâl atuâl.</string>
     <string name="controls_media_dismiss_button">Plate</string>
     <string name="controls_media_resume">Ripie</string>
@@ -928,6 +1056,7 @@
     <string name="media_output_dialog_volume_percentage"><xliff:g id="percentage" example="10">%1$d</xliff:g>%%</string>
     <string name="media_output_group_title_speakers_and_displays">Cassis e schermis</string>
     <string name="media_output_group_title_suggested_device">Dispositîfs sugjerîts</string>
+    <string name="media_output_end_session_dialog_summary">Ferme la tô session di condivision par spostâ file multimediâi suntun altri dispositîf</string>
     <string name="media_output_end_session_dialog_stop">Ferme</string>
     <string name="media_output_first_broadcast_title">Cemût funzionie la trasmission</string>
     <string name="media_output_broadcast">Trasmission</string>
@@ -941,6 +1070,7 @@
     <string name="media_output_broadcast_update_error">Impussibil salvâ. Torne prove.</string>
     <string name="media_output_broadcast_last_update_error">Impussibil salvâ.</string>
     <string name="media_output_broadcast_code_hint_no_less_than_min">Dopre almancul 4 caratars</string>
+    <string name="media_output_broadcast_edit_hint_no_more_than_max">Dopre mancul di <xliff:g id="length" example="16">%1$d</xliff:g> caratars</string>
     <string name="build_number_clip_data_label">Numar di compilazion</string>
     <string name="build_number_copy_toast">Numar di compilazion copiât intes notis.</string>
     <string name="basic_status">Vierç conversazion</string>
@@ -982,6 +1112,7 @@
     <string name="battery_state_unknown_notification_title">Probleme tal lei l\'indicadôr di nivel de batarie</string>
     <string name="battery_state_unknown_notification_text">Tocje par vê plui informazions</string>
     <string name="qs_alarm_tile_no_alarm">Nissune svee</string>
+    <string name="accessibility_bouncer">inserìs il bloc schermi</string>
     <string name="accessibility_fingerprint_label">Sensôr di impronts digjitâi</string>
     <string name="accessibility_authenticate_hint">autenticâsi</string>
     <string name="accessibility_enter_hint">acedi al dispositîf</string>
@@ -1037,6 +1168,7 @@
     <string name="clipboard_edit">modificâ</string>
     <string name="add">Zonte</string>
     <string name="manage_users">Gjestìs utents</string>
+    <string name="drag_split_not_supported">Cheste notifiche no supuarte il strissinament su schermi dividût</string>
     <string name="dream_overlay_status_bar_wifi_off">Wi\u2011Fi no disponibil</string>
     <string name="dream_overlay_status_bar_priority_mode">Modalitât prioritât</string>
     <string name="dream_overlay_status_bar_alarm_set">Svee configurade</string>
@@ -1049,16 +1181,31 @@
     }</string>
     <string name="dream_overlay_weather_complication_desc">        <xliff:g id="weather_condition" example="Partly cloudy">%1$s</xliff:g>, <xliff:g id="temperature" example="7°C">%2$s</xliff:g>
     </string>
+    <string name="note_task_button_label">Cjape notis</string>
+    <string name="note_task_shortcut_long_label">Cjape notis, <xliff:g id="note_taking_app" example="Note-taking App">%1$s</xliff:g></string>
     <string name="broadcasting_description_is_broadcasting">Trasmission in cors</string>
     <string name="bt_le_audio_broadcast_dialog_title">Interompi la trasmission di <xliff:g id="app_name" example="App Name 1">%1$s</xliff:g>?</string>
-    <string name="bt_le_audio_broadcast_dialog_sub_title">Se tu trasmetis <xliff:g id="switchApp" example="App Name 2">%1$s</xliff:g> o tu cambis la jessude, la trasmission corinte si interomparà</string>
+    <string name="bt_le_audio_broadcast_dialog_sub_title">Se tu trasmetis <xliff:g id="switchApp" example="App Name 2">%1$s</xliff:g> o tu cambiis la jessude, la trasmission corinte si interomparà</string>
     <string name="bt_le_audio_broadcast_dialog_switch_app">Trasmeti <xliff:g id="switchApp" example="App Name 2">%1$s</xliff:g></string>
     <string name="bt_le_audio_broadcast_dialog_different_output">Cambie jessude</string>
     <string name="bt_le_audio_broadcast_dialog_unknown_name">Unknown</string>
     <string name="dream_time_complication_12_hr_time_format">h:mm</string>
     <string name="dream_time_complication_24_hr_time_format">kk:mm</string>
+    <string name="log_access_confirmation_title">Permeti a <xliff:g id="log_access_app_name" example="Example App">%s</xliff:g> di acedi a ducj i regjistris dal dispositîf?</string>
+    <string name="log_access_confirmation_allow">Permet acès una tantum</string>
+    <string name="log_access_confirmation_deny">No sta permeti</string>
+    <string name="log_access_confirmation_body">Il dispositîf al regjistre ce che al sucêt tal to dispositîf. Lis aplicazions a puedin doprâ chescj regjistris par cjatâ e comedâ problemis.\n\nCualchi regjistri al podarès contignî informazions sensibilis, duncje concêt l\'acès a ducj i regjistris dal dispositîf nome aes aplicazions che tu ti fidis.
+        \n\nSe no tu ti fidis che cheste aplicazion e vedi acès a ducj i regjistris dal dispositîf, cheste e pues distès acedi al so regjistri personâl. Il produtôr dal to dispositîf al podarès distès rivâ a acedi a cualchi regjistri o informazion sul to dispositîf.
+    </string>
     <string name="log_access_confirmation_learn_more">Plui informazions</string>
+    <string name="log_access_confirmation_learn_more_at">Scuvierç di plui su <xliff:g id="url" example="g.co/android/devicelogs">%s</xliff:g></string>
     <string name="keyguard_affordance_enablement_dialog_action_template">Vierç <xliff:g id="appName" example="Wallet">%1$s</xliff:g></string>
+    <string name="wallet_quick_affordance_unavailable_install_the_app">Par zontâ la aplicazion Wallet come scurte, controle che la aplicazion e sedi instalade</string>
+    <string name="wallet_quick_affordance_unavailable_configure_the_app">Par zontâ la aplicazion Wallet come scurte, verifiche che almancul une cjarte e sedi stade zontade</string>
+    <string name="home_quick_affordance_unavailable_install_the_app">Par zontâ la aplicazion di Inizi come scurte, controle che la aplicazion e sedi instalade</string>
+    <string name="home_quick_affordance_unavailable_configure_the_app">• Al è disponibil almancul un dispositîf o panel di dispositîf</string>
+    <string name="notes_app_quick_affordance_unavailable_explanation">Selezione une aplicazion pes notis predefinide di doprâ la scurte par cjapâ notis</string>
+    <string name="keyguard_affordance_enablement_dialog_notes_app_action">Selezione aplicazion</string>
     <string name="keyguard_affordance_press_too_short">Tocje e ten fracade la scurte</string>
     <string name="rear_display_bottom_sheet_cancel">Anule</string>
     <string name="rear_display_bottom_sheet_confirm">Cambie schermi cumò</string>
@@ -1072,13 +1219,37 @@
     <string name="stylus_battery_low_subtitle">Conet la pene a un cjariebatariis</string>
     <string name="stylus_battery_low">Baterie de pene in esauriment</string>
     <string name="video_camera">Videocjamare</string>
+    <string name="call_from_work_profile_title">Impussibil clamâ di une aplicazion personâl</string>
+    <string name="call_from_work_profile_text">La tô organizazion ti permet di fâ clamadis dome cu lis aplicazions di lavôr</string>
     <string name="call_from_work_profile_action">Passe al profîl di lavôr</string>
+    <string name="install_dialer_on_work_profile_action">Instale une aplicazion di lavôr par telefonâ</string>
     <string name="call_from_work_profile_close">Anule</string>
+    <string name="lock_screen_settings">Personalize la schermade di bloc</string>
+    <string name="keyguard_unlock_to_customize_ls">Sbloche par personalizâ la schermade di bloc</string>
     <string name="wifi_unavailable_dream_overlay_content_description">Wi-Fi no disponibil</string>
     <string name="camera_blocked_dream_overlay_content_description">Fotocjamare blocade</string>
     <string name="camera_and_microphone_blocked_dream_overlay_content_description">Fotocjamare e microfon blocâts</string>
     <string name="microphone_blocked_dream_overlay_content_description">Microfon blocât</string>
     <string name="priority_mode_dream_overlay_content_description">Modalitât prioritât ative</string>
+    <string name="set_default_notes_app_toast_content">Stabilìs in Impostazions la aplicazion pes notis predefinide</string>
+    <string name="install_app">Instale aplicazion</string>
+    <string name="dismiss_dialog">Scarte</string>
+    <string name="privacy_dialog_title">Microfon e fotocjamare</string>
+    <string name="privacy_dialog_summary">Utilizazion resinte des aplicazions</string>
+    <string name="privacy_dialog_more_button">Viôt i acès resints</string>
     <string name="privacy_dialog_done_button">Fat</string>
+    <string name="privacy_dialog_expand_action">Slargje e mostre lis opzions</string>
     <string name="privacy_dialog_collapse_action">Strenç</string>
+    <string name="privacy_dialog_close_app_button">Siere cheste aplicazion</string>
+    <string name="privacy_dialog_close_app_message"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> sierât</string>
+    <string name="privacy_dialog_manage_service">Gjestìs il servizi</string>
+    <string name="privacy_dialog_manage_permissions">Gjestìs l\'acès</string>
+    <string name="privacy_dialog_active_call_usage">In ûs de clamade telefoniche</string>
+    <string name="privacy_dialog_recent_call_usage">Doprât di resint intune clamade telefoniche</string>
+    <string name="privacy_dialog_active_app_usage">In ûs di <xliff:g id="app_name" example="Gmail">%1$s</xliff:g></string>
+    <string name="privacy_dialog_recent_app_usage">Doprât di resint di <xliff:g id="app_name" example="Gmail">%1$s</xliff:g></string>
+    <string name="privacy_dialog_active_app_usage_1">In ûs di <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> (<xliff:g id="attribution_label" example="For Wallet">%2$s</xliff:g>)</string>
+    <string name="privacy_dialog_recent_app_usage_1">Doprât di resint di <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> (<xliff:g id="attribution_label" example="For Wallet">%2$s</xliff:g>)</string>
+    <string name="privacy_dialog_active_app_usage_2">In ûs di <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> (<xliff:g id="attribution_label" example="For Wallet">%2$s</xliff:g> \u2022 <xliff:g id="proxy_label" example="Speech services">%3$s</xliff:g>)</string>
+    <string name="privacy_dialog_recent_app_usage_2">Doprât di resint di <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> (<xliff:g id="attribution_label" example="For Wallet">%2$s</xliff:g> \u2022 <xliff:g id="proxy_label" example="Speech services">%3$s</xliff:g>)</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-gd/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-gd/strings.xml
index 87f64df..6a26de9 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-gd/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-gd/strings.xml
@@ -26,7 +26,7 @@
     <string name="battery_saver_confirmation_title_generic">Mu chaomhnaiche a’ bhataraidh</string>
     <string name="battery_saver_confirmation_ok">Cuir air</string>
     <string name="battery_saver_start_action">Cuir air</string>
-    <string name="battery_saver_dismiss_action">Cha chuir mi seo an comas</string>
+    <string name="battery_saver_dismiss_action">Cha phrìnich mi seo</string>
     <string name="status_bar_settings_auto_rotation">Cuairtich an sgrìn gu fèin-obrachail</string>
     <string name="usb_device_permission_prompt">Am faod <xliff:g id="application" example="Usb Mega Player">%1$s</xliff:g> <xliff:g id="usb_device" example="USB Headphones">%2$s</xliff:g> inntrigeadh?</string>
     <string name="usb_device_permission_prompt_warn">Am faod <xliff:g id="application" example="Usb Mega Player">%1$s</xliff:g> <xliff:g id="usb_device" example="USB Headphones">%2$s</xliff:g> inntrigeadh?\nCha d’ fhuair an aplacaid seo cead clàraidh ach b’ urrainn dhi fuaim a ghlacadh leis an uidheam USB seo.</string>
@@ -171,6 +171,8 @@
     <string name="quick_settings_dnd_label">Na bris a-steach orm</string>
     <string name="quick_settings_bluetooth_label">Bluetooth</string>
     <string name="quick_settings_bluetooth_detail_empty_text">Chan eil uidheam paidhrichte ri làimh</string>
+    <string name="pair_new_bluetooth_devices">Paidhrich uidheam ùr</string>
+    <string name="quick_settings_bluetooth_device_connected">Ceangailte</string>
     <string name="quick_settings_bluetooth_secondary_label_battery_level"><xliff:g id="battery_level_as_percentage">%s</xliff:g> a bhataraidh</string>
     <string name="quick_settings_bluetooth_secondary_label_audio">Fuaimean</string>
     <string name="quick_settings_bluetooth_secondary_label_headset">Seata-cinn</string>
@@ -189,7 +191,6 @@
     <string name="quick_settings_casting">Tilgeil</string>
     <string name="quick_settings_cast_device_default_name">Uidheam gun ainm</string>
     <string name="quick_settings_cast_detail_empty_text">Chan eil uidheam ri làimh</string>
-    <string name="quick_settings_cast_no_wifi">Cha deach WiFi a cheangal</string>
     <string name="quick_settings_brightness_dialog_title">Soilleireachd</string>
     <string name="quick_settings_done">Deiseil</string>
     <string name="quick_settings_close_user_panel">Dùin</string>
@@ -224,6 +225,13 @@
     <string name="quick_settings_nfc_on">Tha NFC an comas</string>
     <string name="quick_settings_screen_record_start">Toiseach</string>
     <string name="quick_settings_screen_record_stop">Cuir stad air</string>
+    <string name="qs_record_issue_start">Toiseach</string>
+    <string name="qs_record_issue_stop">Cuir stad air</string>
+    <string-array name="qs_record_issue_types">
+        <item>Performance</item>
+        <item>User Interface</item>
+        <item>Bataraidh</item>
+    </string-array>
     <string name="quick_step_accessibility_toggle_overview">Toglaich am foir-shealladh</string>
     <string name="zen_priority_introduction">Cha dèid briseadh a-steach ort le fuaimean no crith ach o chaismeachdan, cuimhneachain no tachartasan agus on luchd-ghairm a shònraicheas tu. Cluinnidh tu fhathast na thaghas tu fhèin, a’ gabhail a-staigh ceòl, videothan is geamannan.</string>
     <string name="zen_alarms_introduction">Cha dèid briseadh a-steach ort le fuaimean no crith ach o chaismeachdan. Cluinnidh tu fhathast na thaghas tu fhèin, a’ gabhail a-staigh ceòl, videothan is geamannan.</string>
@@ -245,6 +253,8 @@
     <string name="interruption_level_none_twoline">Tost\nslàn</string>
     <string name="interruption_level_priority_twoline">Le prìomhachas\na-mhàin</string>
     <string name="interruption_level_alarms_twoline">Caismeachdan\na-mhàin</string>
+    <string name="button_to_remove_widget">Thoir air falbh</string>
+    <string name="hub_mode_editing_exit_button_text">Deiseil</string>
     <string name="accessibility_multi_user_switch_switcher">Geàrr leum gu cleachdaiche eile</string>
     <string name="guest_exit_guest_dialog_message">Thèid a h-uile aplacaid is dàta san t-seisean seo a sguabadh às.</string>
     <string name="guest_wipe_session_title">Fàilte air ais, aoigh!</string>
@@ -417,10 +427,6 @@
     <string name="keyboard_key_button_template">Putan <xliff:g id="name">%1$s</xliff:g></string>
     <string name="keyboard_key_home">Dachaigh</string>
     <string name="keyboard_key_back">Air ais</string>
-    <string name="keyboard_key_dpad_up">Suas</string>
-    <string name="keyboard_key_dpad_down">Sìos</string>
-    <string name="keyboard_key_dpad_left">Clì</string>
-    <string name="keyboard_key_dpad_right">Deas</string>
     <string name="keyboard_key_dpad_center">Meadhan</string>
     <string name="keyboard_key_tab">Tab</string>
     <string name="keyboard_key_space">Space</string>
@@ -449,11 +455,13 @@
     <string name="keyboard_shortcut_group_system_switch_input">Atharraich co-dhealbhachd a’ mheur-chlàir</string>
     <string name="keyboard_shortcut_search_category_system">An siostam</string>
     <string name="keyboard_shortcut_search_category_input">Ion-chur</string>
+    <string name="group_system_access_system_settings">Fosgail na roghainnean</string>
     <string name="group_system_lock_screen">An sgrìn-ghlasaidh</string>
     <string name="keyboard_shortcut_group_input">Ion-chur</string>
     <string name="keyboard_shortcut_group_applications">Aplacaidean</string>
-    <string name="keyboard_shortcut_group_applications_assist">Cuidiche</string>
+    <string name="keyboard_shortcut_group_applications_browser">Brabhsair</string>
     <string name="keyboard_shortcut_group_applications_contacts">Luchd-aithne</string>
+    <string name="keyboard_shortcut_group_applications_email">Post-d</string>
     <string name="keyboard_shortcut_group_applications_sms">SMS</string>
     <string name="keyboard_shortcut_group_applications_music">Ceòl</string>
     <string name="keyboard_shortcut_group_applications_calendar">Mìosachan</string>
@@ -572,7 +580,7 @@
     <string name="mobile_data_disable_title">An cuir thu dheth dàta mobile?</string>
     <string name="mobile_data_disable_message">Cha bhi cothrom agad air dàta no an t-eadar-lìon slighe <xliff:g id="carrier" example="T-Mobile">%s</xliff:g>. Chan fhaigh thu an t-eadar-lìon ach slighe WiFi.</string>
     <string name="mobile_data_disable_message_default_carrier">a’ ghiùlanair agad</string>
-    <string name="auto_data_switch_dialog_negative_button">Cha chuir mi seo an comas</string>
+    <string name="auto_data_switch_dialog_negative_button">Cha phrìnich mi seo</string>
     <string name="touch_filtered_warning">Air sgàth ’s gu bheil aplacaid a’ falach iarrtas air cead, chan urrainn
         do ghleus nan roghainnean an fhreagairt agad a dhearbhadh.</string>
     <string name="slice_permission_title">A bheil thu airson cead a thoirt dha <xliff:g id="app" example="Example App">%1$s</xliff:g> ach an seall e slisean dhe <xliff:g id="app_2" example="Other Example App">%2$s</xliff:g>?</string>
@@ -626,7 +634,7 @@
     <string name="controls_dialog_ok">Cuir ris</string>
     <string name="controls_dialog_remove">Thoir air falbh</string>
     <string name="controls_dialog_message">’Ga mholadh le <xliff:g id="app" example="System UI">%s</xliff:g></string>
-    <string name="controls_settings_dialog_neutral_button">Cha chuir mi seo an comas</string>
+    <string name="controls_settings_dialog_neutral_button">Cha phrìnich mi seo</string>
     <string name="controls_pin_use_alphanumeric">Tha litrichean no samhlaidhean sa PIN</string>
     <string name="controls_pin_verify">Dearbh <xliff:g id="device" example="Backdoor lock">%s</xliff:g></string>
     <string name="controls_pin_wrong">PIN ceàrr</string>
@@ -670,6 +678,7 @@
     <string name="log_access_confirmation_learn_more">Barrachd fiosrachaidh</string>
     <string name="rear_display_bottom_sheet_cancel">Sguir dheth</string>
     <string name="call_from_work_profile_close">Sguir dheth</string>
+    <string name="dismiss_dialog">Leig seachad</string>
     <string name="privacy_dialog_done_button">Deiseil</string>
     <string name="privacy_dialog_collapse_action">Co-theannaich</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-kab-rDZ/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-kab-rDZ/strings.xml
index a5f8b26..d148d5e 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-kab-rDZ/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-kab-rDZ/strings.xml
@@ -64,6 +64,7 @@
     <string name="accessibility_quick_settings_bluetooth_on">Bluetooth irmed.</string>
     <string name="accessibility_quick_settings_more_time">Ugar n wakud.</string>
     <string name="data_usage_disabled_dialog_enable">Kemmel</string>
+    <string name="quick_settings_bluetooth_device_connected">Iqqen</string>
     <string name="quick_settings_bluetooth_secondary_label_audio">Imesli</string>
     <string name="quick_settings_bluetooth_secondary_label_headset">Amsegdal n timesliwt</string>
     <string name="quick_settings_bluetooth_secondary_label_input">Anekcum</string>
@@ -81,10 +82,19 @@
     <string name="quick_settings_dark_mode_secondary_label_battery_saver">Aḥraz n uẓru</string>
     <string name="quick_settings_screen_record_start">Bdu</string>
     <string name="quick_settings_screen_record_stop">Seḥbes</string>
+    <string name="qs_record_issue_start">Bdu</string>
+    <string name="qs_record_issue_stop">Seḥbes</string>
+    <string-array name="qs_record_issue_types">
+        <item>Performance</item>
+        <item>User Interface</item>
+        <item>Aẓru</item>
+    </string-array>
     <string name="zen_priority_customize_button">Sagen</string>
     <string name="interruption_level_none">Tasusmi taččurant</string>
     <string name="interruption_level_priority">Tazwart kan</string>
     <string name="interruption_level_alarms">Aṭenṭen kan</string>
+    <string name="button_to_remove_widget">Kkes</string>
+    <string name="hub_mode_editing_exit_button_text">Immed</string>
     <string name="accessibility_multi_user_switch_switcher">Beddel aseqdac</string>
     <string name="guest_wipe_session_wipe">Ales tanekra</string>
     <string name="user_remove_user_remove">Kkes</string>
@@ -129,10 +139,6 @@
     <string name="battery_detail_switch_title">Aḥraz n uẓru</string>
     <string name="keyboard_key_home">Agdil agejdan</string>
     <string name="keyboard_key_back">Ar deffir</string>
-    <string name="keyboard_key_dpad_up">Asawen</string>
-    <string name="keyboard_key_dpad_down">Bas</string>
-    <string name="keyboard_key_dpad_left">Azelmad</string>
-    <string name="keyboard_key_dpad_right">Ayeffus</string>
     <string name="keyboard_key_dpad_center">Alemmas</string>
     <string name="keyboard_key_tab">Tabulation</string>
     <string name="keyboard_key_space">Espace</string>
@@ -157,10 +163,13 @@
     <string name="keyboard_shortcut_group_system_shortcuts_helper">Inegzumen n unasiw</string>
     <string name="keyboard_shortcut_search_category_system">Anagraw</string>
     <string name="keyboard_shortcut_search_category_input">Anekcum</string>
+    <string name="group_system_access_system_settings">Ldi iγewwaṛen</string>
     <string name="group_system_lock_screen">Agdil usewḥel</string>
     <string name="keyboard_shortcut_group_input">Anekcum</string>
     <string name="keyboard_shortcut_group_applications">Isnasen</string>
+    <string name="keyboard_shortcut_group_applications_browser">Iminig</string>
     <string name="keyboard_shortcut_group_applications_contacts">Inermisen</string>
+    <string name="keyboard_shortcut_group_applications_email">Imayl</string>
     <string name="keyboard_shortcut_group_applications_sms">SMS</string>
     <string name="keyboard_shortcut_group_applications_music">Aẓawan</string>
     <string name="keyboard_shortcut_group_applications_calendar">Tasmektit</string>
@@ -244,6 +253,7 @@
     <string name="log_access_confirmation_learn_more">Issin ugar</string>
     <string name="rear_display_bottom_sheet_cancel">Sefsex</string>
     <string name="call_from_work_profile_close">Sefsex</string>
+    <string name="dismiss_dialog">Suref</string>
     <string name="privacy_dialog_done_button">Immed</string>
     <string name="privacy_dialog_collapse_action">Ḍfes</string>
 </resources>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-lb/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-lb/strings.xml
index 1e5d7e9..cd07b84 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-lb/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-lb/strings.xml
@@ -64,6 +64,7 @@
     <string name="ethernet_label">Ethernet</string>
     <string name="quick_settings_bluetooth_label">Bluetooth</string>
     <string name="quick_settings_bluetooth_detail_empty_text">Keng gekoppelt Apparater disponibel</string>
+    <string name="quick_settings_bluetooth_device_connected">Verbonnen</string>
     <string name="quick_settings_rotation_unlocked_label">Automatesch rotéieren</string>
     <string name="accessibility_quick_settings_rotation">Schierm automatesch rotéieren</string>
     <string name="quick_settings_location_label">Standuert</string>
@@ -85,6 +86,8 @@
     <string name="quick_settings_cellular_detail_data_used"><xliff:g id="data_used" example="2.0 GB">%s</xliff:g> benotzt</string>
     <string name="quick_settings_cellular_detail_data_limit"><xliff:g id="data_limit" example="2.0 GB">%s</xliff:g>-Limitt</string>
     <string name="quick_settings_cellular_detail_data_warning"><xliff:g id="data_limit" example="2.0 GB">%s</xliff:g> Warnung</string>
+    <string name="button_to_remove_widget">Ewechhuelen</string>
+    <string name="hub_mode_editing_exit_button_text">Fäerdeg</string>
     <string name="accessibility_multi_user_switch_switcher">Benotzer wiesselen</string>
     <string name="guest_exit_guest_dialog_message">All d\'Appen an Daten an dëser Sëtzung gi geläscht.</string>
     <string name="guest_wipe_session_title">Wëllkomm zréck, Gaascht!</string>
diff --git a/overlay/frameworks/base/packages/SystemUI/res/values-sc-rIT/strings.xml b/overlay/frameworks/base/packages/SystemUI/res/values-sc-rIT/strings.xml
index 8dc93bc..8102565 100644
--- a/overlay/frameworks/base/packages/SystemUI/res/values-sc-rIT/strings.xml
+++ b/overlay/frameworks/base/packages/SystemUI/res/values-sc-rIT/strings.xml
@@ -86,7 +86,7 @@
     <string name="biometric_dialog_last_pattern_attempt_before_wipe_profile">Si pones un\'ischema isballiadu a su tentativu imbeniente, su profilu de traballu e is datos ant a èssere cantzellados dae su dispositivu.</string>
     <string name="biometric_dialog_last_pin_attempt_before_wipe_profile">Si pones unu PIN isballiadu a su tentativu imbeniente, su profilu de traballu e is datos ant a èssere cantzellados dae su dispositivu.</string>
     <string name="biometric_dialog_last_password_attempt_before_wipe_profile">Si pones una crae isballiada a su tentativu imbeniente, su profilu de traballu e is datos s\'ant a cantzellare dae su dispositivu.</string>
-    <string name="biometric_re_enroll_dialog_confirm">Imposta</string>
+    <string name="biometric_re_enroll_dialog_confirm">Cunfigura</string>
     <string name="accessibility_bluetooth_connected">Bluetooth collegadu.</string>
     <string name="accessibility_battery_unknown">Càrriga de sa bateria disconnota.</string>
     <string name="accessibility_bluetooth_name">Collegadu a <xliff:g id="bluetooth" example="Car Audio">%s</xliff:g>.</string>
@@ -118,6 +118,7 @@
     <string name="ethernet_label">Ethernet</string>
     <string name="quick_settings_bluetooth_label">Bluetooth</string>
     <string name="quick_settings_bluetooth_detail_empty_text">Non b\'at dispositivos de assotziare a disponimentu</string>
+    <string name="quick_settings_bluetooth_device_connected">Connètidu</string>
     <string name="quick_settings_rotation_unlocked_label">Rotatzione automàtica</string>
     <string name="accessibility_quick_settings_rotation">Rotatzione automàtica de s\'ischermu</string>
     <string name="quick_settings_location_label">Positzione</string>
@@ -156,6 +157,8 @@
     <string name="interruption_level_none_twoline">Totale\nsilèntziu</string>
     <string name="interruption_level_priority_twoline">Prioridade\nisceti</string>
     <string name="interruption_level_alarms_twoline">Isvèllias\nisceti</string>
+    <string name="button_to_remove_widget">Boga</string>
+    <string name="hub_mode_editing_exit_button_text">Fatu</string>
     <string name="accessibility_multi_user_switch_switcher">Càmbia utente</string>
     <string name="guest_exit_guest_dialog_message">Totu is aplicatziones e datos in custa sessione ant a èssere cantzellados.</string>
     <string name="guest_wipe_session_message">Boles sighire sa sessione tua?</string>
diff --git a/overlay/packages/apps/AudioFX/res/values-ast-rES/strings.xml b/overlay/packages/apps/AudioFX/res/values-ast-rES/strings.xml
deleted file mode 100644
index 4f549e1..0000000
--- a/overlay/packages/apps/AudioFX/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2010-2011 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="app_name">MusicFX</string>
-    <string name="no_effects">Los efeutos nun tán disponibles.</string>
-    <string name="eq_dialog_title">Ecualizador</string>
-    <string name="headset_plug">Conecta los auriculares pa usar estos efeutos.</string>
-    <string name="bass_boost_strength">Potenciación de graves</string>
-    <string name="virtualizer_strength">Soníu envolvente</string>
-    <string name="setup">Configuración</string>
-    <string name="ci_extreme">Potenciador d\'efeutos</string>
-    <string name="user">Usuariu</string>
-    <string name="picker_title">Panel contr. efeut. musicales</string>
-</resources>
diff --git a/overlay/packages/apps/Car/Launcher/app/res/values-ast-rES/strings.xml b/overlay/packages/apps/Car/Launcher/app/res/values-ast-rES/strings.xml
deleted file mode 100644
index 2378609..0000000
--- a/overlay/packages/apps/Car/Launcher/app/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2018 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_title">Llanzador d\'aplicaciones del coche</string>
-    <string name="app_launcher_title_all_apps">Toles aplicaciones</string>
-    <string name="app_launcher_title_media_only">Aplicaciones multimedia</string>
-    <string name="driving_toast_text">        «<xliff:g id="app_name" example="Settings">%1$s</xliff:g>» nun se pue usar mentanto conduces.
-    </string>
-    <string name="ongoing_call_duration_text_separator"> • </string>
-    <string name="ongoing_call_text">Llamada en cursu</string>
-    <string name="hide_debug_apps">Amosar les aplicaciones de depuración</string>
-    <string name="show_debug_apps">Anubrir les aplicaciones de depuración</string>
-</resources>
diff --git a/overlay/packages/apps/Car/Launcher/app/res/values-cy/strings.xml b/overlay/packages/apps/Car/Launcher/app/res/values-cy/strings.xml
deleted file mode 100644
index 47393e1..0000000
--- a/overlay/packages/apps/Car/Launcher/app/res/values-cy/strings.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2018 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_title">Llwythwr Car</string>
-    <string name="app_launcher_title_all_apps">Pob ap</string>
-    <string name="app_launcher_title_media_only">Apiau cyfryngau</string>
-    <string name="driving_toast_text">        Ni ellir ddefnyddio <xliff:g id="app_name" example="Settings">%1$s</xliff:g> tra\'n gyrru.</string>
-    <string name="ongoing_call_text">Galwad ar y gweill</string>
-    <string name="dialing_call_text">Yn deialu…</string>
-    <string name="projection_devices">{count, plural,
-        zero {# dyfeisiau}
-       =1 {# ddyfais}
-        two {# ddyfais}
-        other {# dyfais}
-    }</string>
-    <string name="weather_app_name">Tywydd</string>
-    <string name="hide_debug_apps">Cuddio apiau dadfygio</string>
-    <string name="show_debug_apps">Dangos apiau dadfygio</string>
-</resources>
diff --git a/overlay/packages/apps/Car/Launcher/app/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Car/Launcher/app/res/values-fur-rIT/strings.xml
deleted file mode 100644
index 0430473..0000000
--- a/overlay/packages/apps/Car/Launcher/app/res/values-fur-rIT/strings.xml
+++ /dev/null
@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2018 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_title">Inviadôr aplicazion de auto</string>
-    <string name="app_launcher_title_all_apps">Dutis lis aplicazions</string>
-    <string name="app_launcher_title_media_only">Aplicazions multimediâls</string>
-    <string name="driving_toast_text">        Nol è pussibil doprâ <xliff:g id="app_name" example="Settings">%1$s</xliff:g> intant che tu vuidis.
-    </string>
-    <string name="tap_for_more_info_text">Tocje la cjarte par vê plui informazions</string>
-    <string name="tap_to_launch_text">Tocje la cjarte par inviâ</string>
-    <string name="ongoing_call_duration_text_separator"> • </string>
-    <string name="ongoing_call_text">Clamade in cors</string>
-    <string name="dialing_call_text">Daûr a componi…</string>
-    <string name="projected_launch_text">Invie Android Auto</string>
-    <string name="projected_onclick_launch_error_toast_text">Impussibil inviâ Android Auto. Nissune ativitât cjatade.</string>
-    <string name="projection_devices">{count, plural,
-        one {}=1 {# dispositîf}
-        other {# dispositîfs}
-        }
-    </string>
-    <string name="weather_app_name">Meteo</string>
-    <string name="fake_weather_main_text">--\u00B0 Pal plui soreli</string>
-    <string name="fake_weather_footer_text">Mountain View • H: --\u00B0 L: --\u00B0</string>
-    <string name="hide_debug_apps">Plate lis aplicazions di debug</string>
-    <string name="show_debug_apps">Mostre lis aplicazions di debug</string>
-</resources>
diff --git a/overlay/packages/apps/Car/Launcher/app/res/values-gd/strings.xml b/overlay/packages/apps/Car/Launcher/app/res/values-gd/strings.xml
deleted file mode 100644
index 5c705d5..0000000
--- a/overlay/packages/apps/Car/Launcher/app/res/values-gd/strings.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2018 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_title">Lòinsear a’ chàir</string>
-    <string name="app_launcher_title_all_apps">A h-uile aplacaid</string>
-    <string name="app_launcher_title_media_only">Aplacaidean mheadhanan</string>
-    <string name="driving_toast_text">        Chan fhaod thu <xliff:g id="app_name" example="Settings">%1$s</xliff:g> a chleachdadh fhad ’s a bhios tu a’ draibheadh.
-    </string>
-    <string name="hide_debug_apps">Falaich aplacaidean an dì-bhugachaidh</string>
-    <string name="show_debug_apps">Seall aplacaidean an dì-bhugachaidh</string>
-</resources>
diff --git a/overlay/packages/apps/Car/LinkViewer/res/values-ast-rES/strings.xml b/overlay/packages/apps/Car/LinkViewer/res/values-ast-rES/strings.xml
deleted file mode 100644
index 4db1a0a..0000000
--- a/overlay/packages/apps/Car/LinkViewer/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2018 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name">Visor d\'enllaces</string>
-</resources>
diff --git a/overlay/packages/apps/Car/Notification/res/values-ast-rES/strings.xml b/overlay/packages/apps/Car/Notification/res/values-ast-rES/strings.xml
index 77fd45e..85ac88d 100644
--- a/overlay/packages/apps/Car/Notification/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/Car/Notification/res/values-ast-rES/strings.xml
@@ -15,27 +15,10 @@
     limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="assist_action_play_label">Reproducir</string>
     <string name="assist_action_reply_label">Responder</string>
-    <string name="action_mute_short">Inorar</string>
-    <string name="action_mute_long">Inorar la conversación</string>
-    <string name="action_unmute_short">Dexar d\'inorar</string>
-    <string name="action_unmute_long">Dexar d\'inorar la conversación</string>
-    <string name="action_canned_reply">Toi conduciendo.</string>
-    <string name="canned_reply_message">Toi conduciendo.</string>
-    <string name="toast_message_sent_success">El mensaxe unvióse correutamente.</string>
-    <string name="notification_service_label">Serviciu oyente d\'avisos del coche</string>
-    <string name="notifications">Centru d\'avisos</string>
-    <string name="clear_all">Quitar too</string>
-    <string name="ellipsized_string">…</string>
-    <string name="show_more">Amosar más</string>
-    <string name="notification_header">Avisos</string>
     <string name="notification_recents">Elementos de recién</string>
     <string name="notification_older">Avisos antiguos</string>
-    <string name="empty_notification_header">Nun hai avisos</string>
-    <string name="collapse_group">Contrayer el grupu</string>
     <string name="show_more_from_app"><xliff:g id="count">%1$d</xliff:g> más de: <xliff:g id="app">%2$s</xliff:g></string>
-    <string name="show_count_more">Amosar <xliff:g id="count">%d</xliff:g> más</string>
     <plurals name="message_unshown_count">
         <item quantity="one"><xliff:g id="count">%d</xliff:g> mensaxe más</item>
         <item quantity="other"><xliff:g id="count">%d</xliff:g> mensaxes más</item>
diff --git a/overlay/packages/apps/Car/Notification/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Car/Notification/res/values-fur-rIT/strings.xml
index 41bfc4c..fecfa3f 100644
--- a/overlay/packages/apps/Car/Notification/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/Car/Notification/res/values-fur-rIT/strings.xml
@@ -15,6 +15,7 @@
     limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_label">Gjestôr notifichis automobil</string>
     <string name="assist_action_play_label">Riprodûs</string>
     <string name="assist_action_reply_label">Rispuint</string>
     <string name="action_mute_short">Cidine</string>
@@ -33,7 +34,6 @@
     <string name="notification_recents">Resints</string>
     <string name="notification_older">Notifichis mancul resintis</string>
     <string name="empty_notification_header">Nissune notifiche</string>
-    <string name="collapse_group">Strenç grup</string>
     <string name="show_more_from_app">Altris <xliff:g id="count">%1$d</xliff:g> di <xliff:g id="app">%2$s</xliff:g></string>
     <string name="show_count_more">Mostre ancjemò <xliff:g id="count">%d</xliff:g></string>
     <plurals name="message_unshown_count">
@@ -47,4 +47,13 @@
     <string name="see_more_message">Viôt di plui</string>
     <string name="restricted_hun_message_content">Gnûf messaç</string>
     <string name="manage_text">Gjestìs</string>
+    <string name="category_car_emergency">car_emergency</string>
+    <string name="category_navigation">navigation</string>
+    <string name="category_call">call</string>
+    <string name="category_message">msg</string>
+    <string name="pkg_car_dialer">com.android.car.dialer</string>
+    <string name="hun_suppression_channel_name">Sopression notifichis in risalt</string>
+    <string name="hun_suppression_notification_title_park">Tegniti inzornât su lis ultimis gnovis</string>
+    <string name="hun_suppression_notification_title_drive">Concentriti inte vuide</string>
+    <string name="hun_suppression_notification_description">Cualchi gnove notifiche e ven salvade tal Centri notifichis</string>
 </resources>
diff --git a/overlay/packages/apps/Car/Settings/res/values-ast-rES/strings.xml b/overlay/packages/apps/Car/Settings/res/values-ast-rES/strings.xml
index 0c378d0..ac02433 100644
--- a/overlay/packages/apps/Car/Settings/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/Car/Settings/res/values-ast-rES/strings.xml
@@ -15,186 +15,38 @@
     limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="settings_label">Axustes</string>
-    <string name="more_settings_label">Más</string>
-    <string name="display_settings">Pantalla</string>
-    <string name="brightness">Nivel del brillu</string>
-    <string name="auto_brightness_title">Brillu adautable</string>
-    <string name="network_and_internet">Rede ya internet</string>
-    <string name="mobile_network_settings">Rede móvil</string>
     <string name="mobile_network_summary_count">        {count, plural, one {}
             =1    {# SIM}
             other {# SIMs}
         }
     </string>
-    <string name="mobile_network_toggle_title">Datos móviles</string>
-    <string name="mobile_network_mobile_network_toggle_title">Rede móvil</string>
-    <string name="roaming_title">Roaming</string>
-    <string name="roaming_alert_title">¿Quies permitir el roaming de datos?</string>
-    <string name="data_usage_title">Datos primarios</string>
-    <string name="data_usage_warning_save_title">Guardar</string>
     <string name="network_and_internet_vehicle_internet_title">Internet del vehículu</string>
-    <string name="wifi_settings">Wi\u2011Fi</string>
-    <string name="wifi_failed_forget_message">Hebo un fallu al escaecer la rede</string>
-    <string name="wifi_failed_connect_message">Hebo un fallu al conectase a la rede</string>
     <string name="wifi_connecting">Conectando\u2026</string>
-    <string name="wifi_password">Contraseña</string>
-    <string name="wifi_security">Seguranza</string>
-    <string name="wifi_signal_strength">Intensidá de la señal</string>
-    <string name="wifi_status">Estáu</string>
-    <string name="wifi_frequency">Frecuencia</string>
-    <string name="link_speed">%1$d Mbps</string>
-    <string name="wifi_band_24ghz">2,4 GHz</string>
-    <string name="wifi_band_5ghz">5 GHz</string>
-    <string name="wifi_dns">DNS</string>
-    <string name="wifi_gateway">Pasera</string>
-    <string name="learn_more">Saber más</string>
-    <string name="wifi_hotspot_password_title">Contraseña del puntu Wi-Fi</string>
-    <string name="wifi_hotspot_security_title">Seguranza</string>
     <string name="wifi_hotspot_wpa3_sae">WPA3-Personal</string>
     <string name="wifi_security_psk_sae">WPA2/WPA3-Personal</string>
-    <string name="wifi_hotspot_wpa2_personal">WPA2-Personal</string>
-    <string name="wifi_ap_choose_2G">Banda de 2,4 GHz</string>
-    <string name="wifi_ap_choose_5G">Banda de 5,0 GHz</string>
-    <string name="wifi_ap_2G">2,4 GHz</string>
-    <string name="wifi_ap_5G">5,0 GHz</string>
-    <string name="tether_settings_title_all">Puntu Wi-Fi y tethering</string>
     <string name="hotspot_settings_title">Puntu Wi-Fi</string>
-    <string name="wifi_error">Fallu</string>
-    <string name="network_connection_timeout_dialog_ok">Retentar</string>
-    <string name="network_connection_request_dialog_showall">Amosar too</string>
-    <string name="bluetooth_settings_title">Bluetooth</string>
-    <string name="bluetooth_device">Preséu ensin nome</string>
-    <string name="bluetooth_disconnect_title">¿Quies desconectar el preséu?</string>
-    <string name="bluetooth_name">Nome del vehículu</string>
-    <string name="bluetooth_rename_button">Renomar</string>
-    <string name="bluetooth_available_devices">Preseos disponibles</string>
-    <string name="bluetooth_profiles">Perfiles</string>
-    <string name="bluetooth_turning_on">"Habilitando'l Bluetooth\u2026"</string>
-    <string name="bluetooth_turning_off">"Inhabilitando'l Bluetooth\u2026"</string>
-    <string name="bluetooth_ask_enablement">«<xliff:g id="app_name" example="FancyApp">%1$s</xliff:g>» quier habilitar el Bluetooth</string>
-    <string name="bluetooth_ask_disablement">«<xliff:g id="app_name" example="FancyApp">%1$s</xliff:g>» quier inhabilitar el Bluetooth</string>
-    <string name="bluetooth_ask_enablement_no_name">Una aplicación quier habilitar el Bluetooth</string>
-    <string name="bluetooth_ask_disablement_no_name">Una aplicación quier deshabilitar el Bluetooth</string>
-    <string name="bluetooth_bonded_bluetooth_toggle_content_description">Bluetooth</string>
-    <string name="bluetooth_bonded_media_toggle_content_description">Multimedia</string>
-    <string name="language_settings">Llingües</string>
-    <string name="languages_and_input_settings">Llingües y entrada</string>
-    <string name="language_picker_list_all_header">Toles llingües</string>
-    <string name="keyboard_settings">Tecláu</string>
-    <string name="text_to_speech_preferred_engine_settings">Motor preferíu</string>
-    <string name="text_to_speech_current_engine">Motor actual</string>
-    <string name="sound_settings">Soníu</string>
-    <string name="incoming_call_volume_title">Timbre</string>
-    <string name="media_volume_title">Multimedia</string>
-    <string name="ringtone_picker_save_title">Guardar</string>
     <string name="display_brightness">Brillu</string>
-    <string name="units_settings">Unidaes</string>
-    <string name="units_speed_title">Velocidá</string>
-    <string name="units_distance_title">Distancia</string>
-    <string name="units_fuel_consumption_title">Consumu del combustible</string>
-    <string name="units_energy_consumption_title">Consumu de la enerxía</string>
-    <string name="units_temperature_title">Temperatura</string>
-    <string name="units_volume_title">Volume</string>
-    <string name="units_pressure_title">Presión</string>
-    <string name="units_unit_name_meter_per_sec">Metru per segundu</string>
-    <string name="units_unit_name_rpm">Revoluciones per minutu</string>
-    <string name="units_unit_name_hertz">Herciu</string>
-    <string name="units_unit_name_percentile">Percentil</string>
-    <string name="units_unit_name_millimeter">Milímetru</string>
-    <string name="units_unit_name_meter">Metru</string>
-    <string name="units_unit_name_kilometer">Quilómetru</string>
-    <string name="units_unit_name_mile">Milla</string>
-    <string name="units_unit_name_celsius">Celsius</string>
-    <string name="units_unit_name_fahrenheit">Fahrenheit</string>
-    <string name="units_unit_name_kelvin">Kelvin</string>
-    <string name="units_unit_name_milliliter">Milímetru</string>
-    <string name="units_unit_name_liter">Llitru</string>
-    <string name="units_unit_name_us_gallon">Galón</string>
-    <string name="units_unit_name_imperial_gallon">Galón imperial</string>
-    <string name="units_unit_name_nano_secs">Nanosegundu</string>
-    <string name="units_unit_name_secs">Segundu</string>
-    <string name="units_unit_name_year">Añu</string>
-    <string name="units_unit_name_kilopascal">Quilopascal</string>
-    <string name="units_unit_name_milliampere">Miliamperiu</string>
-    <string name="units_unit_name_millivolt">Milivoltiu</string>
-    <string name="units_unit_name_milliwatts">Milivatiu</string>
-    <string name="units_unit_name_miles_per_hour">Milles per hora</string>
-    <string name="units_unit_name_kilometers_per_hour">Quilómetros per hora</string>
-    <string name="units_unit_name_bar">Bar</string>
-    <string name="units_unit_name_degrees">Grau</string>
-    <string name="units_unit_name_kilometers_per_liter">Quilómetros per llitru</string>
-    <string name="apps_and_notifications_settings">Aplicaciones y avisos</string>
-    <string name="force_stop_dialog_text">Si forcies la parada d\'una aplicación, ye posible que nun se comporte afayadizamente.</string>
+    <string name="force_stop_success_toast_text">        «<xliff:g id="app_name" example="Radio">%1$s</xliff:g>» paró.
+    </string>
     <string name="prioritize_app_performance_dialog_action_on">Sí</string>
     <string name="prioritize_app_performance_dialog_action_off">Non, gracies</string>
-    <string name="disable_text">Desactivar</string>
-    <string name="enable_text">Activar</string>
-    <string name="uninstall_text">Desinstalar</string>
-    <string name="app_disable_dialog_text">Si desactives esta aplicación, ye posible qu\'Android y otres aplicaciones nun funcionen correutamente.</string>
-    <string name="app_disable_dialog_positive">Desactivar l\'aplicación</string>
-    <string name="permissions_label">Permisos</string>
-    <string name="notifications_label">Avisos</string>
-    <string name="storage_application_label">Almacenamientu y caché</string>
-    <string name="application_version_label">Versión: %1$s</string>
     <string name="data_usage_all_apps_title">Toles aplicaciones</string>
-    <string name="computing_size">Calculando\u2026</string>
     <string name="runtime_permissions_additional_count">        {count, plural,
             =1    {# permisu adicional}
             other {# permisos adicionales}
         }
     </string>
-    <string name="assist_app_settings">Aplicación d\'asistencia</string>
-    <string name="voice_input_settings_title">Entrada de voz</string>
-    <string name="autofill_settings_title">Serviciu d\'autorrellenu</string>
-    <string name="app_launch_supported_domain_urls_title">Enllaces compatibles</string>
     <string name="apps_settings_title">Aplicaciones</string>
     <string name="apps_permission_manager_title">Xestor de permisos</string>
-    <string name="notification_listener_revoke_warning_confirm">Desactivar</string>
-    <string name="notification_listener_revoke_warning_cancel">Encaboxar</string>
-    <string name="more_special_access_title">Más</string>
-    <string name="location_settings_title">Llocalización</string>
     <string name="location_toggle_title">Usar la llocalización</string>
-    <string name="location_settings_services_title">Servicios de llocalización</string>
+    <string name="location_driver_assistance_privacy_policy_button_text">Política</string>
     <string name="microphone_settings_title">Micrófonu</string>
     <string name="microphone_toggle_title">Usar el micrófonu</string>
-    <string name="microphone_settings_loading_app_permission_stats">Cargando\u2026</string>
-    <string name="system_setting_title">Sistema</string>
-    <string name="system_update_settings_title">Anovamientos del sistema</string>
-    <string name="continue_confirmation">Siguir</string>
-    <string name="firmware_version">Versión d\'Android</string>
-    <string name="hardware_info">Modelu y hardware</string>
-    <string name="kernel_version">Versión del kernel</string>
-    <string name="device_status_activity_title">Estáu</string>
-    <string name="device_status">Estáu</string>
-    <string name="about_summary">Android <xliff:g example="6.0" id="version">%1$s</xliff:g></string>
-    <string name="legal_information">Información llegal</string>
-    <string name="copyright_title">Copyright</string>
-    <string name="license_title">Llicencia</string>
-    <string name="terms_title">Términos y condiciones</string>
-    <string name="wallpaper_attributions">Fondos de pantalla</string>
-    <string name="model_info">Modelu</string>
-    <string name="status_serial_number">Númberu de serie</string>
-    <string name="hardware_revision">Versión del hardware</string>
-    <string name="settings_license_activity_title">Llicencies de terceros</string>
-    <string name="settings_license_activity_unavailable">Hai un problema al cargar les llicencies.</string>
-    <string name="settings_license_activity_loading">Cargando\u2026</string>
     <string name="show_dev_countdown">        {count, plural,
             =1    {Fáltate # toque p\'activar les opciones de desendolcu.}
             other {Fáltente # toques p\'activar les opciones de desendolcu.}
         }
     </string>
-    <string name="show_dev_on">¡Activesti les opciones de desendolcu!</string>
-    <string name="show_dev_already">Les opciones de desendolcu yá tán activaes.</string>
-    <string name="developer_options_settings">Opciones pa desendolcadores</string>
-    <string name="reset_network_item_mobile"><li>Datos móviles</li></string>
-    <string name="factory_reset_progress_text">Espera…</string>
-    <string name="date_and_time_settings_title">Data y hora</string>
-    <string name="date_time_set_time_title">Hora</string>
-    <string name="date_time_set_timezone_title">Fusu horariu</string>
-    <string name="date_time_set_date_title">Data</string>
-    <string name="date_picker_title">Data</string>
-    <string name="time_picker_title">Hora</string>
     <string name="user_new_user_name">Perfil nuevu</string>
     <string name="user_limit_reached_message">        {count, plural, one {}
             =1    {Namás se pue crear un perfil.}
@@ -203,48 +55,7 @@
     </string>
     <string name="delete_user_dialog_title">¿Quies desaniciar esti perfil?</string>
     <string name="delete_user_error_title">Nun se desanició\'l perfil. Pues reaniciar el preséu y volver tentalo.</string>
-    <string name="delete_user_error_dismiss">Escartar</string>
-    <string name="delete_user_error_retry">Retentar</string>
-    <string name="current_user_name">Tu (%1$s)</string>
-    <string name="user_name_label">Nome</string>
-    <string name="name_input_blank_error">El campu nun pue tar baleru</string>
-    <string name="users_list_title">Usuarios</string>
-    <string name="profiles_list_title">Perfiles</string>
-    <string name="storage_settings_title">Almacenamientu</string>
-    <string name="storage_music_audio">Música y audiu</string>
-    <string name="storage_other_apps">Otres aplicaciones</string>
-    <string name="storage_files">Ficheros</string>
-    <string name="storage_audio_files_title">Ficheros d\'audiu</string>
-    <string name="memory_calculating_size">Calculando\u2026</string>
-    <string name="accounts_settings_title">Cuentes</string>
-    <string name="really_remove_account_title">¿Quies quitar la cuenta?</string>
-    <string name="remove_account_error_title">Hebo un fallu al quitar la cuenta.</string>
-    <string name="privacy_settings_title">Privacidá</string>
     <string name="mute_mic_title">Micrófonu</string>
-    <string name="security_settings_title">Seguranza</string>
-    <string name="security_settings_subtitle">Bloquéu de pantalla</string>
-    <string name="security_lock_pattern">Patrón</string>
-    <string name="security_lock_pin">PIN</string>
-    <string name="security_lock_password">Contraseña</string>
-    <string name="lockpattern_confirm_button_text">Confirmar</string>
-    <string name="lockpattern_restart_button_text">Volver dibuxar</string>
-    <string name="continue_button_text">Siguir</string>
-    <string name="lockscreen_retry_button_text">Retentar</string>
-    <string name="lockscreen_skip_button_text">Saltar</string>
-    <string name="lockpattern_retry_button_text">Borrar</string>
-    <string name="lockpattern_cancel_button_text">Encaboxar</string>
-    <string name="lockpattern_pattern_wrong">El patrón ye incorreutu</string>
-    <string name="lockpattern_settings_help_how_to_record">Cómo dibuxar un patrón de desbloquéu</string>
-    <string name="okay">D\'acuerdu</string>
-    <string name="confirm_pins_dont_match">Los PIN nun concasen</string>
-    <string name="lockscreen_wrong_pin">El PIN ye incorreutu</string>
-    <string name="lockscreen_wrong_password">La contraseña ye incorreuta</string>
-    <string name="confirm_passwords_dont_match">Les contraseñes nun concasen</string>
-    <string name="lockpassword_clear_label">Borrar</string>
-    <string name="lockpassword_cancel_label">Encaboxar</string>
-    <string name="lockpassword_confirm_label">Confirmar</string>
-    <string name="lockpassword_pin_recently_used">L\'alministrador del preséu nun permite usar un PIN recién</string>
-    <string name="lockpassword_password_recently_used">L\'alministrador del preséu nun permite usar una contraseña recién</string>
     <string name="lockpassword_password_requires_alpha">Ha contener polo menos una lletra</string>
     <string name="lockpassword_password_requires_digit">Ha contener polo menos un díxitu</string>
     <string name="lockpassword_password_requires_symbol">Ha contener polo menos un símbolu</string>
@@ -293,19 +104,6 @@
         other {Ha contener polos menos # díxitos}
         }
     </string>
-    <string name="credentials_reset_hint">¿Quies quitar tol conteníu?</string>
-    <string name="forget">Escaecer</string>
-    <string name="connect">Conectar</string>
-    <string name="disconnect">Desconectar</string>
-    <string name="delete_button">Desaniciar</string>
-    <string name="remove_button">Quitar</string>
-    <string name="cancel">Encaboxar</string>
-    <string name="allow">Permitir</string>
-    <string name="deny">Negar</string>
-    <string name="backspace_key">Tecla de retrocesu</string>
-    <string name="suggestion_dismiss_button">ESCARTAR</string>
-    <string name="restricted_while_driving">La función nun ta disponible mentanto conduces</string>
-    <string name="default_search_query">Buscar</string>
     <string name="assistant_and_voice_setting_title">Asistente y voz</string>
     <string name="notifications_all_apps">Toles aplicaciones</string>
     <string name="profiles_and_accounts_settings_title">Perfiles y cuentes</string>
@@ -339,6 +137,4 @@
     <string name="captions_settings_text_style_yellow_on_black">Mariellu sobre prietu</string>
     <string name="captions_settings_text_style_yellow_on_blue">Mariellu sobre azul</string>
     <string name="screen_reader_options_title">Opciones</string>
-    <string name="screen_reader_description_title">Axustes</string>
-    <string name="camera_settings_loading_app_permission_stats">Cargando\u2026</string>
 </resources>
diff --git a/overlay/packages/apps/Car/Settings/res/values-cy/strings.xml b/overlay/packages/apps/Car/Settings/res/values-cy/strings.xml
index 5205c85..567f183 100644
--- a/overlay/packages/apps/Car/Settings/res/values-cy/strings.xml
+++ b/overlay/packages/apps/Car/Settings/res/values-cy/strings.xml
@@ -162,7 +162,6 @@
     <string name="wifi_ap_2G">2.4 GHz</string>
     <string name="wifi_ap_5G">5.0 GHz</string>
     <string name="wifi_ap_band_select_one">Rhaid dewis o leiaf un band ar gyfer y llecyn Wi\u2011Fi:</string>
-    <string name="tether_settings_title_all">Llecyn Wi\u2011Fi a thenynnu</string>
     <string name="hotspot_settings_title">Llecyn Wi-Fi</string>
     <string name="wifi_hotspot_state_off">I ffwrdd</string>
     <string name="wifi_hotspot_auto_off_title">Troi\'r llecyn i ffwrdd yn awtomatig</string>
@@ -410,6 +409,7 @@
     <string name="notification_listener_revoke_warning_summary">Os fyddi\'n gwrthod mynediad <xliff:g id="notification_listener_name">%1$s</xliff:g> at hysbysiadau, mae\'n bosib y bydd mynediad at Dim Tarfu hefyd yn cael ei wrthod.</string>
     <string name="notification_listener_revoke_warning_confirm">Troi i ffwrdd</string>
     <string name="notification_listener_revoke_warning_cancel">Diddymu</string>
+    <string name="performance_impacting_apps_button_label">Blaenoriaethu ap</string>
     <string name="premium_sms_access_title">Mynediad SMS premiwm</string>
     <string name="premium_sms_access_description">Gall SMS Premiwm gostio arian i ti a bydd yn ymddangos ar filiau dy ddarparwr gwasanaeth symudol. Os wyt ti\'n rhoi caniatâd i ap, mi fydd yn bosib iti anfon SMS Premiwm gyda\'r ap hwnnw.</string>
     <string name="usage_access_title">Mynediad at ddefnydd</string>
@@ -418,6 +418,7 @@
     <string name="wifi_control_description">Mae rheolaeth Wi-Fi yn caniatáu i ap droi Wi-Fi ymlaen ac i ffwrdd, sganio am a chysylltu â rhwydweithiau Wi-Fi, tynnu neu ychwanegu rhwydweithiau neu dechrau llecyn Wi-Fi.</string>
     <string name="more_special_access_title">Rhagor</string>
     <string name="location_settings_title">Lleoliad</string>
+    <string name="adas_location_toggle_off_warning">Os wyt yn troi hwn i ffwrdd, bydd apiau cymorth gyrrwr sy\u2019n ddibynol ar wybodaeth lleoliad yn cael eu hanalluogi</string>
     <string name="location_no_recent_access">Dim apiau diweddar</string>
     <string name="location_settings_app_permissions_title">Caniatâd lefel apiau</string>
     <string name="location_settings_services_title">Gwasanaethau Lleoliad</string>
@@ -667,6 +668,7 @@
     <string name="lockpassword_cancel_label">Diddymu</string>
     <string name="lockpassword_confirm_label">Cadarnhau</string>
     <string name="choose_lock_password_hints">Rhaid bod o leiaf 4 nod.</string>
+    <string name="locktype_unavailable">Nid yw\u2019r math yma o glo ar gael.</string>
     <string name="lockpassword_pin_contains_non_digits">Rhaid cynnwys digidau 0 i 9 yn unig.</string>
     <string name="lockpassword_pin_recently_used">Dyw gweinyddwr y ddyfais ddim yn caniatáu defnyddio PIN diweddar</string>
     <string name="lockpassword_pin_denylisted_by_admin">Mae dy weinyddwr TGCh wedi rhwystro rhifau PIN cyffredin. Rho gynnig ar PIN gwahanol.</string>
@@ -786,6 +788,7 @@
         }
     </string>
     <string name="number_of_device_admins_none">Dim apiau wedi\u2019u actifadu</string>
+    <string name="work_policy_privacy_settings_no_org_name">Polisi cerbyd</string>
     <string name="enterprise_privacy_none">Dim</string>
     <string name="enterprise_privacy_enterprise_set_default_apps">Apiau rhagosodedig</string>
     <string name="factory_reset_parked_title">Ailosod y system gwybodloniant</string>
diff --git a/overlay/packages/apps/Car/Settings/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Car/Settings/res/values-fur-rIT/strings.xml
index b8e89ab..ecb646b 100644
--- a/overlay/packages/apps/Car/Settings/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/Car/Settings/res/values-fur-rIT/strings.xml
@@ -30,7 +30,9 @@
         }
     </string>
     <string name="mobile_network_active_sim">Atîf / SIM</string>
-    <string name="mobile_network_inactive_sim">No atîf / SIM</string>
+    <string name="mobile_network_inactive_sim">Inatîf / SIM</string>
+    <string name="mobile_network_active_esim">Atîf / eSIM</string>
+    <string name="mobile_network_inactive_esim">Inatîf / eSIM</string>
     <string name="mobile_network_list_add_more">Zonte altris</string>
     <string name="mobile_network_toggle_title">Dâts mobii</string>
     <string name="mobile_network_toggle_summary">Acêt ai dâts doprant la rêt mobile</string>
@@ -170,7 +172,6 @@
     <string name="wifi_ap_2G">2,4 GHz</string>
     <string name="wifi_ap_5G">5 GHz</string>
     <string name="wifi_ap_band_select_one">Sielç almancul une bande pal pont di acès Wi\u2011Fi:</string>
-    <string name="tether_settings_title_all">Pont di acès e tethering</string>
     <string name="hotspot_settings_title">Pont di acès</string>
     <string name="wifi_hotspot_state_off">Off</string>
     <string name="wifi_hotspot_auto_off_title">Disative il pont di acès in automatic</string>
@@ -231,6 +232,7 @@
     <string name="bluetooth_notif_message">Tocje par associâ cun <xliff:g id="device_name">%1$s</xliff:g>.</string>
     <string name="bluetooth_device_picker">Sielç dispositîf Bluetooth</string>
     <string name="bluetooth_bonded_bluetooth_toggle_content_description">Bluetooth</string>
+    <string name="bluetooth_bonded_phone_toggle_content_description">Telefon</string>
     <string name="bluetooth_bonded_media_toggle_content_description">Contignûts multimediâi</string>
     <string name="language_settings">Lenghis</string>
     <string name="languages_and_input_settings">Lenghis e imission</string>
@@ -315,7 +317,11 @@
     <string name="app_permissions">Permès de aplicazion</string>
     <string name="app_permissions_summary">Controle l\'acès des aplicazions ai tiei dâts</string>
     <string name="applications_settings">Informazions aplicazion</string>
+    <string name="force_stop">Ferme aplicazion</string>
+    <string name="force_stop_dialog_title">Fermâ la aplicazion?</string>
     <string name="force_stop_dialog_text">Se tu sfuarcis la interuzion di une aplicazion, e podarès compuartâsi in mût anomal.</string>
+    <string name="force_stop_success_toast_text">        La aplicazion <xliff:g id="app_name" example="Radio">%1$s</xliff:g> e je stade fermade.
+    </string>
     <string name="prioritize_app_performance_dialog_title">Ativâ prioritât a prestazions de aplicazion?</string>
     <string name="prioritize_app_performance_dialog_text">Cheste operazion e pues causâ une potenziâl instabilitât dal sisteme o efiets sul hardware a lunc tiermin. Desideristu continuâ?</string>
     <string name="prioritize_app_performance_dialog_action_on">Sì</string>
@@ -431,10 +437,9 @@
     <string name="wifi_control_description">Il control dal Wi-Fi al permet a une aplicazion di ativâ o disativâ il Wi-Fi, scansionâ e conetiti a rêts Wi-Fi, zontâ o gjavâ rêts o inviâ un pont di acès dome-locâl.</string>
     <string name="more_special_access_title">Altri</string>
     <string name="location_settings_title">Posizion</string>
-    <string name="location_settings_footer">        Il servizi di gjeolocalizazion al podarès doprâ sorzints come GPS, Wi\u2011Fi, rêts
-        mobilis e sensôrs par judâ a stimâ la posizion dal to dispositîf.
-    </string>
     <string name="location_toggle_title">Dopre posizion</string>
+    <string name="location_toggle_summary">        Dopre la posizion de tô machine cun dutis lis aplicazions che tu âs specificât.
+    </string>
     <string name="location_toggle_off_warning">        Se tu lu disativis, l\'acès ae posizion al vignarà gjavât a dutis lis aplicazions gjavadis chês che a coventin pe assistence ae vuide
     </string>
     <string name="adas_location_toggle_off_warning">        Se tu disativis cheste impostazion, lis aplicazions di assistence ae vuide che si
@@ -442,13 +447,37 @@
     </string>
     <string name="adas_location_toggle_confirm_label">        Disative distès
     </string>
+    <string name="adas_location_toggle_popup_summary">        Nol è pussibil cambiâ cheste impostazion e e je stade disativade dal produtôr de machine.
+    </string>
+    <string name="adas_location_toggle_title">        Funzions che ti judin te vuide
+    </string>
+    <string name="adas_location_toggle_summary">        Permet aes funzionalitâts integradis, aprovadis dal produtôr de tô machine, di acedi
+        ae sô posizion.
+    </string>
     <string name="location_recently_accessed">Utilizazions resintis</string>
     <string name="location_settings_recently_accessed_title">Utilizazions resintis</string>
     <string name="location_settings_recently_accessed_view_all_title">Viôt dutis</string>
     <string name="location_no_recent_access">Nissune aplicazion resinte</string>
+    <string name="driver_assistance_label">        <xliff:g id="time" example="1 min. ago">%1$s</xliff:g> \u2022 Assistence ae vuide \u2022
+        Domandât acès    </string>
+    <string name="location_adas_apps_list_title">        Funzions che ti judin te vuide
+    </string>
+    <string name="location_driver_assistance_privacy_policy_button_text">Politiche</string>
     <string name="location_settings_app_permissions_title">Permès a nivel di aplicazion</string>
+    <string name="location_settings_app_permissions_summary">        Gjestìs permès individuâi des aplicazions
+    </string>
     <string name="location_settings_services_title">Servizis di gjeolocalizazion</string>
     <string name="location_use_location_title">Dopre posizion</string>
+    <string name="location_access_settings_title">Acès ae posizion</string>
+    <string name="location_access_settings_summary">        Sielç se lis aplicazions a puedin acedi ae posizion de tô machine
+    </string>
+    <string name="location_access_disclaimer_summary">        Il produtôr de tô machine al podarà distès otignî la posizion dal automobil. Tu puedis revisionâ
+        lis lôr politichis par vê plui informazions.
+    </string>
+    <string name="location_adas_app_info_summary">        Chestis funzions integradis a domandin acès ae posizion de tô machine par assisti cu la
+        vuide.\n\nScuvierç di plui su cemût che ogni aplicazion e dopre i dâts de tô posizion, leint lis lôr Politichis su la
+        Riservatece.
+    </string>
     <string name="microphone_settings_title">Microfon</string>
     <string name="microphone_toggle_title">Dopre microfon</string>
     <string name="microphone_toggle_summary">Permet a dutis lis aplicazions di acedi al to microfon</string>
@@ -468,6 +497,8 @@
     <string name="system_update_settings_title">Inzornaments di sisteme</string>
     <string name="system_advanced_title">Avanzadis</string>
     <string name="system_advanced_summary">Informazions, informazions legâls, ripristinament e altri</string>
+    <string name="restart_infotainment_system_title">Torne invie il sisteme di infotainment</string>
+    <string name="restart_infotainment_system_dialog_text">Il gnûf inviament dal to sisteme di infotainment al pues puartâ vie cualchi minût. Desideristu continuâ?</string>
     <string name="continue_confirmation">Continue</string>
     <string name="firmware_version">Version di Android</string>
     <string name="security_patch">Nivel de corezion di sigurece di Android</string>
@@ -512,7 +543,11 @@
     <string name="developer_options_settings">Opzions pal svilupadôr</string>
     <string name="reset_options_title">Opzions di ripristinament</string>
     <string name="reset_options_summary">Ripristinament di rêt, aplicazions o dispositîf</string>
+    <string name="reset_network_title">Ripristine Wi\u2011Fi e Bluetooth</string>
+    <string name="reset_network_desc">Cheste operazion e ripristinarà lis impostazions dal Wi\u2011Fi e dal Bluetooth, gjavant de memorie lis conessions precedentis:</string>
+    <string name="reset_network_item_wifi"><li>Rêts Wi\u2011Fi e passwords</li></string>
     <string name="reset_network_item_mobile"><li>Dâts mobii</li></string>
+    <string name="reset_network_item_bluetooth"><li>Telefons e altris dispositîfs Bluetooth</li></string>
     <string name="reset_esim_title">Scancele dutis lis eSIMs dal veicul</string>
     <string name="reset_esim_desc">Cheste operazion no anularà il to plan dai servizis.</string>
     <string name="reset_esim_error_title">Impussibil ripristinâ lis eSIMs</string>
@@ -562,7 +597,7 @@
     <string name="confirm_grant_admin">Sì, rint aministradôr</string>
     <string name="create_user_permission_title">Cree gnûfs profîi</string>
     <string name="outgoing_calls_permission_title">Fâ telefonadis</string>
-    <string name="sms_messaging_permission_title">Messaçs midiant dâts mobii de automobil</string>
+    <string name="sms_messaging_permission_title">Messaçs midiant dâts mobii de machine</string>
     <string name="install_apps_permission_title">Instalazion di gnovis aplicazions</string>
     <string name="uninstall_apps_permission_title">Disinstalazion di aplicazions</string>
     <string name="user_add_user_menu">Zonte profîl</string>
@@ -807,6 +842,8 @@
     <string name="exit_retail_mode_dialog_confirmation_button_text">Siere dimostrazion</string>
     <string name="suggestion_dismiss_button">IGNORE</string>
     <string name="restricted_while_driving">Funzion no disponibile intant che tu vuidis</string>
+    <string name="restricted_for_passenger">Domande al vuidadôr di cambiâ la impostazion</string>
+    <string name="restricted_for_driver">No tu puedis eseguî cheste azion</string>
     <string name="add_user_restricted_while_driving">Impussibil zontâ il profîl intant che tu vuidis</string>
     <string name="default_search_query">Cîr</string>
     <string name="assistant_and_voice_setting_title">Assistent e vôs</string>
@@ -822,6 +859,7 @@
     <string name="add_a_profile_button_text">Zonte un profîl</string>
     <string name="delete_this_profile_text">Elimine chest profîl</string>
     <string name="add_profile_text">Zonte profîl</string>
+    <string name="cannot_remove_driver_profile">Cumò, chest profîl al è jentrât come vuidadôr. Torne prove cuant che nol ven doprât come vuidadôr.</string>
     <string name="qc_display_brightness">Luminositât dal schermi</string>
     <string name="qc_bluetooth_off_devices_info">Par viodi i tiei dispositîfs, ative il Bluetooth</string>
     <string name="qc_bluetooth_on_no_devices_info">Par associâ un dispositîf, vierç lis impostazions dal Bluetooth</string>
diff --git a/overlay/packages/apps/Car/Settings/res/values-gd/strings.xml b/overlay/packages/apps/Car/Settings/res/values-gd/strings.xml
index 351067c..00f9ff1 100644
--- a/overlay/packages/apps/Car/Settings/res/values-gd/strings.xml
+++ b/overlay/packages/apps/Car/Settings/res/values-gd/strings.xml
@@ -141,7 +141,6 @@
     <string name="wifi_ap_2G">2.4 GHz</string>
     <string name="wifi_ap_5G">5.0 GHz</string>
     <string name="wifi_ap_band_select_one">Tagh bann no dhà airson WiFi hotspot:</string>
-    <string name="tether_settings_title_all">Hotspot ⁊ teadhrachadh</string>
     <string name="wifi_hotspot_auto_off_title">Cuir an hotspot dheth gu fèin-obrachail</string>
     <string name="wifi_hotspot_auto_off_summary">Thèid an WiFi hotspot a chur dheth gu fèin-obrachail mur eil uidheam ceangailte ris</string>
     <string name="wifi_ask_enable">Tha <xliff:g id="requester" example="FancyApp">%s</xliff:g> airson WiFi a chur air</string>
diff --git a/overlay/packages/apps/Car/SystemUI/res/values-cy/strings.xml b/overlay/packages/apps/Car/SystemUI/res/values-cy/strings.xml
index 5dee749..58fde4c 100644
--- a/overlay/packages/apps/Car/SystemUI/res/values-cy/strings.xml
+++ b/overlay/packages/apps/Car/SystemUI/res/values-cy/strings.xml
@@ -19,6 +19,7 @@
     <string name="hvac_max_text">Mwy.</string>
     <string name="fan_speed_off">I FFWRDD</string>
     <string name="hvac_temperature_off">I FFWRDD</string>
+    <string name="end_session">Diweddu sesiwn</string>
     <string name="profile_limit_reached_message">{count, plural,
        =1 {Gellir ond creu un proffil.}
         two {Gellir ond creu # broffil.}
@@ -26,9 +27,29 @@
         many {Gellir ond creu # phroffil.}
         other {Gellir ond creu # proffil.}
     }</string>
+    <string name="privacy_chip_off_content">Mae\u2019r <xliff:g id="sensor" example="Microphone">%1$s</xliff:g> i ffwrdd.</string>
+    <string name="privacy_chip_use_sensor">Defnyddio <xliff:g id="sensor" example="microphone">%1$s</xliff:g></string>
+    <string name="mic_privacy_chip_apps_using_mic_suffix">Mae <xliff:g id="app_list" example="Assistant &amp; Phone">%s</xliff:g> yn defnyddio\u2019r meicroffon</string>
     <string name="mic_privacy_chip_dialog_ok">Iawn</string>
+    <string name="camera_privacy_chip_apps_using_camera_suffix">Mae <xliff:g id="app_list" example="Assistant &amp; Phone">%s</xliff:g> yn defnyddio\u2019r camera</string>
+    <string name="camera_privacy_chip_on_toast">Camera ymlaen</string>
+    <string name="camera_privacy_chip_off_toast">Camera i ffwrdd</string>
     <string name="camera_privacy_chip_dialog_ok">Iawn</string>
+    <string name="sensor_privacy_start_use_camera_dialog_title">Troi camera cerbyd ymlaen?</string>
+    <string name="system_bar_home_label">Sgrin Gartref</string>
+    <string name="system_bar_phone_label">Ffôn</string>
+    <string name="system_bar_applications_label">Apiau</string>
+    <string name="system_bar_climate_control_label">Rheoli Hinsawdd</string>
+    <string name="system_bar_notifications_label">Hysbysiadau</string>
+    <string name="system_bar_maps_label">Mapiau</string>
+    <string name="system_bar_media_label">Cyfryngau</string>
+    <string name="hvac_decrease_button_label">Gostwng tymheredd</string>
+    <string name="hvac_increase_button_label">Codi tymheredd</string>
+    <string name="status_icon_bluetooth_off">Gosodiad Bluetooth: Bluetooth i ffwrdd</string>
+    <string name="status_icon_signal_wifi">Gosodiadau Signal: Wifi Ymlaen</string>
+    <string name="status_icon_display_status">Gosodiadau Dangosydd</string>
     <string name="activity_blocked_text">Ni ellir ddefnyddio\u2019r nodwedd hon tra\u2019n gyrru.</string>
     <string name="exit_button_close_application">Cau\'r ap</string>
     <string name="exit_button_go_back">Nôl</string>
+    <string name="back_btn">Nôl</string>
 </resources>
diff --git a/overlay/packages/apps/Car/SystemUI/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Car/SystemUI/res/values-fur-rIT/strings.xml
index b4ffeee..edd62ff 100644
--- a/overlay/packages/apps/Car/SystemUI/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/Car/SystemUI/res/values-fur-rIT/strings.xml
@@ -25,6 +25,8 @@
     <string name="end_session">Termine la session</string>
     <string name="car_new_user">Gnûf profîl</string>
     <string name="user_add_profile_title">"Zontâ un gnûf profîl?"</string>
+    <string name="user_add_user_message_setup">Dopo che tu âs zontât un gnûf profîl, il titolâr dal account al pues personalizâlu.</string>
+    <string name="user_add_user_message_update">Ducj i profîi a puedin instalâ un inzornam. di aplic., che dopo al sarà disponibil a ducj i profîi.</string>
     <string name="profile_limit_reached_title">Tocjât il limit di profîi</string>
     <string name="profile_limit_reached_message">        {count, plural,
             one {}=1    {Al è pussibil creâ dome un profîl.}
@@ -36,6 +38,7 @@
     <string name="privacy_chip_off_content"><xliff:g id="sensor" example="Microphone">%1$s</xliff:g> distudât.</string>
     <string name="privacy_chip_use_sensor">Dopre <xliff:g id="sensor" example="microphone">%1$s</xliff:g></string>
     <string name="privacy_chip_use_sensor_subtext">Pes aplicazions che a àn il permès</string>
+    <string name="privacy_chip_settings">Impostazions riservatece</string>
     <string name="privacy_chip_app_using_sensor_suffix"><xliff:g id="app" example="Assistant">%1$s</xliff:g> al sta doprant: <xliff:g id="sensor" example="microphone">%2$s</xliff:g></string>
     <string name="mic_privacy_chip_apps_using_mic_suffix">Microfon in ûs di <xliff:g id="app_list" example="Assistant &amp; Phone">%s</xliff:g></string>
     <string name="privacy_chip_app_recently_used_sensor_suffix"><xliff:g id="app" example="Assistant">%1$s</xliff:g> al à doprât di resint:<xliff:g id="sensor" example="microphone">%2$s</xliff:g></string>
@@ -61,6 +64,11 @@
     <string name="system_bar_notifications_label">Notifichis</string>
     <string name="system_bar_maps_label">Mapis</string>
     <string name="system_bar_media_label">Multimedia</string>
+    <string name="system_bar_control_center_label">Centri di control</string>
+    <string name="system_bar_assistant_label">Assistent</string>
+    <string name="system_bar_mic_privacy_chip">Chip riservatece mic</string>
+    <string name="system_bar_user_avatar">Avatar utent</string>
+    <string name="system_bar_user_name_text">Test non utent</string>
     <string name="hvac_decrease_button_label">Sbasse la temperadure</string>
     <string name="hvac_increase_button_label">Alce la temperadure</string>
     <string name="status_icon_bluetooth_disconnected">Impostazion Bluetooth: disconetût</string>
@@ -70,9 +78,14 @@
     <string name="status_icon_signal_wifi">Impostazions segnâl: Wifi atîf</string>
     <string name="status_icon_signal_hotspot">Impostazions segnâl: pont di acès atîf</string>
     <string name="status_icon_display_status">Impostazions schermi</string>
+    <string name="status_icon_drive_mode">Modalitât vuide</string>
     <string name="activity_blocked_text">No tu puedis doprâ cheste funzion intant che tu vuidis</string>
     <string name="exit_button_close_application">Siere la aplicazion</string>
     <string name="exit_button_go_back">Indaûr</string>
+    <string name="drive_mode_modes_comfort">Comoditât</string>
+    <string name="drive_mode_modes_eco">Economie</string>
+    <string name="drive_mode_modes_sport">Sport</string>
+    <string name="qc_drive_mode_active_subtitle">Ative</string>
     <string name="qc_footer_settings">Impostazions</string>
     <string name="qc_footer_bluetooth_settings">Impostazions Bluetooth</string>
     <string name="qc_footer_network_internet_settings">Impostazions di rêt e internet</string>
@@ -80,6 +93,33 @@
     <string name="qc_footer_network_sound_settings">Impostazions dal sun</string>
     <string name="qc_footer_profiles_accounts_settings">Impostazions dai profîi e dai accounts</string>
     <string name="lockpattern_does_not_support_rotary">La cumbinazion no supuarte l\'input rotatîf; dopre la tocjade</string>
+    <string name="display_input_lock_text">Il schermi al è blocât</string>
+    <string name="display_input_lock_started_text">Il schermi al è stât blocât</string>
+    <string name="display_input_lock_stopped_text">Il schermi al è cumò sblocât</string>
+    <string name="user_logout_title">Desideristu pardabon disconetiti?</string>
+    <string name="user_logout_message">Chest al sierarà dutis lis aplicazions viertis</string>
+    <string name="user_logout">Disconet</string>
     <string name="car_guest">Ospit</string>
+    <string name="user_switching_message">Cambi di profîl\u2026</string>
+    <string name="user_adding_message">Daûr a zontâ un gnûf profîl\u2026</string>
+    <string name="max_user_limit_reached_message">Tu puedi zontâfin a <xliff:g id="user_limit" example="10">%d</xliff:g> profîi</string>
     <string name="confirm_add_user_title">Zontâ un gnûf profîl?</string>
+    <string name="already_logged_in_message">Par continuâ, <xliff:g id="user_name" example="Peter">%1$s</xliff:g> al/e varès di lâ fûr de schermade dal <xliff:g id="seat_location" example="Driver">%2$s</xliff:g></string>
+    <string name="header_bar_text_in_logged_out_state">Selezione il profîl par scomençâ</string>
+    <string name="logged_in_text">Jentrât</string>
+    <string name="prefix_logged_in_info_for_other_seat">Jentrâts su la schermade <xliff:g id="seat_location" example="Driver">%s</xliff:g></string>
+    <string name="create_user_failed_message">Impussibil zontâ un gnûf profîl. Torne prove plui indevant.</string>
+    <string name="guest_creation_failed_message">Impussibil inviâ il profîl Ospit. Torne prove plui indevant.</string>
+    <string name="stopping_user_text">Daûr a disconetisi…</string>
+    <string name="wait_for_until_stopped_message"><xliff:g id="user_name" example="Peter">%s</xliff:g> al è daûr a disconetisi. Torne prove plui indevant.</string>
+    <string name="seat_driver">vuidadôr</string>
+    <string name="seat_front">anteriôr</string>
+    <string name="seat_rear">posteriôr</string>
+    <string name="seat_left_side">çampe</string>
+    <string name="seat_center_side">mieç</string>
+    <string name="seat_right_side">diestre</string>
+    <string name="car_keyguard_enter_your_pin">Inserìs il to PIN</string>
+    <string name="car_keyguard_enter_your_pattern">Inserìs la tô cumbinazion</string>
+    <string name="car_keyguard_enter_your_password">Inserìs la tô password</string>
+    <string name="back_btn">Indaûr</string>
 </resources>
diff --git a/overlay/packages/apps/Car/SystemUpdater/res/values-ast-rES/strings.xml b/overlay/packages/apps/Car/SystemUpdater/res/values-ast-rES/strings.xml
deleted file mode 100644
index 89f42aa..0000000
--- a/overlay/packages/apps/Car/SystemUpdater/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  Copyright (c) 2016, The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
--->
-<resources>
-    <string name="cannot_access_storage">Nun se pue acceder al preséu d\'almacenamientu</string>
-    <string name="install_now">Instalar agora</string>
-    <string name="update_failed">L\'anovamientu falló</string>
-    <string name="verify_in_progress">Verificando l\'anovamientu…</string>
-    <string name="verify_failure">Seleiciona un ficheru d\'anovamientu válidu.</string>
-    <string name="install_ready">L\'anovamientu yá se pue instalar.</string>
-    <string name="install_in_progress">Instalación en cursu…</string>
-    <string name="volumes">Volúmenes (%d)</string>
-    <string name="path">Camín: %s</string>
-</resources>
diff --git a/overlay/packages/apps/CellBroadcastReceiver/res/values-ast-rES/strings.xml b/overlay/packages/apps/CellBroadcastReceiver/res/values-ast-rES/strings.xml
index ff5e9a2..5a1da51 100644
--- a/overlay/packages/apps/CellBroadcastReceiver/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/CellBroadcastReceiver/res/values-ast-rES/strings.xml
@@ -15,32 +15,12 @@
 -->
 <resources xmlns:android="http://schemas.android.com/apk/res/android" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="sms_cb_sender_name_public_safety">Avisu informativu</string>
-    <string name="button_dismiss">D\'acuerdu</string>
     <string name="menu_preferences">Axustes</string>
     <string name="notification_channel_emergency_alerts_high_priority">Alertes d\'emerxencia ensin reconocencia</string>
-    <string name="notification_channel_broadcast_messages_in_voicecall">Alertes d\'emerxencia nes llamaes de voz</string>
     <string name="notification_channel_settings_updates">Cambeos de los axustes de les alertes d\'emerxencia ensin filos automátiques según la SIM</string>
     <string name="enable_full_screen_public_safety_messages_title">Amosar los mensaxes a pantalla completa</string>
     <string name="enable_exercise_test_alerts_title">@string/cmas_exercise_alert</string>
     <string name="enable_operator_defined_test_alerts_title">@string/cmas_operator_defined_alert</string>
-    <string-array name="alert_reminder_interval_entries">
-        <item>Once</item>
-        <item>Every 2 minutes</item>
-        <item>Every 5 minutes</item>
-        <item>Every 15 minutes</item>
-        <item>Enxamás</item>
-    </string-array>
-    <string name="enable_cmas_presidential_alerts_title">Alertes presidenciales</string>
-    <string name="enable_cmas_presidential_alerts_summary">El presidente emite los mensaxes d\'alvertencia nacionales. Nun se puen desactivar.</string>
-    <string name="show_all_messages">Amosar tolos mensaxes</string>
-    <string name="message_identifier">Identificador:</string>
-    <string name="message_serial_number">Númberu de serie:</string>
-    <string name="data_coding_scheme">Esquema de la codificación de datos:</string>
-    <string name="message_content">Conteníu del mensaxe:</string>
-    <string name="message_coordinates">Coordenaes:</string>
-    <string name="maximum_waiting_time">Tiempu d\'espera máximu:</string>
-    <string name="seconds">segundos</string>
-    <string name="message_copied">Copióse\'l mensaxe</string>
     <string name="notification_cb_settings_changed_title">La operadora camudó los axustes</string>
     <string name="notification_cb_settings_changed_text">Toca equí pa ver los axustes de les alertes d\'emerxencia ensin filos</string>
 </resources>
diff --git a/overlay/packages/apps/CertInstaller/res/values-ast-rES/strings.xml b/overlay/packages/apps/CertInstaller/res/values-ast-rES/strings.xml
deleted file mode 100644
index fb281e1..0000000
--- a/overlay/packages/apps/CertInstaller/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2009 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="redirect_ca_certificate_close_button">Zarrar</string>
-    <string name="invalid_certificate_title">Nun se pue usar esti ficheru</string>
-    <string name="invalid_certificate_close_button">Zarrar</string>
-    <string name="certificate">Certificáu</string>
-    <string name="cert_temp_error">Hebo un fallu temporal. Volvi tentalo dempués.</string>
-</resources>
diff --git a/overlay/packages/apps/Contacts/res/values-ast-rES/strings.xml b/overlay/packages/apps/Contacts/res/values-ast-rES/strings.xml
index 95aec63..4fc8b0c 100644
--- a/overlay/packages/apps/Contacts/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/Contacts/res/values-ast-rES/strings.xml
@@ -25,5 +25,5 @@
          <xliff:g id="title" example="Developer">%3$s</xliff:g>
     </string>
     <string name="ghostData_department">Departamentu</string>
-    <string name="contacts_default_notification_channel">Avisos</string>
+    <string name="sdn_contacts_directory_search_label">Númberos de serviciu de la operadora</string>
 </resources>
diff --git a/overlay/packages/apps/DeskClock/res/values-ast-rES/strings.xml b/overlay/packages/apps/DeskClock/res/values-ast-rES/strings.xml
index ebae0c0..6237b17 100644
--- a/overlay/packages/apps/DeskClock/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/DeskClock/res/values-ast-rES/strings.xml
@@ -15,71 +15,11 @@
   limitations under the License.
   -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2" xmlns:tools="http://schemas.android.com/tools">
-    <string name="timer_sound">Soníu del temporizador</string>
-    <string name="alarm_missed_text"><xliff:g id="alarm_time">%1$s</xliff:g> - <xliff:g id="alarm_label">%2$s</xliff:g></string>
-    <string name="day_concat">", "</string>
-    <string name="loading_widget">Cargando\u2026</string>
-    <string-array name="crescendo_entries">
-        <item>Off</item>
-        <item>5 segundos</item>
-        <item>10 segundos</item>
-        <item>15 segundos</item>
-        <item>20 segundos</item>
-        <item>25 segundos</item>
-        <item>30 segundos</item>
-        <item>35 segundos</item>
-        <item>40 segundos</item>
-        <item>45 segundos</item>
-        <item>50 segundos</item>
-        <item>55 segundos</item>
-        <item>60 segundos</item>
-    </string-array>
-    <string-array name="snooze_duration_entries">
-        <item>1 minutu</item>
-        <item>2 minutos</item>
-        <item>3 minutos</item>
-        <item>4 minutos</item>
-        <item>5 minutos</item>
-        <item>6 minutos</item>
-        <item>7 minutos</item>
-        <item>8 minutos</item>
-        <item>9 minutos</item>
-        <item>10 minutos</item>
-        <item>11 minutos</item>
-        <item>12 minutos</item>
-        <item>13 minutos</item>
-        <item>14 minutos</item>
-        <item>15 minutos</item>
-        <item>16 minutos</item>
-        <item>17 minutos</item>
-        <item>18 minutos</item>
-        <item>19 minutos</item>
-        <item>20 minutos</item>
-        <item>21 minutos</item>
-        <item>22 minutos</item>
-        <item>23 minutes</item>
-        <item>24 minutos</item>
-        <item>25 minutos</item>
-        <item>26 minutes</item>
-        <item>27 minutes</item>
-        <item>28 minutes</item>
-        <item>29 minutes</item>
-        <item>30 minutos</item>
-    </string-array>
-    <string-array name="week_start_entries">
-        <item>Sábadu</item>
-        <item>Domingu</item>
-        <item>Llunes</item>
-    </string-array>
-    <string name="button_cities">Ciudaes</string>
-    <string name="menu_item_settings">Axustes</string>
-    <string name="hours_minutes_seconds"><xliff:g id="hours" example="2">%1$d</xliff:g>:<xliff:g id="minutes" example="3">%2$02d</xliff:g>:<xliff:g id="seconds" example="44">%3$02d</xliff:g></string>
-    <string name="minutes_seconds"><xliff:g id="minutes" example="3">%1$d</xliff:g>:<xliff:g id="seconds" example="44">%2$02d</xliff:g></string>
     <string-array name="sw_share_strings" translatable="true">
-        <item>Naide cuerre más que tu.</item>
-        <item>Esfruta de los frutos del to trabayu.</item>
+        <item>You\'re quite the speed demon.</item>
+        <item>Enjoy the fruits of your labor.</item>
         <item>Sábese que los Androides son rápidos, ¡mas non tanto como tu!</item>
-        <item>¡Uf!</item>
+        <item>Phew.</item>
         <item>713|\/||*05 1337.</item>
         <item>¡Qué velocidá más prodixosa!</item>
         <item>Vamos volver saltar nel tiempu.</item>
@@ -87,97 +27,4 @@
         <item>Cuerres más que la lluz.</item>
         <item>Velocidá fotónica.</item>
     </string-array>
-    <string name="cities_activity_title">Ciudaes</string>
-    <string name="clock_settings">Reló</string>
-    <string name="clock_style">Estilu</string>
-    <string-array name="timezone_labels" tools:ignore="Typos">
-        <item>"Marshall Islands"</item>
-        <item>"Midway Island"</item>
-        <item>"Hawaii"</item>
-        <item>"Alaska"</item>
-        <item>"Pacific Time"</item>
-        <item>"Tijuana"</item>
-        <item>"Arizona"</item>
-        <item>"Chihuahua"</item>
-        <item>"Mountain Time"</item>
-        <item>"Central America"</item>
-        <item>"Central Time"</item>
-        <item>"Ciudá de Méxicu"</item>
-        <item>"Saskatchewan"</item>
-        <item>"Bogotá"</item>
-        <item>"Eastern Time"</item>
-        <item>"Venezuela"</item>
-        <item>"Atlantic Time (Barbados)"</item>
-        <item>"Atlantic Time (Canada)"</item>
-        <item>"Manaus"</item>
-        <item>"Santiago"</item>
-        <item>"Newfoundland"</item>
-        <item>"Brasilia"</item>
-        <item>"Buenos Aires"</item>
-        <item>"Groenlandia"</item>
-        <item>"Montevidéu"</item>
-        <item>"Mid-Atlantic"</item>
-        <item>"Azores"</item>
-        <item>"Cape Verde Islands"</item>
-        <item>"Casablanca"</item>
-        <item>"London, Dublin"</item>
-        <item>"Amsterdam, Berlin"</item>
-        <item>"Belgráu"</item>
-        <item>"Bruxeles"</item>
-        <item>"Sarayevu"</item>
-        <item>"Windhoek"</item>
-        <item>"W. Africa Time"</item>
-        <item>"Amman, Jordan"</item>
-        <item>"Athens, Istanbul"</item>
-        <item>"Beirut, Lebanon"</item>
-        <item>"Cairo"</item>
-        <item>"Ḥélsinki"</item>
-        <item>"Xerusalén"</item>
-        <item>"Minsk"</item>
-        <item>"Ḥarare"</item>
-        <item>"Bagdad"</item>
-        <item>"Moscú"</item>
-        <item>"Kuwait"</item>
-        <item>"Nairobi"</item>
-        <item>"Teḥrán"</item>
-        <item>"Bakú"</item>
-        <item>"Tblisi"</item>
-        <item>"Yereván"</item>
-        <item>"Dubai"</item>
-        <item>"Kabul"</item>
-        <item>"Islamabad, Karachi"</item>
-        <item>"Ural'sk"</item>
-        <item>"Yekaterinburg"</item>
-        <item>"Kolkata"</item>
-        <item>"Sri Lanka"</item>
-        <item>"Katmandú"</item>
-        <item>"Astaná"</item>
-        <item>"Yangon"</item>
-        <item>"Krasnoyarsk"</item>
-        <item>"Bangkok"</item>
-        <item>"Beixín"</item>
-        <item>"Ḥong Kong"</item>
-        <item>"Irkutsk"</item>
-        <item>"Kuala Lumpur"</item>
-        <item>"Perth"</item>
-        <item>"Taipéi"</item>
-        <item>"Seúl"</item>
-        <item>"Tokyo, Osaka"</item>
-        <item>"Yakutsk"</item>
-        <item>"Adelaide"</item>
-        <item>"Darwin"</item>
-        <item>"Brisbane"</item>
-        <item>"Hobart"</item>
-        <item>"Sydney, Canberra"</item>
-        <item>"Vladivostok"</item>
-        <item>"Guam"</item>
-        <item>"Magadan"</item>
-        <item>"Auckland"</item>
-        <item>"Fiji"</item>
-        <item>"Tonga"</item>
-        <item>"Xakarta"</item>
-    </string-array>
-    <string name="shortcut_new_alarm_short">Alarma nueva</string>
-    <string name="shortcut_start_stopwatch_long">Aniciar el cronómetru</string>
-    <string name="night_mode_title">Mou nocherniegu</string>
 </resources>
diff --git a/overlay/packages/apps/DeskClock/res/values-fur-rIT/strings.xml b/overlay/packages/apps/DeskClock/res/values-fur-rIT/strings.xml
index dbdbc9a..76f6ba4 100644
--- a/overlay/packages/apps/DeskClock/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/DeskClock/res/values-fur-rIT/strings.xml
@@ -63,14 +63,14 @@
     <string name="timer_remaining_single">al reste</string>
     <string name="timer_remaining_multiple">a restin</string>
     <string-array name="alarm_set">
-        <item>Svee metude a mancul di 1 minût di cumò.</item>
-        <item>Svee metude a <xliff:g id="DAYS" example="2 days">%1$s</xliff:g> di cumò.</item>
-        <item>Svee metude a <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g> di cumò.</item>
-        <item>Svee metude a <xliff:g id="DAYS" example="2 days">%1$s</xliff:g> e <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g> di cumò.</item>
-        <item>Svee metude a <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g> di cumò.</item>
-        <item>Svee metude a <xliff:g id="DAYS" example="2 days">%1$s</xliff:g> e <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g> di cumò.</item>
-        <item>Svee metude a <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g> e <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g> di cumò.</item>
-        <item>Svee metude a <xliff:g id="DAYS" example="2 days">%1$s</xliff:g>, <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g> e <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g> di cumò.</item>
+        <item>Svee ca di mancul di 1 minût.</item>
+        <item>Svee ca di <xliff:g id="DAYS" example="2 days">%1$s</xliff:g>.</item>
+        <item>Svee ca di <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g>.</item>
+        <item>Svee ca di <xliff:g id="DAYS" example="2 days">%1$s</xliff:g> e <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g>.</item>
+        <item>Svee ca di <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g>.</item>
+        <item>Svee ca di <xliff:g id="DAYS" example="2 days">%1$s</xliff:g> e <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g>.</item>
+        <item>Svee ca di <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g> e <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g>.</item>
+        <item>Svee ca di <xliff:g id="DAYS" example="2 days">%1$s</xliff:g>, <xliff:g id="HOURS" example="2 hours">%2$s</xliff:g> e <xliff:g id="MINUTES" example="2 minutes">%3$s</xliff:g>.</item>
     </string-array>
     <plurals name="days">
         <item quantity="one">1 dì</item>
diff --git a/overlay/packages/apps/DeskClock/res/values-sc-rIT/strings.xml b/overlay/packages/apps/DeskClock/res/values-sc-rIT/strings.xml
index 59ef2db..53f1e07 100644
--- a/overlay/packages/apps/DeskClock/res/values-sc-rIT/strings.xml
+++ b/overlay/packages/apps/DeskClock/res/values-sc-rIT/strings.xml
@@ -178,7 +178,7 @@
     <string name="timer_times_up">Tempus agabbadu</string>
     <string name="timer_notification_label">Contadore de tempus</string>
     <string-array name="sw_share_strings" translatable="true">
-        <item>Nemos tenet sa lestresa tua. </item>
+        <item>Nemos tenet sa lestresa tua.</item>
         <item>Gosa·ti sa bravesa chi as tentu.</item>
         <item>Is Andròides sunt connotos pro èssere lestros, ma non che a tue!</item>
         <item>Uff.</item>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/app/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/app/res/values-ast-rES/strings.xml
deleted file mode 100644
index 55c750c..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/app/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2012 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:tools="http://schemas.android.com/tools" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="accessibility_settings_title">Accesibilidá</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/assisteddialing/ui/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/assisteddialing/ui/res/values-ast-rES/strings.xml
deleted file mode 100644
index 4474c4c..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/assisteddialing/ui/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="assisted_dialing_setting_cc_default_summary">Detectóse automáticamente • <xliff:g example="United Kingdom (+44)" id="ad_country_code_info">%1$s</xliff:g></string>
-  <string name="assisted_dialing_setting_cc_default_summary_fallback">Detectóse automáticamente</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/blockreportspam/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/blockreportspam/res/values-ast-rES/strings.xml
deleted file mode 100644
index 1201e4a..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/blockreportspam/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2016 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="block_number_confirmation_message_new_filtering">    Yá nun vas recibir llamaes o mensaxes d\'esti númberu.</string>
-  <string name="block_number_ok">BLOQUIAR</string>
-  <string name="unblock_number_ok">DESBLOQUIAR</string>
-  <string name="block_report_number_alert_title">¿Quies bloquiar al «<xliff:g id="number">%1$s</xliff:g>»?</string>
-  <string name="block_report_number_alert_details">Yá nun vas recibir llamaes d\'esti númberu.</string>
-  <string name="unblock_report_number_alert_title">¿Quies desbloquiar al «<xliff:g id="number">%1$s</xliff:g>»?</string>
-  <string name="report_not_spam_alert_button">Informar</string>
-  <string name="report_not_spam_alert_title">¿Quies informar d\'un fallu?</string>
-  <string name="block_number_failed_toast">Hebo un problema al bloquiar esti númberu</string>
-  <string name="unblock_number_failed_toast">Hebo un problema al desbloquiar esti númberu</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/calldetails/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/calldetails/res/values-ast-rES/strings.xml
deleted file mode 100644
index 35a8367..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/calldetails/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="rtt_transcript_link">Ver la trescripción</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/calllog/ui/menu/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/calllog/ui/menu/res/values-ast-rES/strings.xml
deleted file mode 100644
index a6a55ec..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/calllog/ui/menu/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="delete">Desaniciar</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/clipboard/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/clipboard/res/values-ast-rES/strings.xml
deleted file mode 100644
index 379750f..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/clipboard/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="toast_text_copied">Copióse\'l testu</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/common/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/common/res/values-ast-rES/strings.xml
deleted file mode 100644
index 6334672..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/common/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="ok_got_it">D\'acuerdu</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/contacts/resources/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/contacts/resources/res/values-ast-rES/strings.xml
deleted file mode 100644
index 03a9a24..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/contacts/resources/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2012 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="nameLabelsGroup">Nome</string>
-    <string name="nicknameLabelsGroup">Nomatu</string>
-    <string name="full_name">Nome</string>
-    <string name="organizationLabelsGroup">Organización</string>
-    <string name="relationLabelsGroup">Rellación</string>
-    <string name="websiteLabelsGroup">Sitiu web</string>
-    <string name="postal_street">Cai</string>
-    <string name="postal_city">Ciudá</string>
-    <string name="postal_region">Estáu</string>
-    <string name="postal_country">País</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/historyitemactions/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/historyitemactions/res/values-ast-rES/strings.xml
deleted file mode 100644
index 659062f..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/historyitemactions/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="voice_call">Llamar</string>
-  <string name="video_call">Videollamar</string>
-  <string name="add_to_contacts">Amestar un contautu</string>
-  <string name="send_a_message">Unviar un mensaxe</string>
-  <string name="block_number">Bloquiar</string>
-  <string name="unblock_number">Desbloquiar</string>
-  <string name="copy_number">Copiar el númberu</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/main/impl/toolbar/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/main/impl/toolbar/res/values-ast-rES/strings.xml
deleted file mode 100644
index ab2ca2e..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/main/impl/toolbar/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2018 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string msgid="2295659037509008453" name="action_menu_overflow_description">Más opciones</string>
-  <string name="settings">Axustes</string>
-  <string name="main_remove_contact">Quitar</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/preferredsim/impl/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/preferredsim/impl/res/values-ast-rES/strings.xml
deleted file mode 100644
index 9bcea5b..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/preferredsim/impl/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="pre_call_select_phone_account_hint_other_sim_in_use">Nun ta disponible mentanto s\'usa «<xliff:g example="SIM 1" id="other_sim">%1$s</xliff:g>»</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/searchfragment/cp2/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/searchfragment/cp2/res/values-ast-rES/strings.xml
deleted file mode 100644
index ac8b19c..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/searchfragment/cp2/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="all_contacts">Tolos contautos</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/spannable/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/spannable/res/values-ast-rES/strings.xml
deleted file mode 100644
index 508694c..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/spannable/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2018 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="general_learn_more">Saber\u00A0más</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/theme/common/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/theme/common/res/values-ast-rES/strings.xml
deleted file mode 100644
index 323c92c..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/theme/common/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2016 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="unknown">Númberu desconocíu</string>
-  <string name="unknown_counter">    <xliff:g id="unknown">%1$s</xliff:g> <xliff:g id="id">%2$d</xliff:g>
-  </string>
-  <string name="payphone">Teléfonu públicu</string>
-  <string name="emergency_number">Númberu d\'emerxencia</string>
-  <string name="call_subject_type_and_number">    <xliff:g example="Mobile" id="type">%1$s</xliff:g> <xliff:g example="(650) 555-1212" id="number">%2$s</xliff:g>
-  </string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/voicemail/listui/error/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/voicemail/listui/error/res/values-ast-rES/strings.xml
deleted file mode 100644
index cda962c..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/voicemail/listui/error/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2016 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="voicemail_action_turn_off_airplane_mode">Axustes del mou avión</string>
-  <string name="voicemail_action_dimiss">Non, gracies</string>
-  <string name="vvm3_error_vms_dns_failure_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_vmg_dns_failure_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_spg_dns_failure_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_vms_timeout_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_vmg_timeout_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_status_sms_timeout_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_invalid_password_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_service_not_provisioned_title">Buzón de voz visual</string>
-  <string name="vvm3_error_service_not_activated_title">Buzón de voz visual</string>
-  <string name="vvm3_error_user_blocked_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_imap_getquota_error_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_imap_select_error_title">Asocedió daqué malo</string>
-  <string name="vvm3_error_imap_error_title">Asocedió daqué malo</string>
-  <string name="dialer_terms_and_conditions_message"><xliff:g>%s</xliff:g></string>
-  <string name="dialer_terms_and_conditions_learn_more">Saber más</string>
-  <string name="dialer_terms_and_conditions_existing_user_ack">D\'acuerdu</string>
-  <string name="dialer_terms_and_conditions_existing_user_decline">Non, gracies</string>
-  <string name="verizon_terms_and_conditions_decline_dialog_downgrade">Desactivar</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/dialer/voicemail/settings/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/dialer/voicemail/settings/res/values-ast-rES/strings.xml
deleted file mode 100644
index 327f375..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/dialer/voicemail/settings/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2017 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="voicemail_notifications_preference_title">Avisos</string>
-  <string name="save_button_text">Guardar</string>
-  <string name="redo_button_text">Retentar</string>
-  <string name="voicemail_advanced_settings_title">Axustes avanzaos</string>
-  <string name="vm_change_pin_progress_message">Espera.</string>
-  <string name="change_pin_continue_label">Siguir</string>
-  <string name="change_pin_confirm_pins_dont_match">Los PIN nun concasen</string>
-  <string name="confirm_disable_voicemail_accept_dialog_label">DESACTIVAR</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/incallui/rtt/impl/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/incallui/rtt/impl/res/values-ast-rES/strings.xml
deleted file mode 100644
index f21aa18..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/incallui/rtt/impl/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2018 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="content_description_rtt_chat_avatar">Avatar</string>
-  <string name="rtt_button_back">Atrás</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/incallui/spam/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/incallui/spam/res/values-ast-rES/strings.xml
deleted file mode 100644
index dce8645..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/incallui/spam/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="spam_notification_was_not_spam_action_text">Non, nun ye spam</string>
-  <string name="spam_notification_block_spam_action_text">Sí, bloquiar el númberu</string>
-  <string name="spam_notification_action_dismiss">Escartar</string>
-</resources>
diff --git a/overlay/packages/apps/Dialer/java/com/android/incallui/theme/res/values-ast-rES/strings.xml b/overlay/packages/apps/Dialer/java/com/android/incallui/theme/res/values-ast-rES/strings.xml
deleted file mode 100644
index d23f58d..0000000
--- a/overlay/packages/apps/Dialer/java/com/android/incallui/theme/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2018 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <string name="phoneAppLabel" product="default">Teléfonu</string>
-</resources>
diff --git a/overlay/packages/apps/DocumentsUI/res/values-ast-rES/strings.xml b/overlay/packages/apps/DocumentsUI/res/values-ast-rES/strings.xml
index f9e1934..7ced670 100644
--- a/overlay/packages/apps/DocumentsUI/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/DocumentsUI/res/values-ast-rES/strings.xml
@@ -16,22 +16,8 @@
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="missing_rename_error">Tienes de renomar esti elementu</string>
     <string name="add_folder_name_error">Tienes d\'amestar un nome</string>
-    <string name="button_back">Atrás</string>
-    <string name="cant_save_to_work_error_title">Nun se pue guardar nel perfil llaboral</string>
-    <string name="cant_save_to_personal_error_title">Nun se pue guardar nel perfil personal</string>
-    <string name="root_info_header_recent">Ficheros de recién</string>
-    <string name="root_info_header_downloads">Ficheros en Descargues</string>
-    <string name="root_info_header_folder">Ficheros en: <xliff:g id="folder" example="DCIM">%1$s</xliff:g></string>
-    <string name="root_info_header_image_recent">Imáxenes de recién</string>
-    <string name="root_info_header_image_downloads">Imáxenes en Descargues</string>
-    <string name="root_info_header_image_folder">Imáxenes en: <xliff:g id="folder" example="DCIM">%1$s</xliff:g></string>
-    <string name="chip_title_large_files">Ficheros grandes</string>
-    <string name="chip_title_from_this_week">Esta selmana</string>
-    <string name="open_tree_button">Usar esta carpeta</string>
-    <string name="directory_blocked_header_subtitle">Pa protexer la to privacidá, escueyi otra carpeta</string>
-    <string name="create_new_folder_button">Crear una carpeta</string>
-    <string name="personal_tab">Personal</string>
-    <string name="work_tab">Llaboral</string>
+    <string name="quiet_mode_error_title">Les aplicaciones llaborales tán en posa</string>
+    <string name="quiet_mode_button">Activar les aplicaciones llaborales</string>
     <string name="grid_mode_showing">Amosando\'l mou de rexáu</string>
     <string name="list_mode_showing">Amosando\'l mou de llista</string>
 </resources>
diff --git a/overlay/packages/apps/DocumentsUI/res/values-fur-rIT/strings.xml b/overlay/packages/apps/DocumentsUI/res/values-fur-rIT/strings.xml
index 4ede448..4307b86 100644
--- a/overlay/packages/apps/DocumentsUI/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/DocumentsUI/res/values-fur-rIT/strings.xml
@@ -39,6 +39,7 @@
     <string name="menu_sort">Ordene par...</string>
     <string name="menu_copy">Copie su\u2026</string>
     <string name="menu_move">Sposte su\u2026</string>
+    <string name="menu_compress">Comprim</string>
     <string name="menu_extract">Tire fûr su\u2026</string>
     <string name="menu_rename">Cambie non</string>
     <string name="menu_inspect">Oten informazions</string>
diff --git a/overlay/packages/apps/EmergencyInfo/res/values-ast-rES/strings.xml b/overlay/packages/apps/EmergencyInfo/res/values-ast-rES/strings.xml
deleted file mode 100644
index 7f679cb..0000000
--- a/overlay/packages/apps/EmergencyInfo/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="ok">D\'acuerdu</string>
-</resources>
diff --git a/overlay/packages/apps/ExactCalculator/res/values-ast-rES/strings.xml b/overlay/packages/apps/ExactCalculator/res/values-ast-rES/strings.xml
new file mode 100644
index 0000000..3ed7afa
--- /dev/null
+++ b/overlay/packages/apps/ExactCalculator/res/values-ast-rES/strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Copyright (C) 2015 The Android Open Source Project
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  -->
+<resources>
+    <string name="desc_paren">paréntesis</string>
+</resources>
diff --git a/overlay/packages/apps/ExactCalculator/res/values-fur-rIT/strings.xml b/overlay/packages/apps/ExactCalculator/res/values-fur-rIT/strings.xml
index 1aebc07..0690a4b 100644
--- a/overlay/packages/apps/ExactCalculator/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/ExactCalculator/res/values-fur-rIT/strings.xml
@@ -23,6 +23,7 @@
     <string name="desc_const_e">numar di Euler</string>
     <string name="desc_const_pi">pi grêc</string>
     <string name="desc_dec_point">pont, virgule</string>
+    <string name="desc_paren">parentesi</string>
     <string name="desc_lparen">parentesi vierte</string>
     <string name="desc_rparen">parentesi sierade</string>
     <string name="desc_fun_cos">cosen</string>
diff --git a/overlay/packages/apps/HTMLViewer/res/values-ast-rES/strings.xml b/overlay/packages/apps/HTMLViewer/res/values-ast-rES/strings.xml
deleted file mode 100644
index f76d505..0000000
--- a/overlay/packages/apps/HTMLViewer/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="app_label">Visor de HTML</string>
-    <string name="cannot_open_link">Nun hai nenguna aplicación que pueda abrir esti enllaz.</string>
-</resources>
diff --git a/overlay/packages/apps/ManagedProvisioning/res/values-ast-rES/strings.xml b/overlay/packages/apps/ManagedProvisioning/res/values-ast-rES/strings.xml
index fd45f64..64b02e9 100644
--- a/overlay/packages/apps/ManagedProvisioning/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/ManagedProvisioning/res/values-ast-rES/strings.xml
@@ -18,7 +18,6 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
   <string name="navigation_button_description">Desplazase p\'arriba</string>
-  <string name="something_went_wrong">Asocedió daqué malo</string>
   <string name="account_management_disclaimer_header">La cuenta ta xestionada</string>
   <string name="fully_managed_device_provisioning_permissions_header">L\'actividá y los datos de to</string>
   <string name="fully_managed_device_provisioning_permissions_secondary_header">Permisos d\'aplicaciones</string>
@@ -26,5 +25,4 @@
   <string name="fully_managed_device_provisioning_return_device_subheader">Volvi a la pantalla anterior o reanicia esti preséu y devólvilu al alministrador de TI.</string>
   <string name="fully_managed_device_cancel_setup_button">Encaboxar la configuración</string>
   <string name="fully_managed_device_reset_and_return_button">Reafitar y devolver el preséu</string>
-  <string name="just_a_sec">Un segundín\u2026</string>
 </resources>
diff --git a/overlay/packages/apps/ManagedProvisioning/res/values-fur-rIT/strings.xml b/overlay/packages/apps/ManagedProvisioning/res/values-fur-rIT/strings.xml
index 0629229..bc5d20e 100644
--- a/overlay/packages/apps/ManagedProvisioning/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/ManagedProvisioning/res/values-fur-rIT/strings.xml
@@ -27,6 +27,7 @@
   <string name="next">Indenant</string>
   <string name="setting_up_workspace">Daûr a configurâ il profîl di lavôr\u2026</string>
   <string name="admin_has_ability_to_monitor_profile">Il to aministradôr di IT al pues monitorâ e gjestî lis impostazions, l\'acès aziendâl, lis aplicazions, i dâts e la ativitât in rêt associâts a chest profîl e ancjemò la tô cronologjie des clamadis e la cronologjie di ricercje dai contats. Contate il to aministradôr di IT par vê plui informazions in merit aes politichis su la riservatece de tô organizazion.</string>
+  <string name="admin_has_ability_to_monitor_device">Il to aministradôr di IT al à la pussibilitât di monitorâ e gjestî lis impostazions, l\'acès aziendâl, lis aplicazions, i permès e i dâts associâts a chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>, includude la ativitât in rêt e la posizion dal dispositîf, la cronologjie des clamadis e de ricercje dai contats.<xliff:g id="line_break">\n\n</xliff:g>Contate il to aministradôr di IT par vê plui informazions, includudis lis politichis su la riservatece de organizazion.</string>
   <string name="theft_protection_disabled_warning">Par doprâ lis funzionalitâts di protezion de robarie, tu scugnis vê un bloc dal schermi protet di password pal to dispositîf.</string>
   <string name="contact_your_admin_for_more_info">Contate il to aministradôr IT par vê plui informazions, includudis lis politichis su la riservatece de tô organizazion.</string>
   <string name="learn_more_link">Plui informazions </string>
@@ -45,6 +46,8 @@
   <string name="sure_you_want_to_delete_profile">Se tu continuis, dutis lis aplicazions e i dâts in chest profîl a vignaran eliminâts.</string>
   <string name="delete_profile">Elimine</string>
   <string name="cancel_delete_profile">Anule</string>
+  <string name="encrypt_device_text_for_profile_owner_setup">Par confgurâ il to profîl di lavôr, il to dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> al à bisugne di jessi cifrât. Cheste operazion e podarès tirâle a dilunc.</string>
+  <string name="encrypt_device_text_for_device_owner_setup">Par configurâ chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>, al à prime di sei cifrât. Cheste operazion e podarès tirâle a dilunc.</string>
   <string name="encrypt_this_device_question">Cifrâ chest dispositîf?</string>
   <string name="encrypt">Cifre</string>
   <string name="continue_provisioning_notify_title">Criptazion completade</string>
@@ -52,6 +55,7 @@
   <string name="managed_provisioning_error_text">Nol è stât pussibil configurâ il to profîl di lavôr. Contate il dipartiment IT o torne prove plui tart.</string>
   <string name="cant_add_work_profile">Impussibil zontâ il profîl di lavôr</string>
   <string name="cant_replace_or_remove_work_profile">Impussibil sostituî o gjavâ il profîl di lavôr</string>
+  <string name="work_profile_cant_be_added_contact_admin">Nol è pussibil zontâ un profîl di lavôr su chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>. Se tu âs domandis, contate l\'aministradôr IT.</string>
   <string name="change_device_launcher">Cambie l\'inviadôr dal dispositîf</string>
   <string name="launcher_app_cant_be_used_by_work_profile">Il to profîl di lavôr nol pues doprâ cheste aplicazion di inviament </string>
   <string name="cancel_provisioning">Anule</string>
@@ -59,6 +63,9 @@
   <string name="user_setup_incomplete">Configurazion utent incomplete</string>
   <string name="default_owned_device_username">Utent dal dispositîf di lavôr</string>
   <string name="setup_work_device">Daûr a configurâ il dispositîf di lavôr\u2026</string>
+  <string name="device_doesnt_allow_encryption_contact_admin">Chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> nol permet la criptazion, che e covente pe configurazion. Pal jutori, contate il to aministradôr di IT.</string>
+  <string name="stop_setup_reset_device_question">Interompi la configurazion e ripristinâ <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>?</string>
+  <string name="this_will_reset_take_back_first_screen">Cheste operazion e ripristinarà il to dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> e ti puartarà indaûr ae prime schermade</string>
   <string name="device_owner_cancel_message">Fermâ di configurâ e scancelâ i dâts dal to dispositîf?</string>
   <string name="device_owner_cancel_cancel">Anule</string>
   <string name="device_owner_error_ok">Va ben</string>
@@ -68,7 +75,10 @@
   <string name="something_went_wrong">Alc al è lât strucj</string>
   <string name="couldnt_set_up_device">Nol è stât pussibil configurâ il dispositîf. Pal jutori, contate il to aministradôr di IT.</string>
   <string name="contact_your_admin_for_help">Contate il to aministradôr di IT par vê jutori</string>
+  <string name="reset_device">Ripristine chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> e prove a configurâlu di gnûf</string>
+  <string name="device_already_set_up">Il dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> al è za configurât</string>
   <string name="error_wifi">Nol è stât pussibil conetisi al Wi-Fi</string>
+  <string name="device_has_reset_protection_contact_admin">Il to dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> al à la protezion di ripristinament ativade. Pal jutori, contate il to aministradôr di IT.</string>
   <string name="frp_clear_progress_title">Daûr a scancelâ</string>
   <string name="frp_clear_progress_text">Par plasê spiete...</string>
   <string name="error_hash_mismatch">Nol è stât pussibil doprâ la aplicazion di aministrazion par vie di un erôr di sume di control. Pal jutori, contate il to aministradôr di IT.</string>
@@ -114,6 +124,9 @@
   <string name="comp_profile_benefits_description">Doprant un profîl di lavôr, tu puedis tignî lis tôs aplicazions di lavôr intun puest</string>
   <string name="setup_profile_encryption">Configure il to profîl. Cifradure</string>
   <string name="setup_profile_progress">Configure il to profîl. Visualizazion avanzament</string>
+  <string name="setup_device">Configure il to dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g></string>
+  <string name="setup_device_encryption">Configure il to dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>. Cifradure</string>
+  <string name="setup_device_progress">Configure il to dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>. Visualizazion avanzament</string>
   <string name="learn_more_label">Boton par savê di plui</string>
   <string name="mdm_icon_label">Icone <xliff:g id="icon_label" example="Test App">%1$s</xliff:g></string>
   <string name="section_heading">Intestazion di sezion <xliff:g id="section_heading" example="Early Renaissance">%1$s</xliff:g>.</string>
@@ -141,6 +154,7 @@
   <string name="brand_screen_header">Chest dispositîf al aparten ae tô organizazion</string>
   <string name="brand_screen_subheader">Chestis aplicazions a vignaran dopradis par gjestî e monitorâ chest telefon</string>
   <string name="account_management_disclaimer_header">Il to account al è gjestît</string>
+  <string name="account_management_disclaimer_subheader">Il to aministradôr di IT al dopre la gjestion dai dispositîfs mobii par aplicâ lis politichis su la sigurece</string>
   <string name="downloading_administrator_header">Daûr a prontâ i preparatîfs pal lavôr\u2026</string>
   <string name="work_profile_provisioning_accept_header_post_suw">Configurìn il to profîl di lavôr</string>
   <string name="work_profile_provisioning_step_1_header">Lis aplicazions di lavôr a vignaran tignudis tal to profîl di lavôr</string>
@@ -150,18 +164,35 @@
   <string name="work_profile_provisioning_summary">Lis aplicazions di lavôr a vegnin tignudis tal to profîl di lavôr. Tu puedis meti in pause lis tôs aplicazions di lavôr se tu âs finît di lavorâ pe zornade. Il to aministradôr di IT al podarà viodi i dâts che a son tal to profîl di lavôr.</string>
   <string name="fully_managed_device_provisioning_accept_header">Configurìn il to dispositîf di lavôr</string>
   <string name="fully_managed_device_provisioning_step_1_header">Ten lis tôs aplicazions di lavôr a puartade di dêt</string>
+  <string name="fully_managed_device_provisioning_step_2_header">Chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> nol è privât</string>
+  <string name="fully_managed_device_provisioning_step_2_subheader">Il to aministradôr di IT al podarès rivâ a viodi i tiei dâts e lis ativitâts su chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>.</string>
   <string name="fully_managed_device_provisioning_permissions_header">Lis tôs ativitâts e i tiei dâts</string>
   <string name="fully_managed_device_provisioning_permissions_secondary_header">Permès de aplicazion</string>
+  <string name="fully_managed_device_provisioning_permissions_secondary_subheader">Il to aministradôr di IT al pues stabilî i permès pes aplicazions su chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>, come i permès dal microfon, de fotocjamare e de posizion.</string>
   <string name="fully_managed_device_provisioning_progress_label">Daûr a configurâ il to dispositîf\u2026</string>
+  <string name="fully_managed_device_provisioning_summary">Dopre chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> par acedi cun facilitât aes tôs aplicazions di lavôr. Chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> nol è privât, duncje il to aministradôr di IT al podarès rivâ a viodi i tiei dâts e la ativitât.</string>
+  <string name="fully_managed_device_with_permission_control_provisioning_summary">Dopre chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> par acedi cun facilitât aes tôs aplicazions di lavôr. Chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> nol è privât, duncje il to aministradôr di IT al podarès rivâ a viodi la tô ativitât e i tiei dâts. L\'aministradôr di IT al pues ancje stabilî i permès pes aplicazions su chest dispositîf, come i permès dal microfon, de fotocjamare e de posizion.</string>
   <string name="fully_managed_device_provisioning_return_device_title">Torne chest dispositîf al to aministradôr di IT</string>
   <string name="fully_managed_device_provisioning_return_device_subheader">Torne indaûr ae schermade precedente o ripristine chest dispositîf e tornilu al to aministradôr di IT.</string>
   <string name="fully_managed_device_cancel_setup_button">Anule configurazion</string>
   <string name="fully_managed_device_reset_and_return_button">Ripristine e restituìs il dispositîf</string>
+  <string name="fully_managed_device_unsupported_DPC_in_headless_mode_header">Impussibil configurâ il dispositîf</string>
+  <string name="fully_managed_device_unsupported_DPC_in_headless_mode_subheader">Impussibil regjistrâ chest dispositîf in modalitât gjestide ad implen. Ripristine il to dispositîf aes impostazions di fabriche e contate il to aministradôr di IT.</string>
+  <string name="fully_managed_device_reset_button">Ripristinament di fabriche</string>
   <string name="cope_provisioning_step_1_header">Lis aplicazions di lavôr a son tignudis tal to profîl di lavôr e a son gjestidis dal to aministradôr IT</string>
   <string name="cope_provisioning_step_2_header">Lis aplicazions personâls a son separadis e platadis da lis aplicazions di lavôr</string>
   <string name="cope_provisioning_step_3_header">Il to aministradôr di IT al pues controlâ chest dispositîf e blocâ ciertis aplicazions</string>
+  <string name="cope_provisioning_summary">Lis aplicazions di lavôr a son tignudis tal to profîl di lavôr e a son gjestidis dal to aministradôr di IT. Lis aplicazions personâls a son separadis e platadis da lis aplicazions di lavôr. Il to aministradôr di IT al pues controlâ chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> e blocâ ciertis aplicazions.</string>
   <string name="just_a_sec">Dome un secont\u2026</string>
   <string name="fully_managed_device_provisioning_privacy_title">Pro memoria di riservatece</string>
+  <string name="fully_managed_device_provisioning_privacy_body">Il to aministradôr di IT al podarès rivâ a viodi i tiei dâts e lis ativitâts su chest dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g></string>
+  <string name="financed_device_screen_header">Chest <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> al è furnît di <xliff:g id="creditor_name" example="creditor_name">%2$s</xliff:g></string>
+  <string name="financed_make_payments_subheader_title">Fâs i paiaments par chest <xliff:g id="device_name" example="Pixel">%1$s</xliff:g></string>
+  <string name="financed_make_payments_subheader_description"><xliff:g id="creditor_name" example="creditor_name">%1$s</xliff:g> al pues instalâ la aplicazion di <xliff:g id="creditor_name" example="creditor_name">%2$s</xliff:g> cussì che tu puedis fâ i paiaments par chest <xliff:g id="device_name" example="Pixel">%3$s</xliff:g>.</string>
+  <string name="financed_restrict_device_subheader_title">Chest <xliff:g id="device_name" example="Pixel">%1$s</xliff:g> al pues vignî limitât</string>
+  <string name="financed_restrict_device_subheader_description"><xliff:g id="creditor_name" example="creditor_name">%1$s</xliff:g> al pues limitâ l\'acès a chest <xliff:g id="device_name" example="Pixel">%2$s</xliff:g> se no tu fasis i paiaments.</string>
+  <string name="error_role_holder_hash_mismatch">Impussibil configurâ il dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>. Contate il to aministradôr di IT e riferìs \"Invalid checksum\" (sume di control no valide).</string>
   <string name="error_role_holder_download_install_failed">Prove plui indenant o domande aiût al to aministradôr di IT</string>
+  <string name="error_role_holder_package_invalid">Impussibil configurâ il dispositîf <xliff:g id="device_name" example="Pixel">%1$s</xliff:g>. Contate il to aministradôr di IT e riferìs \"Missing or corrupted components\" (a mancjin components o a son ruvinâts).</string>
   <string name="setting_up">Daûr a configurâ\u2026</string>
 </resources>
diff --git a/overlay/packages/apps/Messaging/res/values-ast-rES/arrays.xml b/overlay/packages/apps/Messaging/res/values-ast-rES/arrays.xml
deleted file mode 100644
index 795dedb..0000000
--- a/overlay/packages/apps/Messaging/res/values-ast-rES/arrays.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2015 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-         http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string-array name="notification_reply_choices">
-        <item>Yes</item>
-        <item>No</item>
-        <item>D\'acuerdu</item>
-        <item>Hehe</item>
-        <item>Thanks</item>
-        <item>I agree</item>
-        <item>Nice</item>
-        <item>On my way</item>
-        <item>OK, let me get back to you later</item>
-        <item>:)</item>
-        <item>:(</item>
-    </string-array>
-</resources>
diff --git a/overlay/packages/apps/Messaging/res/values-ast-rES/strings.xml b/overlay/packages/apps/Messaging/res/values-ast-rES/strings.xml
deleted file mode 100644
index 8c9e302..0000000
--- a/overlay/packages/apps/Messaging/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Copyright (C) 2015 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-         http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="posted_just_now">"Puramente agora"</string>
-    <string name="posted_now">"Agora"</string>
-    <string name="enumeration_comma">,\u0020</string>
-    <string name="notification_separator">\u0020\u0020</string>
-    <string name="notification_ticker_separator">:\u0020</string>
-    <string name="notification_space_separator">\u0020\u0020</string>
-    <string name="notification_picture">Semeya</string>
-    <string name="notification_audio">Clip d\'audiu</string>
-    <string name="notification_video">Videu</string>
-    <string name="unknown_self_participant">Yo</string>
-    <string name="mms_messaging_category_pref_title">MMS</string>
-    <string name="advanced_category_pref_title">Axustes avanzaos</string>
-    <string name="notifications_pref_title">Avisos</string>
-    <string name="wireless_alerts_title">Alertes ensin filos</string>
-    <string name="notifications_enabled_conversation_pref_title">Avisos</string>
-    <string name="requires_sms_permissions_close_button">D\'acuerdu</string>
-    <string name="conversation_list_item_view_sent_from_you_prefix">Tu:\u0020</string>
-    <string name="conversation_list_item_view_sent_from_other_prefix"><xliff:g id="firstNameOfSender">%s</xliff:g>:\u0020</string>
-    <string name="conversation_list_snippet_picture">Semeya</string>
-    <string name="conversation_list_snippet_audio_clip">Clip d\'audiu</string>
-    <string name="conversation_list_snippet_video">Videu</string>
-    <string name="mms_text">MMS</string>
-    <string name="content_description_for_number_zero">Cero</string>
-    <string name="content_description_for_number_one">Uno</string>
-    <string name="content_description_for_number_two">Dos</string>
-    <string name="content_description_for_number_three">Trés</string>
-    <string name="content_description_for_number_four">Cuatro</string>
-    <string name="content_description_for_number_five">Cinco</string>
-    <string name="content_description_for_number_six">Seis</string>
-    <string name="content_description_for_number_seven">Siete</string>
-    <string name="content_description_for_number_eight">Ocho</string>
-    <string name="content_description_for_number_nine">Nueve</string>
-    <string name="advanced_settings">Axustes avanzaos</string>
-    <string name="advanced_settings_activity_title">Axustes avanzaos</string>
-    <string name="link_display_format"><xliff:g id="text">%1$s</xliff:g> (<xliff:g id="url">%2$s</xliff:g>)</string>
-</resources>
diff --git a/overlay/packages/apps/Nfc/res/values-ast-rES/strings.xml b/overlay/packages/apps/Nfc/res/values-ast-rES/strings.xml
index 8599e2a..76d5f1a 100644
--- a/overlay/packages/apps/Nfc/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/Nfc/res/values-ast-rES/strings.xml
@@ -1,53 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name">Serviciu NFC</string>
-    <string name="nfcUserLabel">NFC</string>
-    <string name="accessibility_nfc_enabled">NFC habilitáu.</string>
-    <string name="tap_to_beam">Toca equí pa tresmitir</string>
-    <string name="beam_progress">Tresmisión entrante…</string>
-    <string name="beam_outgoing">Tresmitiendo…</string>
-    <string name="beam_complete">Completóse la tresmisión</string>
-    <string name="beam_failed">La tresmisión nun se completó</string>
-    <string name="beam_canceled">La tresmisión encaboxóse</string>
-    <string name="cancel">Encaboxar</string>
-    <string name="beam_tap_to_view">Toca equí pa ver el conteníu</string>
-    <string name="beam_handover_not_supported">El preséu del receutor nun ye compatible cola tresmisión de ficheros grandes.</string>
-    <string name="beam_try_again">Volvi axuntar los preseos</string>
-    <string name="beam_busy">La tresmisión nun ta disponible. Volvi tentalo cuando se complete l\'anterior.</string>
-    <string name="device">preséu</string>
-    <string name="connecting_peripheral">Conectando «<xliff:g id="device_name">%1$s</xliff:g>»</string>
-    <string name="connected_peripheral">«<xliff:g id="device_name">%1$s</xliff:g>» conectóse</string>
-    <string name="connect_peripheral_failed">Nun se pudo conectar «<xliff:g id="device_name">%1$s</xliff:g>»</string>
-    <string name="disconnecting_peripheral">Desconectando «<xliff:g id="device_name">%1$s</xliff:g>»</string>
-    <string name="disconnected_peripheral">«<xliff:g id="device_name">%1$s</xliff:g>» desconectóse</string>
-    <string name="pairing_peripheral">Empareyando «<xliff:g id="device_name">%1$s</xliff:g>»</string>
-    <string name="pairing_peripheral_failed">Nun se pudo empareyar «<xliff:g id="device_name">%1$s</xliff:g>»</string>
-    <string name="failed_to_enable_bt">Nun se pudo habilitar el Bluetooth</string>
-    <string name="confirm_pairing">¿De xuru que quies empareyar el preséu Bluetooth «<xliff:g id="device_name">%1$s</xliff:g>»?</string>
-    <string name="pair_yes">Sí</string>
-    <string name="pair_no">Non</string>
-    <string name="tap_again_to_pay">Volvi tocar pa pagar con «<xliff:g id="app">%1$s</xliff:g>»</string>
-    <string name="tap_again_to_complete">Volvi tocar pa completar l\'aición con <xliff:g id="app">%1$s</xliff:g></string>
-    <string name="transaction_failure">Esta transaición nun se pudo completar con «<xliff:g id="app">%1$s</xliff:g>».</string>
-    <string name="could_not_use_app">Nun se pudo usar «<xliff:g id="app">%1$s</xliff:g>».</string>
-    <string name="pay_with">Pagar con</string>
-    <string name="complete_with">Completar con</string>
-    <string name="default_pay_app_removed">Quitóse\'l serviciu preferíu de «Tocar y pagar». ¿Quies escoyer otru?</string>
-    <string name="ask_nfc_tap">Toca otru preséu pa completar l\'aición</string>
-    <string name="wifi_connect">Conectar</string>
-    <string name="status_unable_to_connect">Nun ye posible conectase a la rede</string>
-    <string name="status_wifi_connected">Conectóse</string>
-    <string name="title_connect_to_network">Conexón a la rede</string>
-    <string name="prompt_connect_to_network">¿Quies conectate a la rede «<xliff:g id="network_ssid">%1$s</xliff:g>»?</string>
-    <string name="beam_requires_nfc_enabled">Android Beam rique que\'l NFC tea habilitáu. ¿Quies habilitalu?</string>
-    <string name="android_beam">Android Beam</string>
-    <string name="beam_requires_external_storage_permission">L\'aplicación nun tien el permisu del almacenamientu esternu, obligatoriu pa tresmitir el ficheru</string>
-    <string name="title_confirm_url_open">¿Quies abrir l\'enllaz?</string>
-    <string name="summary_confirm_url_open" product="tablet">La tableta recibió un enllaz pente NFC:</string>
-    <string name="summary_confirm_url_open" product="default">El teléfonu recibió un enllaz pente NFC:</string>
-    <string name="action_confirm_url_open">Abrir l\'enllaz</string>
-    <string name="tag_read_error">Fallu de la llectura NFC. Volvi tentalo.</string>
-    <string name="tag_dispatch_failed">Nun hai nenguna aplicación compatible con esta etiqueta NFC</string>
-    <string name="nfc_blocking_alert_title">El NFC pue tar bloquiáu</string>
-    <string name="nfc_blocking_alert_message">Toca equí pa saber cómo igualo.</string>
+    <string name="nfc_logging_alert_title">Tán rexistrándose los datos de NFC</string>
+    <string name="nfc_logging_alert_message">Toca pa dexar de rexistrar.</string>
 </resources>
diff --git a/overlay/packages/apps/Nfc/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Nfc/res/values-fur-rIT/strings.xml
index cbaa60c..c14d5b4 100644
--- a/overlay/packages/apps/Nfc/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/Nfc/res/values-fur-rIT/strings.xml
@@ -52,4 +52,6 @@
     <string name="tag_dispatch_failed">Nissune aplicazion supuartade par cheste etichete NFC</string>
     <string name="nfc_blocking_alert_title">Il NFC al podarès jessi blocât</string>
     <string name="nfc_blocking_alert_message">Tocje par scuvierzi cemût comedâ.</string>
+    <string name="nfc_logging_alert_title">E je in cors la regjistrazion dai dâts NFC.</string>
+    <string name="nfc_logging_alert_message">Tocje par fermâ la regjistrazion.</string>
 </resources>
diff --git a/overlay/packages/apps/PhoneCommon/res/values-ast-rES/strings.xml b/overlay/packages/apps/PhoneCommon/res/values-ast-rES/strings.xml
deleted file mode 100644
index 20d5c37..0000000
--- a/overlay/packages/apps/PhoneCommon/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,60 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2012 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="description_dialpad_back">Navigate back</string>
-    <string name="description_dialpad_overflow">Más opciones</string>
-    <string name="description_delete_button">retrocesu</string>
-    <string name="description_image_button_plus">más</string>
-    <string name="description_voicemail_button">buzón de voz</string>
-    <string name="default_notification_description">Soníu predeterináu (<xliff:g id="default_sound_title">%1$s</xliff:g>)</string>
-    <string name="callFailed_userBusy">La llinia ta ocupada</string>
-    <string name="callFailed_congestion">La rede ta ocupada</string>
-    <string name="callFailed_timedOut">Nun hai rempuesta. Escosó\'l tiempu d\'espera.</string>
-    <string name="callFailed_server_unreachable">El sirvidor nun ta al algame</string>
-    <string name="callFailed_number_unreachable">El númberu nun ta al algame</string>
-    <string name="callFailed_invalid_credentials">El nome d\'usuariu o la contraseña son incorreutos</string>
-    <string name="callFailed_out_of_network">Llamada de fuera de la rede</string>
-    <string name="callFailed_server_error">Fallu del sirvidor. Volvi tentalo dempués.</string>
-    <string name="callFailed_noSignal">Nun hai señal</string>
-    <string name="callFailed_limitExceeded">Superóse la llende d\'ACM</string>
-    <string name="callFailed_powerOff">La señal móvil ta desactivada</string>
-    <string name="callFailed_simError">Nun hai nenguna SIM o produxo un fallu</string>
-    <string name="callFailed_outOfService">La rede móvil nun ta disponible</string>
-    <string name="callFailed_fdn_only">Los NMF torguen les llamaes salientes.</string>
-    <string name="callFailed_dialToUssd">La llamada convirtióse nuna solicitú USSD</string>
-    <string name="callFailed_dialToSs">La llamada convirtióse nuna solicitú SS</string>
-    <string name="callFailed_dialToDial">Convirtióse a un númberu diferente</string>
-    <string name="callFailed_dialToDialVideo">Convirtióse a una videollamada</string>
-    <string name="callFailed_dialVideoToSs">La videollamada convirtióse nuna solicitú SS</string>
-    <string name="callFailed_dialVideoToUssd">La videollamada convirtióse nuna solicitú USSD</string>
-    <string name="callFailed_dialVideoToDial">Convirtióse a una llamada estándar</string>
-    <string name="callFailed_dialVideoToDialVideo">Convirtióse a un númberu diferente</string>
-    <string name="callFailed_cb_enabled">Nun se puen facer llamaes mentanto\'l bloquéu de llamaes ta activáu.</string>
-    <string name="callFailed_dsac_restricted">El control d\'accesos torga les llamaes.</string>
-    <string name="callFailed_dsac_restricted_emergency">El control d\'accesos torga les llamaes d\'emerxencia.</string>
-    <string name="callFailed_dsac_restricted_normal">El control d\'accesos torga les llamaes estándar.</string>
-    <string name="callFailed_unobtainable_number">El númberu nun ye válidu</string>
-    <string name="incall_error_missing_voicemail_number">El númberu del buzón de voz ye desconocíu.</string>
-    <string name="callFailed_video_call_tty_enabled">Nun se puen facer videollamaes cuando\'l mou TTY ta activáu.</string>
-    <string name="callEnded_pulled">La llamada tresfirióse a otru preséu.</string>
-    <string name="ringtone_silent">Nengún</string>
-    <string name="ringtone_unknown">Timbre desconocíu</string>
-    <string name="callFailed_maximum_reached">Toles llinies disponibles tán n\'usu.  Pa facer una llamada, desconecta una de les llamaes nesti preséu o n\'otru de los tos preseos.</string>
-    <string name="callFailed_data_disabled">La llamada finó porque se desactivaron los datos móviles.</string>
-    <string name="callFailed_data_limit_reached_description">La llamada finó porque s\'algamó la llende de los datos móviles.</string>
-    <string name="callFailed_data_limit_reached">Algamóse la llende de datos. La llamada finó.</string>
-</resources>
diff --git a/overlay/packages/apps/QuickAccessWallet/res/values-ast-rES/strings.xml b/overlay/packages/apps/QuickAccessWallet/res/values-ast-rES/strings.xml
deleted file mode 100644
index 9bb3f7f..0000000
--- a/overlay/packages/apps/QuickAccessWallet/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="error_user_locked">Desbloquia\'l teléfonu pa cargar la información de pagu</string>
-    <string name="accessibility_menu">Menú</string>
-    <string name="error_generic">Hebo un problema al consiguir les tarxetes. Volvi tentalo dempués</string>
-    <string name="settings">Axustes</string>
-</resources>
diff --git a/overlay/packages/apps/SafetyRegulatoryInfo/res/values-ast-rES/strings.xml b/overlay/packages/apps/SafetyRegulatoryInfo/res/values-ast-rES/strings.xml
deleted file mode 100644
index 8f4064d..0000000
--- a/overlay/packages/apps/SafetyRegulatoryInfo/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="app_name">Manual de seguranza y de normativa</string>
-</resources>
diff --git a/overlay/packages/apps/Settings/res/values-ast-rES/arrays.xml b/overlay/packages/apps/Settings/res/values-ast-rES/arrays.xml
index abf3484..b4e494e 100644
--- a/overlay/packages/apps/Settings/res/values-ast-rES/arrays.xml
+++ b/overlay/packages/apps/Settings/res/values-ast-rES/arrays.xml
@@ -18,42 +18,6 @@
 */
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string-array name="dark_ui_scheduler_preference_titles">
-        <item>@string/dark_ui_auto_mode_never</item>
-        <item>@string/dark_ui_auto_mode_custom</item>
-        <item>@string/dark_ui_auto_mode_auto</item>
-    </string-array>
-    <string-array name="dark_ui_scheduler_with_bedtime_preference_titles">
-        <item>@string/dark_ui_auto_mode_never</item>
-        <item>@string/dark_ui_auto_mode_custom</item>
-        <item>@string/dark_ui_auto_mode_auto</item>
-        <item>@string/dark_ui_auto_mode_custom_bedtime</item>
-    </string-array>
-    <string-array name="wifi_tether_security">
-        <item>@string/wifi_security_sae</item>
-        <item>@string/wifi_security_psk_sae</item>
-        <item>@string/wifi_security_wpa2</item>
-        <item>@string/wifi_security_none</item>
-    </string-array>
-    <string-array name="bearer_entries">
-        <item>Unspecified</item>
-        <item>LTE</item>
-        <item>HSPAP</item>
-        <item>HSPA</item>
-        <item>HSUPA</item>
-        <item>HSDPA</item>
-        <item>UMTS</item>
-        <item>EDGE</item>
-        <item>GPRS</item>
-        <item>eHRPD</item>
-        <item>EVDO_B</item>
-        <item>EVDO_A</item>
-        <item>EVDO_0</item>
-        <item>1xRTT</item>
-        <item>IS95B</item>
-        <item>IS95A</item>
-        <item>NR</item>
-    </string-array>
     <string-array name="accessibility_button_location_selector_titles">
         <item>Floating over other apps</item>
         <item>Barra de navegación</item>
diff --git a/overlay/packages/apps/Settings/res/values-ast-rES/strings.xml b/overlay/packages/apps/Settings/res/values-ast-rES/strings.xml
index 6daf056..0d843a8 100644
--- a/overlay/packages/apps/Settings/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-ast-rES/strings.xml
@@ -14,94 +14,27 @@
      limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="keywords_add_bt_device">bluetooth</string>
-    <string name="connected_device_media_device_title">Preseos multimedia</string>
-    <string name="connected_device_other_device_title">Otros preseos</string>
-    <string name="proxy_error_dismiss">D\'acuerdu</string>
-    <string name="okay">D\'acuerdu</string>
-    <string name="location_settings_title">Llocalización</string>
-    <string name="account_settings_title">Cuentes</string>
-    <string name="security_settings_title">Seguranza</string>
+    <string name="temperature_preferences_title">Temperatura</string>
     <string name="security_settings_face_preference_title">Desbloquéu facial</string>
     <string name="security_settings_face_profile_preference_title">Desbloquéu facial pal perfil llaboral</string>
-    <string name="face_intro_error_max">Amestesti\'l númberu máximu de cares</string>
-    <string name="face_intro_error_unknown">Nun se puen amestar más cares</string>
-    <string name="security_settings_face_enroll_dialog_ok">D\'acuerdu</string>
-    <string name="security_settings_face_enroll_error_generic_dialog_message">El rexistru facial nun funcionó.</string>
     <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2">El desbloquéu pel sensor de buelgues crea un modelu únicu de la to buelga pa verificar que yes tu. Pa crear esti modelu de buelga demientres la configuración, vas facer imáxenes de la to buelga dende posiciones estremaes.</string>
     <string name="biometric_settings_use_face_preference_summary">Cola cara</string>
     <string name="biometric_settings_use_fingerprint_preference_summary">Cola buelga</string>
     <string name="biometric_settings_use_face_or_fingerprint_preference_summary">Cola cara o cola buelga</string>
-    <string name="biometric_settings_hand_back_to_guardian_ok">D\'acuerdu</string>
-    <string name="biometric_settings_add_biometrics_in_split_mode_ok">D\'acuerdu</string>
-    <string name="security_settings_fingerprint_enroll_dialog_ok">D\'acuerdu</string>
-    <string name="security_header">Seguranza</string>
-    <string name="encryption_settings_title">Cifráu</string>
-    <string name="number_of_device_admins_none">Nun hai nenguna aplicación activa</string>
-    <string name="bluetooth_settings_title">Bluetooth</string>
     <string name="wifi_band_6ghz">6 GHz</string>
-    <string name="wifi_venue_website_button_text">Abrir el sitiu</string>
-    <string name="android_beam_settings_title">Android Beam</string>
-    <string name="wifi_subscription">Soscripción</string>
     <string name="wifi_hotspot_speed_6g">6 GHz</string>
-    <string name="wifi_add_app_single_network_title">¿Quies guardar esta rede?</string>
-    <string name="wifi_add_app_single_network_saving_summary">Guardando\u2026</string>
-    <string name="wifi_add_app_network_save_failed_summary">Nun se pue guardar. Volvi tentalo.</string>
-    <string name="wifi_add_app_networks_saving_summary">Guardando <xliff:g id="number" example="3">%d</xliff:g> redes\u2026</string>
-    <string name="wallpaper_settings_title">Fondu de pantalla</string>
     <string name="style_and_wallpaper_settings_title">Fondu de pantalla y estilu</string>
-    <string name="screensaver_settings_title">Curiapantalles</string>
-    <string name="ambient_display_screen_title">Visualización d\'ambiente</string>
-    <string name="sim_enter_ok">D\'acuerdu</string>
     <string name="main_clear_progress_text">Espera\u2026</string>
-    <string name="tether_settings_title_all">Tethering y puntu Wi-Fi</string>
-    <string name="ethernet_tether_checkbox_text">Tethering per ethernet</string>
-    <string name="tethering_footer_info">Usa\'l puntu Wi\u2011Fi y el tethering pa fornir internet a otros preseos pente la to conexón de datos móviles. Les aplicaciones tamién puen crear un puntu Wi\u2011Fi pa compartir conteníu colos preseos cercanos.</string>
-    <string name="tethering_footer_info_sta_ap_concurrency">Usa\'l puntu Wi\u2011Fi y el tethering pa fornir internet a otros preseos pente la to conexón de datos móviles o de Wi\u2011Fi. Les aplicaciones tamién puen crear un puntu Wi\u2011Fi pa compartir conteníu colos preseos cercanos.</string>
-    <string name="mobile_insert_sim_card" translatable="true">Inxerta una tarxeta SIM y reanicia\'l preséu</string>
-    <string name="mobile_connect_to_internet" translatable="true">Conéctate a internet</string>
     <string name="location_category_recent_location_access">Accesu recién</string>
-    <string name="lockpassword_forgot_password">¿Escaeciesti la contraseña?</string>
-    <string name="lockpassword_forgot_pattern">¿Escaeciesti\'l patrón?</string>
-    <string name="lockpassword_forgot_pin">¿Escaeciesti\'l PIN?</string>
-    <string name="dlg_ok">D\'acuerdu</string>
-    <string name="app_not_found_dlg_text"> Nun s\u2019atopó l\u2019aplicación na llista d\'aplicaciones instalaes.</string>
-    <string name="keywords_virtual_keyboard">Gboard</string>
-    <string name="keyboard_options_category">Opciones</string>
-    <string name="trackpad_pointer_speed">Velocidá del punteru</string>
-    <string name="trackpad_notifications_title">Avisos</string>
-    <string name="pointer_speed">Velocidá del punteru</string>
-    <string name="user_dict_settings_title">Diccionariu personal</string>
-    <string name="user_dict_settings_add_dialog_confirm">D\'acuerdu</string>
-    <string name="builtin_keyboard_settings_title">Tecláu físicu</string>
     <string name="screen_reader_category_title">Llector de pantalla</string>
     <string name="captions_category_title">Sotítulos</string>
-    <string name="audio_category_title">Audiu</string>
-    <string name="accessibility_screen_option">Opciones</string>
-    <string name="accessibility_tutorial_dialog_button">Entendílo</string>
     <string name="accessibility_shortcut_edit_dialog_summary_software_floating"><annotation id="link">Más opciones</annotation></string>
-    <string name="accessibility_button_location_title">Llocalización</string>
-    <string name="accessibility_autoclick_short_summary">0,2 segundos</string>
-    <string name="accessibility_autoclick_medium_summary">0,6 segundos</string>
-    <string name="accessibility_autoclick_long_summary">1 segundu</string>
-    <string name="daltonizer_mode_tritanomaly_summary">Tritanomalía</string>
-    <string name="vpn_settings_title">VPN</string>
-    <string name="adaptive_connectivity_title">Conectividá adautable</string>
-    <string name="adaptive_connectivity_summary">Aumenta la duración de la batería y ameyora\'l rindimientu del preséu pente la xestión automática de les conexones a la rede</string>
     <string name="request_manage_credentials_more">Amosar más</string>
     <string name="remove_credential_management_app">Quitar l\'aplicación</string>
     <string name="remove_credential_management_app_dialog_title">¿Quies quitar esta apicación?</string>
-    <string name="notification_history_title">Historial d\'avisos</string>
-    <string name="vpn_version">Versión</string>
-    <string name="nfc_payment_settings_title">Pagos ensin contautu</string>
-    <string name="nfc_how_it_works_got_it">Entendílo</string>
     <string name="nfc_more_title">Más\u2026</string>
-    <string name="cell_broadcast_settings">Alertes d\'emerxencia ensin filos</string>
     <string name="nr_advanced_calling_title">Vo5G</string>
-    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined">¿Quies unviar los contautos a la operadora?</string>
     <string name="sim_settings_title">SIMs</string>
-    <string name="network_dashboard_title">Redes ya internet</string>
-    <string name="connected_devices_dashboard_title">Preseos conectaos</string>
     <string name="account_dashboard_title">Contraseñes y cuentes</string>
     <string name="zen_mode_duration_summary_time_hours">        {count, plural, one {}
             =1    {1 hora}
@@ -113,34 +46,14 @@
             other {# minutos}
         }
     </string>
-    <string name="zen_category_people">Persones</string>
-    <string name="zen_custom_settings_dialog_ok">Entendílo</string>
-    <string name="zen_custom_settings_notifications_header">Avisos</string>
     <string name="work_sync_dialog_title">¿Quies usar los soníos del perfil personal?</string>
-    <string name="configure_notification_settings">Avisos</string>
-    <string name="conversation_notifs_category">Conversación</string>
-    <string name="asst_capability_ranking_title">Clasificación de los avisos adautables</string>
-    <string name="asst_capabilities_actions_replies_title">Aiciones y rempuestes suxeríes</string>
-    <string name="asst_capabilities_actions_replies_summary">Amuesa automáticamente les aiciones y les rempuestes suxeríes</string>
-    <string name="notification_history">Historial d\'avisos</string>
-    <string name="history_toggled_on_title">Nun hai avisos de recién</string>
-    <string name="bubble_app_setting_selected_conversation_title">Conversaciones</string>
-    <string name="notifications_title">Avisos</string>
-    <string name="conversations_category_title">Conversaciones</string>
-    <string name="important_conversations">Conversaciones con prioridá</string>
     <string name="notification_assistant_security_warning_summary">        Los avisos ameyoraos trocaron los avisos adautables n\'Android 12.
         Esta función amuesa aiciones y rempuestes suxeríes, y organiza los avisos.
         \n\nLos avisos ameyoraos puen acceder al conteníu de los avisos, incluyida la información
         personal como\'l nome y los mensaxes de los contautos. Esta función tamién pue escartar o
         responder a los avisos, como les llamaes telefóniques y controlar el mou «Nun molestar».
     </string>
-    <string name="notif_type_conversation">Conversaciones</string>
-    <string name="notif_type_alerting">Avisos</string>
     <string name="notif_listener_not_migrated">Esta aplicación nun ye compatible colos axustes ameyoraos</string>
-    <string name="notification_vibrate_title">Vibración</string>
-    <string name="zen_mode_conversations_title">Conversaciones</string>
-    <string name="zen_mode_from_all_conversations">Toles conversaciones</string>
-    <string name="zen_mode_from_important_conversations">Conversaciones con prioridá</string>
     <string name="zen_mode_conversations_count">        {count, plural,
             =0    {Nada}
             =1    {1 conversación}
@@ -155,39 +68,16 @@
             other {{contact_1}, {contact_2}, y # más}
         }
     </string>
-    <string name="zen_mode_messages">Mensaxes</string>
-    <string name="zen_mode_messages_title">Mensaxes</string>
     <string name="zen_mode_contacts_count">        {count, plural, one {}
             =0    {Nada}
             =1    {1 contautu}
             other {# contautos}
         }
     </string>
-    <string name="zen_mode_media">Soníos multimedia</string>
-    <string name="zen_mode_reminders">Recordatorios</string>
-    <string name="zen_mode_reminders_list_first">Recordatorios</string>
-    <string name="zen_mode_events_list_first">Eventos</string>
-    <string name="zen_mode_bypassing_apps_summary_all">Tolos avisos</string>
-    <string name="zen_mode_bypassing_apps_summary_some">Dalgunos avisos</string>
-    <string name="zen_mode_calls_summary_one"><xliff:g id="caller type" example="contacts">%1$s</xliff:g></string>
-    <string name="zen_mode_calls_summary_two"><xliff:g id="caller type" example="starred contacts">%1$s</xliff:g> y <xliff:g id="caller type" example="repeat callers">%2$s</xliff:g></string>
     <string name="warning_button_text">Alvertencia</string>
-    <string name="suggestion_button_close">Zarrar</string>
     <string name="memtag_reboot_title">¿Quies reaniciar el preséu?</string>
-    <string name="app_launch_dialog_ok">D\'acuerdu</string>
-    <string name="storage_type_internal">almacenamientu internu</string>
-    <string name="storage_type_external">almacenamientu esternu</string>
-    <string name="notifications_label">Avisos</string>
-    <string name="memory_settings_title">Memoria</string>
-    <string name="usb_switching">Cambiando\u2026</string>
-    <string name="battery_tips_card_dismiss_button">Entendílo</string>
-    <string name="notification_log_channel">canal</string>
     <string name="assistant_gesture_category_title">Asistente dixital</string>
-    <string name="left_edge">Berbesu esquierdu</string>
-    <string name="right_edge">Berbesu derechu</string>
-    <string name="storage_audio">Audiu</string>
     <string name="autofill_passwords">Contraseñes</string>
-    <string name="location_category">Llocalización</string>
     <string-array name="graphics_driver_all_apps_preference_values">
         <item>@string/graphics_driver_app_preference_default</item>
         <item>@string/graphics_driver_app_preference_production_driver</item>
@@ -201,7 +91,6 @@
     </string-array>
     <string name="my_device_info_basic_info_category_title">Información básica</string>
     <string name="my_device_info_device_identifiers_category_title">Identificadores del preséu</string>
-    <string name="sim_card">SIM</string>
     <string name="privileged_action_disable_fail_title">Nun se pue desactivar la operadora</string>
     <string name="privileged_action_disable_fail_text">Asocedió daqué malo y nun se pudo desactivar la operadora.</string>
     <string name="sim_action_enable_dsds_title">¿Quies usar 2 SIMs?</string>
@@ -209,27 +98,15 @@
     <string name="dsds_activation_failure_title">Nun se pue activar la SIM</string>
     <string name="sim_switch_channel_id">Cambéu d\'operadora</string>
     <string name="network_changed_notification_text">La rede móvil camudó</string>
-    <string name="sim_card_label">SIM</string>
-    <string name="network_connection_searching_message">Buscando\'l preséu\u2026</string>
-    <string name="network_connection_connecting_message">Conectando al preséu\u2026</string>
-    <string name="privacy_dashboard_title">Privacidá</string>
-    <string name="track_frame_time_keywords">GPU</string>
-    <string name="select_invalid_bug_report_handler_toast_text">Esta escoyeta yá nun ye válida. Volvi tentalo.</string>
-    <string name="power_menu_long_press_for_power_menu_title">Menú d\'apagáu</string>
     <string name="power_menu_long_press_for_assistant_title">Asistente dixital</string>
     <string name="provider_internet_settings">Internet</string>
     <string name="provider_network_settings_title">SIMs</string>
     <string name="sms_preference_title">SMS</string>
-    <string name="sim_category_title">SIM</string>
     <string name="default_active_sim_sms">SMS</string>
     <string name="preference_summary_default_combination"><xliff:g id="state" example="Connected">%1$s</xliff:g> / <xliff:g id="networkMode" example="LTE">%2$s</xliff:g></string>
-    <string name="bluetooth_message_access_dialog_title">¿Quies acceder a los mensaxes?</string>
-    <string name="bluetooth_phonebook_access_notification_content">Un preséu quier acceder a los contautos y al rexistru de llamaes. Toca pa ver los detalles.</string>
-    <string name="bluetooth_phonebook_access_dialog_title">¿Quies permitir l\'accesu a los contautos y al rexistru de llamaes?</string>
     <string name="category_name_appearance">Aspeutu</string>
     <string name="dark_theme_main_switch_title">Usar l\'estilu escuru</string>
     <string name="smart_forwarding_ongoing_text">Anovando los axustes…</string>
-    <string name="smart_forwarding_missing_alert_dialog_text">D\'acuerdu</string>
     <string name="show_clip_access_notification">Amosar l\'accesu al cartafueyu</string>
     <string name="show_clip_access_notification_summary">Amuesa un mensaxe cuando les aplicaciones accedan al testu, les imáxenes o a otru conteníu que copies</string>
     <string name="mic_toggle_title">Accesu al micrófonu</string>
diff --git a/overlay/packages/apps/Settings/res/values-cy/strings.xml b/overlay/packages/apps/Settings/res/values-cy/strings.xml
index 1485cc5..eda0104 100644
--- a/overlay/packages/apps/Settings/res/values-cy/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-cy/strings.xml
@@ -21,6 +21,7 @@
     <string name="deny">Gwrthod</string>
     <string name="confirmation_turn_on">Troi ymlaen</string>
     <string name="device_info_default">Anhysybys</string>
+    <string name="device_info_protected_single_press">Tapio i ddangos gwybodaeth</string>
     <string name="show_dev_on">Rwyt bellach â mynediad fel datblygwr!</string>
     <string name="show_dev_already">Dim angen; rwyt eisoes yn ddatblygwr.</string>
     <string name="dev_settings_disabled_warning">Galluoga opsiynau datblygwyr yn gyntaf.</string>
@@ -98,6 +99,8 @@
     <string name="connected_device_previously_connected_screen_title">Wedi\u2019u cysylltu yn y gorffennol</string>
     <string name="connected_device_bluetooth_turned_on_toast">Bluetooth wedi\'i droi ymlaen</string>
     <string name="previous_connected_see_all">Gweld y cyfan</string>
+    <string name="connected_device_fast_pair_device_see_all">Gweld y cyfan</string>
+    <string name="stylus_default_notes_summary_work"><xliff:g id="app_name" example="Mail">%s</xliff:g> (Proffil gwaith)</string>
     <string name="date_and_time">Dyddiad ac amser</string>
     <string name="proxy_settings_title">Procsi</string>
     <string name="proxy_clear_text">Clirio</string>
@@ -134,6 +137,7 @@
     <string name="desc_no_available_supported_locale">Dyw dewis iaith yr ap hwn ddim ar gael yn Gosodiadau.</string>
     <string name="desc_app_locale_disclaimer">Gall fod yr iaith yn wahanol i\u2019r ieithoedd ar gael yn yr ap. Dyw rhai apiau ddim yn cefnogi\u2019r gosodiad hwn.</string>
     <string name="button_label_confirmation_of_system_locale_change">Newid</string>
+    <string name="title_unavailable_locale">%s dim ar gael</string>
     <string name="default_string_of_regional_preference">Defnyddio\'r rhagosodiad</string>
     <string name="dlg_remove_locales_message">Caiff testun ei ddangos mewn iaith arall.</string>
     <string name="dlg_remove_locales_error_title">Nid yw\'n bosib tynnu pob un iaith.</string>
@@ -197,8 +201,6 @@
     <string name="location_settings_footer_location_off">        Mae mynediad at leoliad i ffwrdd ar gyfer pob ap a gwasanaeth. Gall dy ddyfais dal i
         anfon gwybodaeth lleoliad at wasanaethau brys os fyddi\'n galw neu anfon neges brys.
     </string>
-    <string name="location_settings_footer_learn_more_content_description">        Dysgu rhagor am Gosodiadau Lleoliad.
-    </string>
     <string name="account_settings_title">Cyfrifon</string>
     <string name="security_settings_title">Diogelwch</string>
     <string name="encryption_and_credential_settings_title">Amgryptio a thystnodiadau</string>
@@ -280,6 +282,14 @@
     <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2">Mae Datgloi ag Ôl Bys yn creu model unigryw o ôl dy fys i ddilysu mai ti sydd yno. I greu\u2019r model hwn ar ddechrau, rhaid cymryd lluniau o ôl dy fys o wahanol fannau.</string>
     <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2">Mae Datgloi ag Ôl Bys yn creu model unigryw o ôl bys dy blentyn i ddilysu mai nhw sydd yno. I greu\u2019r model hwn ar ddechrau, rhaid cymryd lluniau o\'r ôl bys o wahanol fannau.</string>
     <string name="security_settings_activeunlock_biometric_setup">Gosod</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">Dim nawr</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">Parhau</string>
+    <string name="security_settings_remoteauth_enroll_introduction_more">Rhagor</string>
+    <string name="security_settings_remoteauth_enroll_introduction_how_title">Sut mae\'n gweithio</string>
+    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title">Rwyt mewn rheolaeth</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Diddymu</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">Cadarnhau</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">Iawn</string>
     <string name="security_settings_work_biometric_preference_title">Datgloi Gwyneg ac Ôl Bys ar gyfer gwaith</string>
     <string name="security_settings_biometric_preference_summary_both_fp_multiple">Ychwanegwyd wyneb ac olion bysedd</string>
     <string name="security_settings_biometric_preference_summary_both_fp_single">Ychwanegwyd wyneb ac ôl bys</string>
@@ -354,6 +364,19 @@
     <string name="security_header">Diogelwch</string>
     <string name="privacy_header">Preifatrwydd</string>
     <string name="work_profile_category_header">Proffil gwaith</string>
+    <string name="private_space_biometric_title">Datgloi ag Wyneb ac Ôl Bys</string>
+    <string name="private_space_biometric_summary">Tapia i\'w osod</string>
+    <string name="private_space_screen_lock_summary">Yr un fath a chlo sgrin y ddyfais</string>
+    <string name="privatespace_hide_off_summary">I ffwrdd</string>
+    <string name="privatespace_hide_on_summary">Ymlaen</string>
+    <string name="private_space_category_system">System</string>
+    <string name="no_device_lock_title">Gosod clo sgrin</string>
+    <string name="no_device_lock_action_label">Gosod clo\'r sgrin</string>
+    <string name="no_device_lock_cancel">Diddymu</string>
+    <string name="private_space_cancel_label">Diddymu</string>
+    <string name="private_space_setup_button_label">Gosod</string>
+    <string name="private_space_how_title">Sut mae\'n gweithio</string>
+    <string name="private_space_done_label">Iawn</string>
     <string name="fingerprint_add_max">Gellir ychwanegu hyd at <xliff:g id="count" example="5">%d</xliff:g> ôl bys</string>
     <string name="fingerprint_intro_error_max">Rwyt wedi ychwanegu\'r nifer mwyaf o olion bysau a ganiateir.</string>
     <string name="fingerprint_intro_error_unknown">Methu ag ychwanegu rhagor o ôl fysedd</string>
@@ -462,7 +485,6 @@
     <string name="bluetooth_device_context_connect">Cysylltu</string>
     <string name="bluetooth_device_context_disconnect">Datgysylltu</string>
     <string name="bluetooth_device_context_pair_connect">Paru a chysylltu</string>
-    <string name="bluetooth_empty_list_bluetooth_off">Pan mae Bluetooth ymlaen, gall dy ddyfais gyfathrebu gyda dyfeisiau Bluetooth gerllaw.</string>
     <string name="bluetooth_scan_change">Newid</string>
     <string name="device_details_title">Manylion y ddyfais</string>
     <string name="bluetooth_device_mac_address">Cyfeiriad Bluetooth y ddyfais: <xliff:g id="address">%1$s</xliff:g></string>
@@ -638,15 +660,12 @@
     <string name="lost_internet_access_cancel">Aros ar Wi\u2011Fi</string>
     <string name="lost_internet_access_persist">Byth dangos eto</string>
     <string name="wifi_connect">Cysylltu</string>
-    <string name="wifi_turned_on_message">Wi\u2011Fi  wedi\u2019i droi ymlaen</string>
     <string name="wifi_connected_to_message">Wedi cysylltu i <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
-    <string name="wifi_connecting_to_message">Yn cysylltu â <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
     <string name="wifi_connecting">Yn cysylltu\u2026</string>
     <string name="wifi_failed_connect_message">Methwyd â chysylltu â\'r rhwydwaith</string>
     <string name="wifi_not_in_range_message">Rhwydwaith dim o fewn cyrraedd</string>
     <string name="wifi_forget">Anghofio</string>
     <string name="wifi_modify">Addasu</string>
-    <string name="wifi_failed_forget_message">Methwyd ag anghofio\'r rhwydwaith</string>
     <string name="wifi_save">Cadw</string>
     <string name="wifi_failed_save_message">Methwyd a chadw\'r rhwydwaith</string>
     <string name="wifi_cancel">Diddymu</string>
@@ -693,7 +712,6 @@
     <string name="wifi_hotspot_no_password_subtext">Dim cyfrinair wedi\'i osod</string>
     <string name="wifi_hotspot_name_title">Enw llecyn</string>
     <string name="wifi_hotspot_password_title">Cyfrinair y llecyn</string>
-    <string name="wifi_hotspot_ap_band_title">Band AP</string>
     <string name="wifi_hotspot_auto_off_title">Troi\'r llecyn i ffwrdd yn awtomatig</string>
     <string name="wifi_hotspot_auto_off_summary">Pan nad oes dyfeisiau wedi\'u cysylltu</string>
     <string name="wifi_hotspot_maximize_compatibility">Ehangu cytunedd</string>
@@ -880,6 +898,7 @@
     <string name="kernel_version">Fersiwn cnewyllyn</string>
     <string name="build_number">Rhif adeiledd</string>
     <string name="module_version">Diweddariad system Google Play</string>
+    <string name="battery_info">Gwybodaeth batri</string>
     <string name="device_info_not_available">Dim ar gael</string>
     <string name="storage_settings">Storfa</string>
     <string name="storage_settings_for_app">Storfa a storfa dros dro</string>
@@ -1055,16 +1074,6 @@
     <string name="tether_settings_summary_all">Llecyn, USB, Bluetooth, Ethernet</string>
     <string name="tether_settings_summary_off">Peidio â rhannu\'r rhyngrwyd â dyfeisiau eraill</string>
     <string name="tether_preference_summary_off">I ffwrdd</string>
-    <string name="tethering_interface_options">Tenynnu</string>
-    <string name="disable_wifi_hotspot_title">Peidio â defnyddio man poeth Wi\u2011Fi</string>
-    <string name="disable_wifi_hotspot_when_usb_on">Rhannu\'r rhyngrwyd trwy USB yn unig</string>
-    <string name="disable_wifi_hotspot_when_bluetooth_on">Rhannu\'r rhyngrwyd trwy Bluetooth yn unig</string>
-    <string name="disable_wifi_hotspot_when_ethernet_on">Rhannu\'r rhyngrwyd trwy Ethernet yn unig</string>
-    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on">Rhannu\'r rhyngrwyd trwy USB a Bluetooth yn unig</string>
-    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on">Rhannu\'r rhyngrwyd trwy USB ac Ethernet yn unig</string>
-    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on">Rhannu\'r rhyngrwyd trwy Bluetooth ac Ethernet yn unig</string>
-    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on">Rhannu\'r rhyngrwyd trwy USB, Bluetooth ac Ethernet yn unig</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">Tenynnu USB</string>
     <string name="bluetooth_tether_checkbox_text">Tenynnu Bluetooth</string>
     <string name="ethernet_tether_checkbox_text">Tenynnu ethernet</string>
@@ -1072,7 +1081,6 @@
     <string name="tethering_footer_info_sta_ap_concurrency">Defnyddia lecyn a thennynu ddarparu rhyngrwyd i ddyfeisiau eraill trwy dy gysylltiad Wi\ u2011Fi neu ddata symudol. Gall apiau hefyd greu lecyn i rannu cynnwys gyda dyfeisiau cyfagos.</string>
     <string name="tethering_help_button_text">Cymorth</string>
     <string name="network_settings_title">Rhwydwaith symudol</string>
-    <string name="manage_mobile_plan_title" translatable="true">Cynllun ffôn symudol</string>
     <string name="sms_application_title" translatable="true">Ap SMS</string>
     <string name="sms_change_default_dialog_title" translatable="true">Newid apiau SMS?</string>
     <string name="sms_change_default_dialog_text" translatable="true">Defnyddio <xliff:g id="new_app">%1$s</xliff:g> yn lle <xliff:g id="current_app">%2$s</xliff:g> fel yr ap SMS?</string>
@@ -1080,10 +1088,6 @@
     <string name="network_scorer_change_active_dialog_title">Newid cynorthwyyd Wi\u2011Fi?</string>
     <string name="network_scorer_change_active_dialog_text">Defnyddio <xliff:g id="new_app">%1$s</xliff:g> yn lle <xliff:g id="current_app">%2$s</xliff:g> i reoli dy gysylltiadau rhwydwaith?</string>
     <string name="network_scorer_change_active_no_previous_dialog_text">Defnyddio <xliff:g id="new_app">%s</xliff:g> i reoli dy gysylltiadau rhwydwaith?</string>
-    <string name="mobile_unknown_sim_operator" translatable="true">Gweithredwr SIM anhysbys</string>
-    <string name="mobile_no_provisioning_url">Nid oes gan <xliff:g id="operator">%1$s</xliff:g> unrhyw wefan darpariaethu hysbys</string>
-    <string name="mobile_insert_sim_card" translatable="true">Gosoda gerdyn SIM ac yna ailddechrau</string>
-    <string name="mobile_connect_to_internet" translatable="true">Cysyllta â\'r rhyngrwyd</string>
     <string name="location_category_recent_location_requests">Ceisiadau diweddar am leoliad</string>
     <string name="managed_profile_location_switch_title">Lleoliad ar gyfer proffil gwaith</string>
     <string name="location_app_level_permissions">Caniatâd apiau i gael at leoliad</string>
@@ -1482,7 +1486,6 @@
     <string name="accessibility_magnification_switch_shortcut_negative_button">Defnyddio tap triphlyg</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button">Diddymu</string>
     <string name="accessibility_magnification_service_settings_title">Gosodiadau chwyddhad</string>
-    <string name="accessibility_screen_magnification_gestures_title">Chwyddo wrth dapio teirgwaith</string>
     <string name="accessibility_screen_magnification_navbar_title">Chwyddo gyda llwybr byr</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture">Chwyddo gyda llwybr byr a thap triphlyg</string>
     <string name="accessibility_introduction_title">Ynghylch <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
@@ -1583,8 +1586,8 @@
     <string name="accessibility_control_timeout_footer_learn_more_content_description">Dysgu rhagor am amser i weithredu (terfyn amser hygyrchedd)</string>
     <string name="accessibility_control_timeout_preference_title">Cyfnod i weithredu</string>
     <string name="accessibility_long_press_timeout_preference_title">Oediad cyffwrdd a dal</string>
-    <string name="accessibility_display_inversion_preference_title">Gwrthdroad lliwiau</string>
-    <string name="accessibility_display_inversion_switch_title">Defnyddio gwrthdroad lliwiau</string>
+    <string name="accessibility_display_inversion_preference_title">Gwrthdroi lliwiau</string>
+    <string name="accessibility_display_inversion_switch_title">Defnyddio gwrthdroi lliwiau</string>
     <string name="accessibility_display_inversion_shortcut_title">Llwybr byr i wrthdroi lliwiau</string>
     <string name="accessibility_autoclick_preference_title">Awtoglicio (amser trigo)</string>
     <string name="accessibility_autoclick_short_title">Byr</string>
@@ -1689,23 +1692,18 @@
     <string name="accessibility_service_action_perform_description">Gall tracio dy ryngweithiadau gydag ap neu galedwedd synhwyro a rhyngweithio gydag ap ar dy ran.</string>
     <string name="accessibility_dialog_button_allow">Caniatáu</string>
     <string name="accessibility_dialog_button_deny">Gwrthod</string>
-    <string name="accessibility_dialog_button_stop">Stopio</string>
-    <string name="accessibility_dialog_button_cancel">Diddymu</string>
-    <string name="disable_service_title">Stopio <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
-    <string name="disable_service_message">Bydd tapio <xliff:g id="stop" example="Stop">%1$s</xliff:g> yn stopio <xliff:g id="service" example="TalkBack">%2$s</xliff:g>.</string>
+    <string name="accessibility_dialog_button_stop">Troi i ffwrdd</string>
     <string name="accessibility_no_services_installed">Dim gwasanaeth wedi\'i osod</string>
     <string name="accessibility_no_service_selected">Dim gwasanaeth wedi\'i ddewis</string>
     <string name="accessibility_service_default_description">Dim disgrifiad wedi\'i gynnig.</string>
     <string name="settings_button">Gosodiadau</string>
     <string name="keywords_reduce_bright_colors">sensitifrwydd golau, thema tywyll, cur pen, dolur pen, meigryn, migraine, modd darllen, modd nos, lleihau disgleirdeb, pwynt gwyn</string>
-    <string name="keywords_accessibility">defnydd hawdd, mynediad hawdd, hygyrchedd, cymorth, cynorthwyydd</string>
     <string name="keywords_magnification">chwyddwr ffenestr, chwyddo, mawrygu, mwyhau, gwneud yn fwy, nam golwg,</string>
     <string name="keywords_live_caption">capsiynau, isdeitlau, CC, trawsgrifio byw, cymorth clyw, colli clyw, CART, llafar i destun, isdeitl</string>
     <string name="keywords_display_size">maint sgrin, sgrin mawr</string>
     <string name="keywords_bold_text">cyferbyniad uchel, golwg isel, nam ar y golwg, ffont trwm, ffont bras</string>
     <string name="keywords_color_correction">addasu\'r lliw </string>
     <string name="keywords_color_inversion">troi\'r sgrin yn dywyll, troi\'r sgrin yn golau</string>
-    <string name="keywords_auto_click">motor, llygoden</string>
     <string name="keywords_rtt">cymorth clyw, trwm fy nghlyw, trwm ei glyw, trwm ei chlyw, trwm y clyw, nam ar y clyw, teclyn clyw, colli clyw, capsiynau, isdeitlau, tty</string>
     <string name="print_settings">Argraffu</string>
     <string name="print_settings_summary_no_service">I ffwrdd</string>
@@ -1740,11 +1738,13 @@
             - <xliff:g id="status">%2$s</xliff:g></string>
     <string name="power_discharge_remaining"><xliff:g id="remain">%1$s</xliff:g> yn weddill</string>
     <string name="power_charge_remaining"><xliff:g id="until_charged">%1$s</xliff:g> i wefru</string>
+    <string name="power_usage_detail_screen_time">Amser sgrin</string>
     <string name="low_battery_summary">Batri isel</string>
     <string name="background_activity_summary">Caniatáu i\'r ap hwn redeg yn y cefndir</string>
     <string name="background_activity_warning_dialog_title">Cyfyngu gweithgarwch yn y cefndir?</string>
     <string name="background_activity_warning_dialog_text">Os wyt yn cyfyngu gweithgaredd cefndir ap mi all ymddwyn yn wahanol i\'r disgwyl.</string>
     <string name="background_activity_disabled_dialog_text">Gan nad yw\'r ap hwn wedi\'i osod i optimeiddio defnydd batri, gellir ei gyfyngu.\n\nI gyfyngu\'r ap, rhaid yn gyntaf troi optimeiddiad batri ymlaen.</string>
+    <string name="manager_battery_usage_category_title">Rheoli defnydd batri</string>
     <string name="manager_battery_usage_unrestricted_title">Dim cyfyngu</string>
     <string name="manager_battery_usage_optimized_title">Defnydd optimaidd</string>
     <string name="manager_battery_usage_restricted_title">Wedi\'i rhwystro</string>
@@ -1951,8 +1951,6 @@
     <string name="emergency_tone_title">Signal deialu mewn argyfwng</string>
     <string name="emergency_tone_summary">Gosod yr ymddygiad ar gyfer pan fo galwad brys yn cael ei wneud</string>
     <string name="privacy_settings_title">Copi wrth gefn</string>
-    <string name="backup_summary_state_on">Ymlaen</string>
-    <string name="backup_summary_state_off">I ffwrdd</string>
     <string name="backup_section_title">Cadw copi wrth gefn ac adfer</string>
     <string name="personal_data_section_title">Data personol</string>
     <string name="backup_data_title">Creu copi wrth gefn o fy nata</string>
@@ -2086,27 +2084,18 @@
     <string name="vpn_name">Enw</string>
     <string name="vpn_type">Math</string>
     <string name="vpn_server">Cyfeiriad gweinydd</string>
-    <string name="vpn_mppe">Amgryptiad PPP (MPPE)</string>
-    <string name="vpn_l2tp_secret">Cyfrinach L2TP</string>
     <string name="vpn_ipsec_identifier">Adnabyddydd IPSec</string>
     <string name="vpn_ipsec_secret">Allwedd IPSec a rannwyd ymlaen llaw</string>
     <string name="vpn_ipsec_user_cert">Tystysgrif defnyddiwr IPSec</string>
     <string name="vpn_ipsec_ca_cert">Tystysgrif CA IPSec</string>
     <string name="vpn_ipsec_server_cert">Tystysgrif gweinydd IPSec</string>
     <string name="vpn_show_options">Dangos dewisiadau uwch</string>
-    <string name="vpn_search_domains">Parthau chwilio DNS</string>
-    <string name="vpn_dns_servers">Gweinyddion DNS (e.g. 8.8.8.8)</string>
-    <string name="vpn_routes">Llywbrau dargyfeirio (e.e. 10.0.0.0/8)</string>
     <string name="vpn_username">Enw defnyddiwr</string>
     <string name="vpn_password">Cyfrinair</string>
     <string name="vpn_save_login">Cadw gwybodaeth y cyfrif</string>
     <string name="vpn_not_used">(heb ei ddefnyddio)</string>
     <string name="vpn_no_ca_cert">(peidio â gwirio\'r gweinydd)</string>
     <string name="vpn_no_server_cert">(derbyniwyd gan y gweinydd)</string>
-    <string name="vpn_always_on_invalid_reason_type">Ni all y math hwn o VPN aros wedi\'i gysylltu o hyd</string>
-    <string name="vpn_always_on_invalid_reason_server">Dyw VPN ymlaen-o-hyd ond yn gweithio gyda gweinyddion a chyfeiriadau rhifol</string>
-    <string name="vpn_always_on_invalid_reason_no_dns">Rhaid rhoi gweinydd DNS ar gyfer VPN ymlaen-o-hyd</string>
-    <string name="vpn_always_on_invalid_reason_dns">Rhaid bod y cyfeiriad gweinydd DNS ar gyfer VPN ymlaen-o-hyd yn un rhifol</string>
     <string name="vpn_always_on_invalid_reason_other">Dyw\'r wybodaeth a roddwyd ddim yn cefnogi VPN ymlaen-o-hyd</string>
     <string name="vpn_cancel">Diddymu</string>
     <string name="vpn_done">Diystyru</string>
@@ -2243,10 +2232,6 @@
     <string name="amber_alerts_title">Rhybuddion OREN</string>
     <string name="amber_alerts_summary">Derbyn bwletinau am gipio plant</string>
     <string name="repeat_title">Ailadrodd</string>
-    <string name="call_manager_enable_title">Galluogi Rheolwr Galwadau</string>
-    <string name="call_manager_enable_summary">Caniatáu i\'r gwasanaeth hwn reoli sut mae dy alwadau yn cael eu gwneud.</string>
-    <string name="call_manager_title">Rheolwr Galwadau</string>
-    <string name="call_manager_summary"><xliff:g id="app">%1$s</xliff:g></string>
     <string name="cell_broadcast_settings">Rhybuddion argyfwng di-wifr</string>
     <string name="network_operators_settings">Darparwyr rhwydwaith</string>
     <string name="access_point_names">Enwau Pwyntiau Mynediad (APN)</string>
@@ -2372,7 +2357,6 @@
     <string name="keywords_wallet">waled</string>
     <string name="keywords_payment_settings">talu, tapio, taliadau</string>
     <string name="keywords_backup">cadw copi wrth gefn, copi wrth gefn</string>
-    <string name="keywords_assist_gesture_launch">ystum</string>
     <string name="keywords_face_unlock">wyneb, gwyneb, datgloi, mewngofnodi, seinio mewn, dilysu</string>
     <string name="keywords_biometric_unlock">wyneb, datgloi, dilysu, mewngofnodi, ôl bys, bys, ol bys, biometrig, biometric, dilysiad</string>
     <string name="keywords_imei_info">imei, meid, min, versiwn prl, imei sv</string>
@@ -2626,7 +2610,6 @@
     <string name="lock_screen_notifications_summary_show">Dangos holl gynnwys hysbysiadau</string>
     <string name="lock_screen_notifications_summary_hide">Dangos cynnwys sensitif dim ond pan wedi datgloi</string>
     <string name="lock_screen_notifications_summary_disable">Peidio â dangos hysbysiadau o gwbl</string>
-    <string name="lock_screen_notifications_interstitial_message">Sut wyt am i\'r sgrin cloi eu dangos?</string>
     <string name="lock_screen_notifications_interstitial_title">Sgrin cloi</string>
     <string name="lock_screen_notifications_summary_show_profile">Dangos holl gynnwys hysbysiadau gwaith</string>
     <string name="lock_screen_notifications_summary_hide_profile">Cuddio cynnwys gwaith sensitif</string>
@@ -3160,7 +3143,6 @@
     <string name="cell_data_warning">Rhybudd data <xliff:g name="amount" example="1 GB">^1</xliff:g></string>
     <string name="cell_data_limit">Cyfyngiad data <xliff:g name="amount" example="1 GB">^1</xliff:g></string>
     <string name="cell_data_warning_and_limit">Rhybudd data <xliff:g name="amount" example="1 GB">^1</xliff:g> / Terfyn data <xliff:g name="amount" example="2 GB">^2</xliff:g></string>
-    <string name="operator_warning">Mae\'n bosib y bydd cyfrif data\'r darparwr yn wahanol i gyfrif y ddyfais.</string>
     <string name="non_carrier_data_usage_warning">Nid yw\'n cynnwys defnydd data dros rwydweithiau symudol</string>
     <string name="data_used_template"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> wedi ei ddefnyddio</string>
     <string name="set_data_warning">Gosod rhybudd data</string>
@@ -3184,7 +3166,6 @@
     <string name="no_carrier_update_text">Diweddarwyd <xliff:g name="time" example="3m">^2</xliff:g> yn ôl</string>
     <string name="carrier_and_update_now_text">Diweddarwyd gan <xliff:g name="carrier" example="T-mobile">^1</xliff:g> jyst nawr</string>
     <string name="no_carrier_update_now_text">Diweddarwyd jyst nawr</string>
-    <string name="launch_mdp_app_text">Gweld cynllun</string>
     <string name="launch_wifi_text">Gweld manylion</string>
     <string name="data_saver_title">Arbedwr Data</string>
     <string name="unrestricted_data_saver">Data heb derfyn</string>
@@ -3260,7 +3241,6 @@
     <string name="quick_settings_developer_tiles">Teils gosodiadau cyflym datblygwr</string>
     <string name="adb_authorization_timeout_title">Analluogi terfyn amser awdurdodiad adb</string>
     <string name="adb_authorization_timeout_summary">Analluogi dod ag awdurdodiadau ADB i ben yn awtomatig i systemau sydd heb gysylltu o fewn y cyfnod amser rhagosodedig (7 diwrnod) neu dewis y defnyddiwr (o leiaf 1 diwrnod).</string>
-    <string name="winscope_trace_quick_settings_title">Olrhain WinScope</string>
     <string name="sensors_off_quick_settings_title">Synwyryddion i Ffwrdd</string>
     <string name="managed_profile_settings_title">Gosodiadau proffil gwaith</string>
     <string name="cross_profile_calendar_title">Calendr rhyng-broffil</string>
@@ -3482,7 +3462,6 @@
     <string name="prevent_ringing_option_vibrate_summary">Dirgrynu</string>
     <string name="prevent_ringing_option_mute_summary">Distewi</string>
     <string name="pref_title_network_details">Manylion y rhwydwaith</string>
-    <string name="about_phone_device_name_warning">Mae enw dy ddyfais yn weladwy i apiau ar dy ffôn. Mae\'n bosib y bydd hefyd yn weladwy i eraill pan fyddi yn cysylltu â dyfeisiau Bluetooth, yn cysylltu â rhwydwaith Wi-Fi neu\'n creu llecyn Wi-Fi.</string>
     <string name="devices_title">Dyfeisiau</string>
     <string name="choose_network_title">Dewis rhwydwaith</string>
     <string name="network_disconnected">Wedi datgysylltu</string>
@@ -3608,6 +3587,7 @@
     <string name="sim_action_no_thanks">Dim diolch</string>
     <string name="sim_action_cancel">Diddymu</string>
     <string name="sim_switch_button">Newid</string>
+    <string name="sim_action_turn_off">Troi i ffwrdd</string>
     <string name="dsds_activation_failure_title">Methu â gweithredu\'r SIM</string>
     <string name="dsds_activation_failure_body_msg2">Rho gynnig ar droi\'r SIM ymlaen eto. Os yw\'r broblem yn parhau, ail-ddechreua dy ddyfais.</string>
     <string name="sim_switch_channel_id">Yn newid darparwr</string>
@@ -3678,9 +3658,6 @@
     <string name="wfc_disclaimer_emergency_limitation_title_text">Galwadau brys</string>
     <string name="wfc_disclaimer_emergency_limitation_desc_text">Dyw dy ddarparwr gwasanaeth ddim yn cefnogi galwadau brys trwy Galwadau Wi\u2011Fi.\nMae\u2019r ddyfais yn newid yn awtomatig i rwydwaith symudol i wneud galwad brys.\nDyw galwadau brys ond yn bosib ble mae signal symudol ar gael.</string>
     <string name="wifi_calling_summary">Defnyddio Wi\u2011Fi ar gyfer galwadau i wella ansawdd</string>
-    <string name="backup_calling_settings_title">Galw wrth gefn</string>
-    <string name="backup_calling_setting_summary">Os nad yw <xliff:g id="backup_calling_operator_text" example="Google Fi">%1$s</xliff:g> ar gael neu os yn crwydro, defnyddia dy SIM data symudol ar gyfer galwadau <xliff:g id="backup_calling_carrier_text" example="Google Fi">%1$s</xliff:g>.</string>
-    <string name="keywords_backup_calling">galw wrth gefn</string>
     <string name="enable_receiving_mms_notification_title">Neges MMS i mewn</string>
     <string name="enable_sending_mms_notification_title">Methu ag anfon neges MMS</string>
     <string name="enable_mms_notification_summary">Tapia i ganiatáu negesu MMS ar <xliff:g id="operator_name" example="T-Mobile">%1$s</xliff:g> pan fo data symudol i ffwrdd</string>
@@ -3715,7 +3692,6 @@
     <string name="media_controls_title">Cyfryngau</string>
     <string name="media_controls_resume_title">Pinio\u2019r chwaraeydd cyfryngau</string>
     <string name="media_controls_resume_description">I allu barhau i chwarae yn gyflym, mae\u2019r chwaraeydd cyfryngau yn aros ar agor yn Gosodiadau Cyflym</string>
-    <string name="media_controls_recommendations_title">Dangos awgrymiadau cyfryngau</string>
     <string name="media_controls_recommendations_description">Ar sail dy ddefnydd</string>
     <string name="media_controls_hide_player">Cuddio chwaraeydd</string>
     <string name="media_controls_show_player">Dangos chwaraeydd</string>
@@ -3849,4 +3825,17 @@
     <string name="color_selector_dialog_cancel">Diddymu</string>
     <string name="contrast_medium">Canolig</string>
     <string name="contrast_high">Uchel</string>
+    <string name="generic_accessibility_service_on">Ymlaen</string>
+    <string name="generic_accessibility_service_off">I ffwrdd</string>
+    <string name="generic_accessibility_feature_shortcut_off">I ffwrdd</string>
+    <string name="accessibility_shortcut_state_off">I ffwrdd</string>
+    <string name="daltonizer_state_on">Ymlaen</string>
+    <string name="daltonizer_state_off">I ffwrdd</string>
+    <string name="color_inversion_state_on">Ymlaen</string>
+    <string name="color_inversion_state_off">I ffwrdd</string>
+    <string name="autoclick_disabled">I ffwrdd</string>
+    <string name="show_captions_disabled">I ffwrdd</string>
+    <string name="show_captions_enabled">Ymlaen</string>
+    <string name="live_caption_disabled">I ffwrdd</string>
+    <string name="live_caption_enabled">Ymlaen</string>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-eo/strings.xml b/overlay/packages/apps/Settings/res/values-eo/strings.xml
index a93e588..3ab3529 100644
--- a/overlay/packages/apps/Settings/res/values-eo/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-eo/strings.xml
@@ -35,9 +35,13 @@
     <string name="location_settings_title">Loko</string>
     <string name="security_settings_face_enroll_introduction_cancel">Nuligi</string>
     <string name="security_settings_fingerprint_enroll_introduction_cancel">Nuligi</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Nuligi</string>
     <string name="cancel_lock_screen_dialog_button_label">Nuligi</string>
     <string name="security_settings_fingerprint_enroll_dialog_name_label">Nomo</string>
     <string name="security_settings_fingerprint_enroll_dialog_delete">Forigi</string>
+    <string name="private_space_category_system">Sistemo</string>
+    <string name="no_device_lock_cancel">Nuligi</string>
+    <string name="private_space_cancel_label">Nuligi</string>
     <string name="unlock_set_unlock_password_title">Pasvorto</string>
     <string name="unlock_set_unlock_mode_password">Pasvorto</string>
     <string name="unlock_disable_frp_warning_ok">Forigi</string>
@@ -88,7 +92,6 @@
     <string name="accessibility_button_location_title">Loko</string>
     <string name="accessibility_menu_item_settings">Agordoj</string>
     <string name="captioning_locale">Lingvo</string>
-    <string name="accessibility_dialog_button_cancel">Nuligi</string>
     <string name="settings_button">Agordoj</string>
     <string name="print_menu_item_settings">Agordoj</string>
     <string name="print_menu_item_add_printers">Aldoni presilojn</string>
diff --git a/overlay/packages/apps/Settings/res/values-fur-rIT/arrays.xml b/overlay/packages/apps/Settings/res/values-fur-rIT/arrays.xml
index ef13dd1..80a6ad2 100644
--- a/overlay/packages/apps/Settings/res/values-fur-rIT/arrays.xml
+++ b/overlay/packages/apps/Settings/res/values-fur-rIT/arrays.xml
@@ -89,6 +89,11 @@
         <item>4</item>
         <item>5</item>
     </string-array>
+    <string-array name="bluetooth_audio_routing_titles">
+        <item>Dopre la aplicazion predefinide</item>
+        <item>Riprodûs sul aparât acustic</item>
+        <item>Riprodûs su la casse dal telefon</item>
+    </string-array>
     <string-array name="wifi_signal">
         <item>Scjarse</item>
         <item>Scjarse</item>
@@ -490,4 +495,19 @@
         <item>625000</item>
         <item>1875000</item>
         </string-array>
+    <string-array name="temperature_units">
+        <item>default</item>
+        <item>celsius</item>
+        <item>fahrenhe</item>
+    </string-array>
+    <string-array name="first_day_of_week">
+        <item>default</item>
+        <item>sun</item>
+        <item>mon</item>
+        <item>tue</item>
+        <item>wed</item>
+        <item>thu</item>
+        <item>fri</item>
+        <item>sat</item>
+    </string-array>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Settings/res/values-fur-rIT/strings.xml
index f46d313..d735905 100644
--- a/overlay/packages/apps/Settings/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-fur-rIT/strings.xml
@@ -21,6 +21,11 @@
     <string name="deny">Dinee</string>
     <string name="confirmation_turn_on">Ative</string>
     <string name="device_info_default">No cognossût</string>
+    <string name="device_info_protected_single_press">Tocje par mostrâ informazions</string>
+    <string name="show_dev_countdown">{count, plural,
+      one {}=1      {Ti mancje # passaç par deventâ un svilupadôr.}
+      other   {Ti mancjin # passaçs par deventâ un svilupadôr.}
+    }</string>
     <string name="show_dev_on">Cumò tu sês un svilupadôr!</string>
     <string name="show_dev_already">Nol covente, tu sês za un svilupadôr.</string>
     <string name="dev_settings_disabled_warning">Abilite prime lis opzions di svilupadôr.</string>
@@ -39,7 +44,11 @@
     <string name="font_size_make_smaller_desc">Rint plui piçul</string>
     <string name="font_size_make_larger_desc">Rint plui grant</string>
     <string name="stay_awake_on_fold_title">Simpri</string>
+    <string name="stay_awake_on_fold_summary">Il schermi frontâl si ative cuant che tu sieris il to dispositîf</string>
+    <string name="selective_stay_awake_title">Dome zûcs, videos e altri</string>
+    <string name="selective_stay_awake_summary">Il schermi frontâl si ative pes aplicazions che a impedissin al schermi di distudâsi</string>
     <string name="sleep_on_fold_title">Mai</string>
+    <string name="sleep_on_fold_summary">Il schermi frontâ si bloche cuant che tu sieris il to dispositîf</string>
     <string name="auto_rotate_settings_primary_switch_title">Dopre rotazion automatiche</string>
     <string name="smart_rotate_text_headline">Il rilevament de muse al dopre la fotocjamare frontâl par miorâ la precision de rotazion automatiche. Lis imagjins no vegnin mai archiviadis o mandadis a Google.</string>
     <string name="bluetooth">Bluetooth</string>
@@ -57,10 +66,23 @@
     <string name="bluetooth_pair_right_ear_button">Associe orele diestre</string>
     <string name="bluetooth_pair_left_ear_button">Associe orele çampe</string>
     <string name="bluetooth_pair_other_ear_dialog_title">Associe chê altre orele</string>
+    <string name="bluetooth_pair_other_ear_dialog_left_ear_message">Il to dispospositîf pe scolte di çampe al è conetût.\n\nPar associâ chel di diestre, controle che al sedi impiât e pront par associâsi.</string>
+    <string name="bluetooth_pair_other_ear_dialog_right_ear_message">Il to dispositîf pe scolte di diestre al è conetût.\n\nPar associâ chel di çampe, controle che al sedi impiât e pront par associâsi.</string>
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button">Associe orele diestre</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button">Associe orele çampe</string>
+    <string name="bluetooth_device_controls_general">Par ducj i dispositîfs pe scolte</string>
+    <string name="bluetooth_device_controls_title">Impostazions dispositîfs pe scolte</string>
+    <string name="bluetooth_device_controls_summary">Scurte, compatibilitât aparâts acutstics</string>
+    <string name="bluetooth_device_controls_specific">Par chest dispositîf</string>
+    <string name="bluetooth_audio_routing_title">Jessude audio</string>
+    <string name="bluetooth_audio_routing_about_title">Informazions su jessude audio</string>
+    <string name="bluetooth_audio_routing_summary">Indrece i suns al to dispositîf pe scolte o ae casse dal telefon</string>
     <string name="bluetooth_screen_related">Corelâts</string>
+    <string name="bluetooth_ringtone_title">Sunarie e sveis</string>
+    <string name="bluetooth_call_title">Audio des clamadis</string>
     <string name="bluetooth_media_title">Contignûts multimediâi</string>
+    <string name="bluetooth_system_sounds_title">Notifichis e altris suns di sisteme</string>
+    <string name="bluetooth_audio_routing_footer_summary">Come impostazion predefinide, la jessude audio e ven determinade da lis singulis aplicazions</string>
     <string name="bluetooth_device">Dispositîf Bluetooth cence non</string>
     <string name="progress_scanning">Daûr a cirî</string>
     <string name="bluetooth_no_devices_found">Nol è stât cjatât nissun dispositîf Bluetooth tai contors.</string>
@@ -89,6 +111,9 @@
     <string name="bluetooth_disable_hw_offload_dialog_message">Tu scugnis tornâ a inviâ il dispositîf par cambiâ cheste impostazion.</string>
     <string name="bluetooth_disable_hw_offload_dialog_confirm">Torne invie</string>
     <string name="bluetooth_disable_hw_offload_dialog_cancel">Anule</string>
+    <string name="bluetooth_disable_leaudio">Disative Audio LE Bluetooth</string>
+    <string name="bluetooth_disable_leaudio_summary">Al disative la funzion Bluetooth audio LE se il dispositîf al supuarte lis capacitâts hardware dal audio LE.</string>
+    <string name="bluetooth_show_leaudio_device_details">Mostre interutôr audio LE in Detais dispositîf</string>
     <string name="connected_device_media_device_title">Dispositîfs multimediâi</string>
     <string name="connected_device_call_device_title">Dispositîfs di clamade</string>
     <string name="connected_device_other_device_title">Altris dispositîfs</string>
@@ -98,6 +123,13 @@
     <string name="connected_device_previously_connected_screen_title">Conetûts in precedence</string>
     <string name="connected_device_bluetooth_turned_on_toast">Bluetooth ativât</string>
     <string name="previous_connected_see_all">Viôt ducj</string>
+    <string name="connected_device_fast_pair_device_see_all">Viôt ducj</string>
+    <string name="stylus_device_details_title">Pene</string>
+    <string name="stylus_default_notes_app">Pression boton di insom</string>
+    <string name="stylus_default_notes_summary_work"><xliff:g id="app_name" example="Mail">%s</xliff:g> (Profîl di lavôr)</string>
+    <string name="stylus_textfield_handwriting">Scrît tai cjamps di test</string>
+    <string name="stylus_ignore_button">Ignore dutis lis pressions dal boton de pene</string>
+    <string name="stylus_connected_devices_title">Pene</string>
     <string name="date_and_time">Date e ore</string>
     <string name="proxy_settings_title">Proxy</string>
     <string name="proxy_clear_text">Nete</string>
@@ -121,25 +153,59 @@
     <string name="skip_label">Salte</string>
     <string name="next_label">Indenant</string>
     <string name="language_picker_title">Lenghis</string>
+    <string name="language_picker_category_title">Ordin des lenghis preferidis</string>
     <string name="desc_current_default_language">Lenghe di sisteme</string>
     <string name="locale_remove_menu">Gjave</string>
     <string name="add_a_language">Zonte une lenghe</string>
     <string name="app_locale_preference_title">Lenghe</string>
     <string name="locale_picker_category_title">Lenghe preferide</string>
+    <string name="app_locales_picker_menu_title">Lenghis des aplicazions</string>
     <string name="app_locale_picker_summary">Stabilìs la lenghe par ogni aplicazion</string>
+    <string name="app_locale_picker_title">Lenghe de aplicazion</string>
     <string name="suggested_app_locales_title">Lenghis sugjeridis</string>
     <string name="all_supported_app_locales_title">Dutis lis lenghis</string>
     <string name="preference_of_system_locale_title">Lenghe di sisteme</string>
     <string name="preference_of_system_locale_summary">Predefinît di sisteme</string>
     <string name="desc_no_available_supported_locale">La selezion de lenghe par cheste aplicazion no je disponibile di Impostazions.</string>
     <string name="desc_app_locale_disclaimer">La lenghe e podarès jessi divierse di chês disponibilis te aplicazion. Al è pussibil che cualchi aplicazion no supuarti cheste impostazion.</string>
+    <string name="desc_app_locale_selection_supported">Stabilìs la lenghe par ogni aplicazion.</string>
+    <string name="desc_introduction_of_language_picker">Il to sisteme, lis aplicazions e i sîts web a doprin la prime lenghe supuartade di chês preferidis.</string>
+    <string name="desc_notice_of_language_picker">Par selezionâ une lenghe par ogni aplicazion, va tes impostazions de lenghe de aplicazion.</string>
+    <string name="desc_locale_helper_footer_general">Plui informazions su lis lenghis des aplicazions</string>
+    <string name="title_change_system_locale">Cambiâ la lenghe di sisteme a %s ?</string>
+    <string name="desc_notice_device_locale_settings_change">A cambiaran lis impostazions dal dispositîf e lis preferencis regjonâls.</string>
     <string name="button_label_confirmation_of_system_locale_change">Cambie</string>
+    <string name="title_unavailable_locale">%s no disponibil</string>
+    <string name="desc_unavailable_locale">Nol è pussibil doprâ cheste lenghe tant che lenghe di sisteme, ma cussì tu fasis savê a aplicazions e sîts web che tu preferissis cheste lenghe.</string>
+    <string name="regional_preferences_title">Preferencis regjonâls</string>
+    <string name="regional_preferences_summary">Stabilìs preferencis su unitâts e numars</string>
+    <string name="regional_preferences_main_page_sub_title">Fâs savê aes aplicazions lis tôs preferencis regjonâls cussì a puedin personalizâ la esperience di utilizazion.</string>
+    <string name="regional_preferences_option_page_sub_title">Lis aplicazions a dopraran lis tôs preferencis regjonâls se pussibil.</string>
+    <string name="temperature_preferences_title">Temperadure</string>
+    <string name="first_day_of_week_preferences_title">Prin dì de setemane</string>
+    <string name="numbers_preferences_title">Preferencis pai numars</string>
     <string name="default_string_of_regional_preference">Dopre la aplicazion predefinide</string>
+    <string name="celsius_temperature_unit">Celsius (\u00B0C)</string>
+    <string name="fahrenheit_temperature_unit">Fahrenheit (\u00B0F)</string>
+    <string name="sunday_first_day_of_week">Domenie</string>
+    <string name="monday_first_day_of_week">Lunis</string>
+    <string name="tuesday_first_day_of_week">Martars</string>
+    <string name="wednesday_first_day_of_week">Miercus</string>
+    <string name="thursday_first_day_of_week">Joibe</string>
+    <string name="friday_first_day_of_week">Vinars</string>
+    <string name="saturday_first_day_of_week">Sabide</string>
+    <string name="title_regional_pref_footer">Se une aplicazion no supuarte lis preferencis regjonâls, la aplicazion e doprarà lis sôs impostazions di localizazion predefinidis.</string>
+    <string name="desc_regional_pref_footer_learn_more">Scuvierç di plui su lis preferencis relativis ae lenghe.</string>
+    <string name="dlg_remove_locales_title">{count, plural,
+      one {}=1      {Gjavâ la lenghe selezionade?}
+      other   {Gjavâ lis lenghis selezionadis?}
+    }</string>
     <string name="dlg_remove_locales_message">Il test al vignarà visualizât intune altre lenghe.</string>
     <string name="dlg_remove_locales_error_title">Impussibil gjavâ dutis lis lenghis</string>
     <string name="dlg_remove_locales_error_message">Ten almancul une lenghe preferide</string>
-    <string name="action_drag_label_move_up">Môf in sù</string>
-    <string name="action_drag_label_move_down">Môf in jù</string>
+    <string name="locale_not_translated">No disponibil tant che lenghe di sisteme</string>
+    <string name="action_drag_label_move_up">Môf insù</string>
+    <string name="action_drag_label_move_down">Môf injù</string>
     <string name="action_drag_label_move_top">Môf insom</string>
     <string name="action_drag_label_move_bottom">Môf da pît</string>
     <string name="action_drag_label_remove">Gjave la lenghe</string>
@@ -163,6 +229,8 @@
     <string name="roaming_disable">Conet ai servizis di dâts in roaming</string>
     <string name="roaming_warning">A podaressin vignî contizâts coscj pal roaming.</string>
     <string name="date_time_auto">Stabilìs la ore in automatic</string>
+    <string name="zone_auto_title">Stabilìs in automatic</string>
+    <string name="auto_zone_requires_location_summary">Se chest interutôr al è atîf, la posizion e vignarà doprade par stabilî il fûs orari</string>
     <string name="date_time_24hour_auto">Dopre impostazions locâls predefinidis</string>
     <string name="date_time_24hour">Dopre formât 24 oris</string>
     <string name="date_time_set_time_title">Ore</string>
@@ -175,6 +243,8 @@
     <string name="date_time_select_fixed_offset_time_zones">Selezione la variazion dal UTC</string>
     <string name="zone_info_exemplar_location_and_offset"><xliff:g id="exemplar_location" example="Los Angeles">%1$s</xliff:g> (<xliff:g id="offset" example="GMT-08:00">%2$s</xliff:g>)</string>
     <string name="zone_info_offset_and_name"><xliff:g id="time_type" example="Pacific Time">%2$s</xliff:g> (<xliff:g id="offset" example="GMT-08:00">%1$s</xliff:g>)</string>
+    <string name="zone_info_footer_first_sentence">Al dopre <xliff:g id="offset_and_name" example="Pacific Time (GMT-08:00)">%1$s</xliff:g>. <xliff:g id="second_sentence" example="Pacific Daylight Time starts on Mar 11 2018.">%2$s</xliff:g></string>
+    <string name="zone_info_footer_second_sentence"><xliff:g id="dst_time_type" example="Pacific Daylight Time">%1$s</xliff:g> al scomence al/ai <xliff:g id="transition_date" example="Mar 11 2018">%2$s</xliff:g>.</string>
     <string name="zone_info_footer_no_dst">Al dopre <xliff:g id="offset_and_name" example="GMT-08:00 Pacific Time">%1$s</xliff:g>. Nissune ore legâl.</string>
     <string name="zone_time_type_dst">Ore legâl</string>
     <string name="zone_time_type_standard">Ore solâr</string>
@@ -197,8 +267,6 @@
     <string name="location_settings_footer_location_off">        L\'acès ae posizion al è disativât par aplicazions e servizis. Al sarà ancjemò pussibil
         inviâ la tô posizion ai interlocutôrs des emergjencis cuant che tu clamis o tu mandis un messaç a un numar di emergjence.
     </string>
-    <string name="location_settings_footer_learn_more_content_description">        Scuvierç di plui su lis impostazions di gjeolocalizazion.
-    </string>
     <string name="account_settings_title">Accounts</string>
     <string name="security_settings_title">Sigurece</string>
     <string name="encryption_and_credential_settings_title">Cifradure e credenziâls</string>
@@ -210,6 +278,7 @@
     <string name="safety_center_title">Sigurece e riservatece</string>
     <string name="safety_center_summary">Sigurece de aplicazion, bloc dal dispositîf, permès</string>
     <string name="security_settings_face_preference_summary">Muse zontade</string>
+    <string name="security_settings_face_preference_summary_none">Configurazion necessarie</string>
     <string name="security_settings_face_preference_title">Sbloc cu la muse</string>
     <string name="security_settings_face_profile_preference_title">Sbloc cu la muse par lavôr</string>
     <string name="security_settings_face_enroll_education_title">Cemût configurâ il sbloc cu la muse</string>
@@ -257,12 +326,19 @@
     <string name="security_settings_face_settings_remove_dialog_title">Eliminâ il model di muse?</string>
     <string name="security_settings_face_settings_remove_dialog_details">Il to model di muse al vignarà eliminât par simpri e in sigurece.\n\nDopo de rimozion ti coventarà il PIN, la cumbinazion o la password par sblocâ il to telefon o par autenticâti tes aplicazions.</string>
     <string name="security_settings_face_settings_remove_dialog_details_convenience">Il to model di muse al vignarà eliminât par simpri e in sigurece.\n\nDopo de rimozion ti coventarà il PIN, la cumbinazion o la password par sblocâ il to telefon.</string>
+    <string name="security_settings_face_remove_dialog_details_fingerprint">Il to model di muse al vignarà eliminât par simpri e in sigurece.\n\nDopo de rimozion ti coventarà l\'impront, il PIN, la cumbinazion o la password par sblocâ il to telefon o par autenticâti tes aplicazions.</string>
+    <string name="security_settings_face_remove_dialog_details_fingerprint_conv">Il to model di muse al vignarà eliminât par simpri e in sigurece.\n\nDopo de rimozion ti coventarà l\'impront, il PIN, la cumbinazion o la password par sblocâ il to telefon.</string>
     <string name="security_settings_face_settings_context_subtitle">Dopre il sbloc cu la muse par sblocâ il to telefon</string>
     <string name="security_settings_fingerprint">Impront digjitâl</string>
     <string name="security_settings_fingerprint_preference_title">Impront digjitâl</string>
     <string name="security_settings_fingerprint_settings_preferences_category">Cuant che tu dopris il sbloc cul impront</string>
     <string name="security_settings_work_fingerprint_preference_title">Impront pal lavôr</string>
     <string name="fingerprint_add_title">Zonte impront</string>
+    <string name="security_settings_fingerprint_preference_summary">{count, plural,
+      one {}=1      {Impront zontât}
+      other   {# impronts zontâts}
+    }</string>
+    <string name="security_settings_fingerprint_preference_summary_none">Configurazion necessarie</string>
     <string name="security_settings_fingerprint_enroll_introduction_title">Stabilìs il to impront</string>
     <string name="security_settings_fingerprint_enroll_consent_introduction_title">Permet il sbloc cul impront</string>
     <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled">Dopre il to impront digjitâl</string>
@@ -284,9 +360,10 @@
     <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6">Par vê risultâts otimâi, dopre une protezion pal schermi cu la certificazion Made for Google. Cun altris protezions pal schermi, al è pussibil che l\'impront no funzioni.</string>
     <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6">Par vê risultâts otimâi, dopre une protezion pal schermi cu la certificazion Made for Google. Cun altris protezions pal schermi, al è pussibil che l\'impront di to fi no funzioni.</string>
     <string name="security_settings_activeunlock_preference_title">Sbloc cul orloi</string>
-    <string name="biometric_settings_intro_with_activeunlock">Cuant che tu configuris il sbloc cu la muse e il sbloc cul impront, il telefon ti domandarà l\'impront cuant che tu metis une mascare o tu sês intun ambient scûr.\n\nTu puedis sblocâ cul orloi cuant che la tô muse o l\u2019impront no vegnin ricognossûts.</string>
-    <string name="biometric_settings_intro_with_fingerprint">Tu puedis sblocâ cul orloi cuant che l\u2019impront nol ven ricognossût.</string>
-    <string name="biometric_settings_intro_with_face">Tu puedis sblocâ cul orloi cuant che la muse no ven ricognossude.</string>
+    <string name="biometric_settings_use_fingerprint_or_watch_for"> Dopre l\'impront o l\'orloi par</string>
+    <string name="biometric_settings_use_face_or_watch_for"> Dopre la muse o l\'orloi par</string>
+    <string name="biometric_settings_use_face_fingerprint_or_watch_for"> Use la muse, l\'impront o l\'orloi par</string>
+    <string name="biometric_settings_use_watch_for"> Dopre l\'orloi par</string>
     <string name="biometric_settings_use_face_or_watch_preference_summary">Cun muse o orloi</string>
     <string name="biometric_settings_use_fingerprint_or_watch_preference_summary">Cun impront o orloi</string>
     <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary">Cun muse, impront o orloi</string>
@@ -303,17 +380,33 @@
     <string name="security_settings_face_watch_preference_summary">Muse e <xliff:g id="watch" example="Dani\'s Watch">%s</xliff:g> zontâts</string>
     <string name="security_settings_fingerprint_single_face_watch_preference_summary">Muse, impront e <xliff:g id="watch" example="Dani\'s Watch">%s</xliff:g> zontâts</string>
     <string name="security_settings_fingerprint_multiple_face_watch_preference_summary">Muse, impronts e <xliff:g id="watch" example="Dani\'s Watch">%s</xliff:g> zontâts</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">No cumò</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">Continue</string>
+    <string name="security_settings_remoteauth_enroll_introduction_more">Altri</string>
+    <string name="security_settings_remoteauth_enroll_introduction_how_title">Cemût funzionial?</string>
+    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title">Tu sês tu a vê il control</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Anule</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">Conferme</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">Fat</string>
+    <string name="security_settings_remoteauth_settings_title">Sbloc cul orloi</string>
+    <string name="security_settings_biometric_preference_title">Sbloc cul impront e cu la muse</string>
     <string name="security_settings_work_biometric_preference_title">Sbloc cu la muse e cul impront par lavôr</string>
+    <string name="security_settings_biometric_preference_summary_none_enrolled">Configurazion necessarie</string>
     <string name="security_settings_biometric_preference_summary_both_fp_multiple">Muse e impronts zontâts</string>
     <string name="security_settings_biometric_preference_summary_both_fp_single">Muse e impront zontâts</string>
     <string name="biometric_settings_intro">Cuant che tu configuris il sbloc cu la muse e cul impront, il telefon ti domandarà l\'impront se tu âs intôr une mascare o tu sês in une zone scure</string>
     <string name="biometric_settings_category_ways_to_unlock">Manieris par sbocâ</string>
+    <string name="biometric_settings_category_use_face_fingerprint">Dopre la muse o l\'impront par</string>
     <string name="biometric_settings_use_biometric_unlock_phone">Sbloche il telefon</string>
     <string name="biometric_settings_use_biometric_for_apps">Verifiche de tô identitât tes aplicazions</string>
     <string name="biometric_settings_use_face_preference_summary">Cu la muse</string>
     <string name="biometric_settings_use_fingerprint_preference_summary">Cul impront</string>
     <string name="biometric_settings_use_face_or_fingerprint_preference_summary">Cun muse o impront</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">Va ben</string>
+    <string name="biometric_settings_add_face_in_split_mode_title">Impussibil configurâ il sbloc cu la muse</string>
+    <string name="biometric_settings_add_face_in_split_mode_message">Jes dal schermi dividût par configurâ il sbloc cu la muse</string>
+    <string name="biometric_settings_add_fingerprint_in_split_mode_title">Impussibil configurâ l\'impront</string>
+    <string name="biometric_settings_add_fingerprint_in_split_mode_message">Jes dal schermi dividût par configurâ il sbloc cul impront</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">Va ben</string>
     <string name="lock_screen_intro_skip_title">Ignorâ il bloc dal schermi?</string>
     <string name="skip_anyway_button_label">Salte di istès</string>
@@ -363,6 +456,7 @@
     <string name="security_settings_udfps_side_fingerprint_help">Poie un flanc dal impront sul sensôr e ten fracât, dopo passe a chel altri flanc</string>
     <string name="setup_fingerprint_enroll_enrolling_skip_title">Saltâ la configurazion dal impront?</string>
     <string name="setup_fingerprint_enroll_enrolling_skip_message">Tu âs sielt di doprâ il to impront digjitâl come une des manieris par sblocâ il to telefon. Se cumò tu saltis cheste configurazion tu le varâs di fâ plui indenant. La configurazion e puarte vie sù par jù dome un minût.</string>
+    <string name="lock_screen_skip_setup_title">Saltâ la configurazion di <xliff:g id="options" example="PIN • Face • Fingerprint">%s</xliff:g></string>
     <string name="lock_screen_pin_skip_title">Saltâ la configurazion dal PIN?</string>
     <string name="lock_screen_pin_skip_face_title">Saltâ la configurazion par PIN e muse?</string>
     <string name="lock_screen_pin_skip_fingerprint_title">Saltâ la configurazion par PIN e impront?</string>
@@ -379,20 +473,43 @@
     <string name="security_settings_fingerprint_enroll_done">Fat</string>
     <string name="security_settings_fingerprint_enroll_touch_dialog_title">Folc ti trai! Chel nol è il sensôr</string>
     <string name="security_settings_fingerprint_enroll_touch_dialog_message">Tocje il sensôr daûr dal to telefon. Dopre il to dêt indiç.</string>
+    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title">Impussibil completâ la config. dal impront</string>
+    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup">Tu puedis tornâ a provâ daurman o configurâ l\'impront plui indevant tes Impostazions.</string>
+    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message">Tu puedis tornâ a provâ daurman o configurâ l\'impront plui indevant.</string>
     <string name="security_settings_fingerprint_enroll_error_dialog_title">Configurazion impront scjadude</string>
+    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup">Tu puedis configurâ l\'impront plui indevant tes Impostazions.</string>
+    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup">Alc al è lât strucj. Tu puedis configurâ l\'impront plui indevant tes Impostazions.</string>
+    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message">Tu puedis configurâ l\'impront plui indevant.</string>
+    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message">Alc al è lât strucj. Tu puedis configurâ l\'impront plui indevant.</string>
     <string name="fingerprint_enroll_button_add">Zonte un altri</string>
     <string name="fingerprint_enroll_button_next">Indenant</string>
     <string name="security_fingerprint_disclaimer_lockscreen_disabled_1">La opzion dal bloc schermi e je disativade. Par savênt di plui, contate l\u2019aministradôr de tô organizazion.</string>
     <string name="security_fingerprint_disclaimer_lockscreen_disabled_2">Tu puedis ancjemò doprâ l\'impront par autorizâ compris e l\'acès pes aplicazions.</string>
     <string name="security_settings_fingerprint_enroll_lift_touch_again">Alce il dêt, dopo torne tocje il sensôr</string>
+    <string name="security_settings_fingerprint_bad_calibration_title">Impussibil doprâ il sensôr di impront</string>
+    <string name="security_settings_fingerprint_bad_calibration">Contate un riparadôr.</string>
     <string name="security_advanced_settings">Altris impostazions di sigurece</string>
     <string name="security_advanced_settings_work_profile_settings_summary">Bloc dal profîl di lavôr, cifradure e altri</string>
     <string name="security_advanced_settings_no_work_profile_settings_summary">Cifradure, credenziâls e altri</string>
     <string name="security_advanced_settings_keywords">sigurece, altris impostazions di sigurece, plui impostazions, impostazions di sigurece avanazadis</string>
     <string name="privacy_advanced_settings">Altris impostazions di riservatece</string>
+    <string name="more_security_privacy_settings">Plui sigurece e riservatece</string>
     <string name="security_header">Sigurece</string>
     <string name="privacy_header">Riservatece</string>
     <string name="work_profile_category_header">Profîl di lavôr</string>
+    <string name="private_space_biometric_title">Sbloc cu la muse e cul impront</string>
+    <string name="private_space_biometric_summary">Tocje par configurâ</string>
+    <string name="private_space_screen_lock_summary">Compagn dal bloc schermi dal dispositîf</string>
+    <string name="privatespace_hide_off_summary">Off</string>
+    <string name="privatespace_hide_on_summary">On</string>
+    <string name="private_space_category_system">Sisteme</string>
+    <string name="no_device_lock_title">Stabilìs un bloc schermi</string>
+    <string name="no_device_lock_action_label">Stabilìs il bloc schermi</string>
+    <string name="no_device_lock_cancel">Anule</string>
+    <string name="private_space_cancel_label">Anule</string>
+    <string name="private_space_setup_button_label">Configure</string>
+    <string name="private_space_how_title">Cemût funzionial?</string>
+    <string name="private_space_done_label">Fat</string>
     <string name="fingerprint_add_max">Tu puedis zontâ fin a <xliff:g id="count" example="5">%d</xliff:g> impronts</string>
     <string name="fingerprint_intro_error_max">Tu âs zontât il numar massim di impronts digjitâi</string>
     <string name="fingerprint_intro_error_unknown">Impussibil zontâ altris impronts</string>
@@ -419,6 +536,12 @@
     <string name="lock_settings_picker_profile_message">Se tu dismenteis chest bloc, domande al to aministradôr di IT di ristabilîlu</string>
     <string name="setup_lock_settings_options_button_label">Opzions dal bloc schermi</string>
     <string name="setup_lock_settings_options_dialog_title">Opzions dal bloc schermi</string>
+    <string name="lock_screen_auto_pin_confirm_title">Sbloc cun conferme automatiche</string>
+    <string name="lock_screen_auto_pin_confirm_summary">Sbloche in automatic se tu scrivis un PIN just di 6 cifris o plui. Cheste opzion e je un tic mancul sigure rispiet a chê di tocjâ Invie par confermâ.</string>
+    <string name="auto_pin_confirm_user_message">Conferme in automatic il PIN just</string>
+    <string name="auto_pin_confirm_opt_in_security_message">Confermant il PIN tocjant Invie al è plui sigûr di doprâ la conferme automatiche</string>
+    <string name="auto_confirm_on_pin_verify_description">Inserìs il PIN dal dispositîf par ativâ la conferme automatiche</string>
+    <string name="auto_confirm_off_pin_verify_description">Inserìs il PIN dal dispositîf par disativâ la conferme automatiche</string>
     <string name="unlock_set_unlock_launch_picker_title">Bloc schermi</string>
     <string name="unlock_set_unlock_launch_picker_title_profile">Bloc dal profîl di lavôr</string>
     <string name="unlock_set_unlock_off_title">Nissun</string>
@@ -428,8 +551,15 @@
     <string name="unlock_set_unlock_password_title">Password</string>
     <string name="unlock_set_do_later_title">No cumò</string>
     <string name="current_screen_lock">Bloc schermi atuâl</string>
+    <string name="fingerprint_unlock_set_unlock_pattern">Cumbinazion \u2022 Impront</string>
+    <string name="fingerprint_unlock_set_unlock_pin">PIN \u2022 Impront</string>
+    <string name="fingerprint_unlock_set_unlock_password">Password \u2022 Impront</string>
     <string name="fingerprint_unlock_skip_fingerprint">Continue cence impront</string>
+    <string name="face_unlock_set_unlock_pattern">Cumbinazion \u2022 Muse</string>
+    <string name="face_unlock_set_unlock_pin">PIN \u2022 Muse</string>
+    <string name="face_unlock_set_unlock_password">Password \u2022 Muse</string>
     <string name="face_unlock_skip_face">Continue cence sbloc cu la muse</string>
+    <string name="biometrics_unlock_skip_biometrics">Continue cence impront o muse</string>
     <string name="unlock_set_unlock_mode_off">Nissun</string>
     <string name="unlock_set_unlock_mode_none">Scoriment</string>
     <string name="unlock_set_unlock_mode_pattern">Cumbinazion</string>
@@ -469,13 +599,61 @@
     <string name="lock_last_pattern_attempt_before_wipe_profile">Se al prossim tentatîf tu inserissis une cumbinazion sbaliade, il to profîl di lavôr e i siei dâts a vignaran eliminâts</string>
     <string name="lock_last_pin_attempt_before_wipe_profile">Se al prossim tentatîf tu inserissis un PIN sbaliât, il to profîl di lavôr e i siei dâts a vignaran eliminâts</string>
     <string name="lock_last_password_attempt_before_wipe_profile">Se al prossim tentatîf tu inserissis une password sbaliade, il to profîl di lavôr e i siei dâts a vignaran eliminâts</string>
+    <string name="lockpassword_password_too_short">{count, plural,
+      one {}=1      {E à di vê almancul # caratar}
+      other   {E à di vê almancul # caratars}
+    }</string>
     <string name="lockpassword_password_too_short_all_numeric">        {count, plural,
             one {}=1    {Se tu dopris nome numars, e scugne vê almancul 1 cifre}
             other {Se tu dopris nome numars, e scugne vê almancul # cifris}
         }
     </string>
+    <string name="lockpassword_pin_too_short">{count, plural,
+      one {}=1      {Il PIN al à di vê almancul # cifre}
+      other   {Il PIN al à di vê almancul # cifris}
+    }</string>
+    <string name="lockpassword_pin_too_short_autoConfirm_extra_message">{count, plural,
+        one {}=1      {Il PIN al à di vê almancul # cifre, ma un PIN di {minAutoConfirmLen} cifris al è conseât par vê plui sigurece}
+        other   {Il PIN al à di vê almancul # cifris, ma un PIN di {minAutoConfirmLen} cifris al è conseât par vê plui sigurece}
+        }</string>
+    <string name="lockpassword_password_too_long">{count, plural,
+      one {}=1      {E à di vê mancul di # caratar}
+      other   {E à di vê mancul di # caratars}
+    }</string>
+    <string name="lockpassword_pin_too_long">{count, plural,
+      one {}=1      {Al à di vê mancul di # cifre}
+      other   {Al à di vê mancul di # cifris}
+    }</string>
     <string name="lockpassword_pin_recently_used">L\'aministradôr dal dispositîf nol permet di doprâ un PIN resint</string>
     <string name="lockpassword_illegal_character">No pues includi un caratar no valit</string>
+    <string name="lockpassword_password_requires_letters">{count, plural,
+      one {}=1      {E à di vê almancul 1 letare}
+      other   {E à di vê almancul # letaris}
+    }</string>
+    <string name="lockpassword_password_requires_lowercase">{count, plural,
+      one {}=1      {E à di vê almancul 1 letare minuscule}
+      other   {E à di vê almancul # letaris minusculis}
+    }</string>
+    <string name="lockpassword_password_requires_uppercase">{count, plural,
+      one {}=1      {E à di vê almancul 1 letare maiuscule}
+      other   {E à di vê almancul # letaris maiusculis}
+    }</string>
+    <string name="lockpassword_password_requires_numeric">{count, plural,
+      one {}=1      {E à di vê almancul 1 numar}
+      other   {E à di vê almancul # numars}
+    }</string>
+    <string name="lockpassword_password_requires_symbols">{count, plural,
+      one {}=1      {E à di vê almancul 1 simbul speciâl}
+      other   {E à di vê almancul # simbui speciâi}
+    }</string>
+    <string name="lockpassword_password_requires_nonletter">{count, plural,
+      one {}=1      {E à di vê almancul 1 caratar diviers di une letare}
+      other   {E à di vê almancul # caratars che no son letaris}
+    }</string>
+    <string name="lockpassword_password_requires_nonnumerical">{count, plural,
+      one {}=1      {E à di vê almancul 1 caratar diviers di un numar}
+      other   {E à di vê almancul # caratars che no son numars}
+    }</string>
     <string name="lockpassword_password_recently_used">L\'aministradôr dal dispositîf nol permet di doprâ une
         password resinte</string>
     <string name="lockpassword_pin_no_sequential_digits">Lis secuencis di numars in cressi, in calâ o ripetûts
@@ -487,12 +665,21 @@
     <string name="lockpattern_tutorial_continue_label">Indenant</string>
     <string name="manage_device_admin">Aplicazions di aministrazion dal dispositîf</string>
     <string name="number_of_device_admins_none">Nissune aplicazion ative</string>
+    <string name="number_of_device_admins">{count, plural,
+      one {}=1      {# aplicazion ative}
+      other   {# aplicazions ativis}
+    }</string>
     <string name="manage_trust_agents">Agjents di fiducie</string>
     <string name="disabled_because_no_backup_security">Par doprâ cheste opzion, prime configure un bloc schermi</string>
     <string name="manage_trust_agents_summary">Nissun</string>
+    <string name="manage_trust_agents_summary_on">{count, plural,
+      one {}=1      {1 agjent di fiducie atîf}
+      other   {# agjents di fiducie atîfs}
+    }</string>
     <string name="bluetooth_settings">Bluetooth</string>
     <string name="bluetooth_settings_title">Bluetooth</string>
     <string name="bluetooth_pairing_request">Associâ cun <xliff:g id="device_name">%1$s</xliff:g>?</string>
+    <string name="bluetooth_pairing_group_late_bonding">Zonte un gnûf membri al complès coordenât esistent</string>
     <string name="bluetooth_pairing_key_msg">Codiç di associazion Bluetooth</string>
     <string name="bluetooth_enter_passkey_msg">Scrîf il codiç di associazion e frache Invie</string>
     <string name="bluetooth_enable_alphanumeric_pin">Il PIN al conten letaris o simbui</string>
@@ -507,22 +694,29 @@
     <string name="bluetooth_device_context_connect">Conet</string>
     <string name="bluetooth_device_context_disconnect">Disconet</string>
     <string name="bluetooth_device_context_pair_connect">Associe e conet</string>
-    <string name="bluetooth_empty_list_bluetooth_off">Cuant che il Bluetooth al è ativât, il to dispositîf al pues comunicâ cun altris dispositîfs Bluetooth tai contors.</string>
+    <string name="bluetooth_scanning_on_info_message">Cuant che il Bluetooth al ven ativât, il to dispositîf al pues comunicâ cun altris dispositîfs Bluetooth che a son dongje.\n\nPar miorâ la esperience di utilizazion dal dispositîf, aplicazions e servizis a podaran continuâ a scansionâ dispositîfs dongje in cualsisei moment, ancje cuant che il Bluetooth al ven distudât. Cheste pussibilitât e pues vignî doprade, par esempli, par miorâ lis funzions e i servizis basâts su la posizion. Tu puedis cambiâ cheste configurazion intes impostazions di scansionament dal Bluetooth.</string>
     <string name="bluetooth_scan_change">Cambie</string>
     <string name="device_details_title">Detais dispositîf</string>
+    <string name="bluetooth_device_keyboard_settings_preference_title">Impostazions tastiere</string>
     <string name="bluetooth_device_mac_address">Direzion Bluetooth dal dispositîf: <xliff:g id="address">%1$s</xliff:g></string>
     <string name="bluetooth_multuple_devices_mac_address">Direzion Bluetooth dal dispositîf:\n<xliff:g id="address">%1$s</xliff:g></string>
     <string name="bluetooth_unpair_dialog_title">Dismenteâ il dispositîf?</string>
     <string name="remove_association_button">Gjave associazion</string>
     <string name="bluetooth_companion_app_remove_association_dialog_title">Disconeti la aplicazion?</string>
     <string name="bluetooth_companion_app_body">La aplicazion <xliff:g id="app_name" example="App Name">%1$s</xliff:g> no si conetarà plui al to <xliff:g id="device_name" example="Device Name">%2$s</xliff:g></string>
+    <string name="device_details_leaudio_toggle_summary">Sperimentâl. Al miore la cualitât audio.</string>
     <string name="bluetooth_unpair_dialog_forget_confirm_button">Dismentee dispositîf</string>
     <string name="bluetooth_companion_app_remove_association_confirm_button">Disconet aplicazion</string>
     <string name="bluetooth_max_connected_audio_devices_string">Numar massim di dispositîfs audio Bluetooth conetûts</string>
     <string name="bluetooth_max_connected_audio_devices_dialog_title">Selezione il numar massim di dispositîfs audio Bluetooth conetûts</string>
     <string name="nfc_stack_debuglog_title">Regjistri di debug dal stack NFC</string>
     <string name="nfc_stack_debuglog_summary">Aumente il nivel di regjistrazion dal stack NFC</string>
+    <string name="nfc_verbose_vendor_log_title">Regjistri prolìs di debug dal produtôr di NFC</string>
+    <string name="nfc_verbose_vendor_log_summary">Inclût intes segnalazions di erôr, regjistris adizionâi dal produtôr specifics pal dispositîf, che a puedin contignî informazions privadis. </string>
+    <string name="nfc_snoop_log_title">Regjistri cence filtris NCI NFC</string>
+    <string name="nfc_snoop_log_summary">Tire dongje pachets NFC detaiâts, che a puedin contignî informazions privadis. </string>
     <string name="nfc_reboot_dialog_title">Tornâ a inviâ il dispositîf?</string>
+    <string name="nfc_reboot_dialog_message">La regjistrazion NDF detaiade e je pensade nome par finalitâts di disvilup. Dâts NFC adizionâi a vegnin includûts tes segnalazions di erôr e chescj a podaressin contignî informazions privadis. Torne invie il dispositîf par cambiâ cheste impostazion. </string>
     <string name="nfc_reboot_dialog_confirm">Torne invie</string>
     <string name="wifi_display_settings_title">Trasmet</string>
     <string name="keywords_wifi_display_settings">spieli</string>
@@ -585,7 +779,7 @@
     <string name="wifi_configure_settings_preference_title">Preferencis Wi\u2011Fi</string>
     <string name="wifi_configure_settings_preference_summary_wakeup_on">Il Wi\u2011Fi si ative in automatic</string>
     <string name="wifi_configure_settings_preference_summary_wakeup_off">Il Wi\u2011Fi no si ative in automatic</string>
-    <string name="wifi_menu_p2p">Wi\u2011Fi Direct</string>
+    <string name="wifi_menu_p2p">Wi\u2011Fi Diret</string>
     <string name="wifi_empty_list_wifi_off">Par viodi lis rêts disponibilis, ative il Wi\u2011Fi.</string>
     <string name="wifi_empty_list_wifi_on">Daûr a cirî lis rêts\u2026</string>
     <string name="wifi_empty_list_user_restricted">No tu âs i permès par cambiâ la rêt Wi\u2011Fi.</string>
@@ -614,6 +808,7 @@
     <string name="wifi_eap_method">Metodi EAP</string>
     <string name="please_select_phase2">Autenticazion di fase 2</string>
     <string name="wifi_eap_ca_cert">Certificât CA</string>
+    <string name="wifi_eap_min_tls_ver">Version minime di TLS</string>
     <string name="wifi_eap_ocsp">Stât dal certificât in linie</string>
     <string name="wifi_eap_domain">Domini</string>
     <string name="wifi_eap_user_cert">Certificât utent</string>
@@ -656,6 +851,7 @@
     <string name="wifi_dpp_sharing_wifi_with_this_device">Daûr a condividi la rêt Wi\u2011Fi cun chest dispositîf\u2026</string>
     <string name="wifi_dpp_connecting">Daûr a coneti\u2026</string>
     <string name="wifi_dpp_share_hotspot">Condivît pont di acès</string>
+    <string name="wifi_dpp_lockscreen_title">Verifiche la tô identitât</string>
     <string name="wifi_dpp_wifi_password">Password Wi\u2011Fi: <xliff:g id="password" example="my password">%1$s</xliff:g></string>
     <string name="wifi_dpp_hotspot_password">Password pont di acès: <xliff:g id="password" example="my password">%1$s</xliff:g></string>
     <string name="wifi_auto_connect_title">Conession automatiche</string>
@@ -687,19 +883,28 @@
     <string name="lost_internet_access_cancel">Reste sul Wi\u2011Fi</string>
     <string name="lost_internet_access_persist">No sta mostrâ plui</string>
     <string name="wifi_connect">Conet</string>
-    <string name="wifi_turned_on_message">Wi\u2011Fi ativât</string>
     <string name="wifi_connected_to_message">Conetût a <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
-    <string name="wifi_connecting_to_message">Conession a <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
     <string name="wifi_connecting">Daûr a coneti\u2026</string>
     <string name="wifi_failed_connect_message">Nol è stât pussibil conetisi ae rêt</string>
     <string name="wifi_not_in_range_message">Rêt fûr puartade</string>
     <string name="wifi_forget">Dismentee</string>
     <string name="wifi_modify">Modifiche</string>
-    <string name="wifi_failed_forget_message">Impussibil dismenteâ la rêt</string>
     <string name="wifi_save">Salve</string>
     <string name="wifi_failed_save_message">Nol è stât pussibil salvâ la rêt</string>
     <string name="wifi_cancel">Anule</string>
     <string name="wifi_forget_dialog_title">Dismenteâ la rêt?</string>
+    <string name="wifi_saved_access_points_summary">{count, plural,
+      one {}=1      {1 rêt}
+      other   {# rêts}
+    }</string>
+    <string name="wifi_saved_passpoint_access_points_summary">{count, plural,
+      one {}=1      {1 abonament}
+      other   {# abonaments}
+    }</string>
+    <string name="wifi_saved_all_access_points_summary">{count, plural,
+      one {}=1      {1 rêt e 1 abonament}
+      other   {# rêts e # abonaments}
+    }</string>
     <string name="wifi_advanced_ssid_title">SSID</string>
     <string name="wifi_advanced_device_mac_address_title">Direzion MAC dal dispositîf</string>
     <string name="wifi_advanced_randomized_mac_address_title">Direzion MAC casuâl</string>
@@ -709,9 +914,13 @@
     <string name="wifi_type_title">Gjenar</string>
     <string name="wifi_details_dns">DNS</string>
     <string name="wifi_details_ipv6_address_header">Direzions IPv6</string>
+    <string name="hotspot_device_details_category">Detais dispositîf dal pont di acès</string>
+    <string name="hotspot_device_details_internet_source">Sorzint internet</string>
     <string name="internet_source_wifi">Wi\u2011Fi</string>
     <string name="internet_source_mobile_data">Dâts mobii</string>
     <string name="internet_source_ethernet">Ethernet</string>
+    <string name="hotspot_connection_category">Conession dal pont di acès</string>
+    <string name="hotspot_connection_strength">Fuarce de conession</string>
     <string name="wifi_saved_access_points_label">Rêts salvadis</string>
     <string name="wifi_subscribed_access_points_tab">Sotscrizions</string>
     <string name="wifi_saved_other_networks_tab">Altris rêts</string>
@@ -723,7 +932,7 @@
     <string name="wifi_dns2">DNS 2 (gjavât che nol vegni ignorât dal DNS Privât)</string>
     <string name="wifi_gateway">Gateway</string>
     <string name="wifi_network_prefix_length">Lungjece prefìs rêt</string>
-    <string name="wifi_p2p_settings_title">Wi\u2011Fi Direct</string>
+    <string name="wifi_p2p_settings_title">Wi\u2011Fi Diret</string>
     <string name="wifi_p2p_menu_search">Cîr dispositîfs</string>
     <string name="wifi_p2p_menu_searching">Daûr a cirî\u2026</string>
     <string name="wifi_p2p_menu_rename">Cambie non al dispositîf</string>
@@ -742,15 +951,31 @@
     <string name="wifi_hotspot_no_password_subtext">Nissune password stabilide</string>
     <string name="wifi_hotspot_name_title">Non dal pont di acès</string>
     <string name="wifi_hotspot_password_title">Password dal pont di acès</string>
-    <string name="wifi_hotspot_ap_band_title">Bande AP</string>
     <string name="wifi_hotspot_auto_off_title">Disative il pont di acès in automatic</string>
     <string name="wifi_hotspot_auto_off_summary">Cuant che nissun dispositîf al è colegât</string>
     <string name="wifi_hotspot_maximize_compatibility">Compatibilitât slargjade</string>
     <string name="wifi_hotspot_maximize_compatibility_single_ap_summary">Al jude altris dispositîfs a cjatâ chest pont di acès. Al ridûs la velocitât di conession dal pont di acès.</string>
     <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary">Al jude altris dispositîfs a cjatâ chest pont di acès. Al aumente il consum di batarie.</string>
+    <string name="wifi_hotspot_speed_title">Velocitât e compatibilitât</string>
+    <string name="wifi_hotspot_speed_summary_2g">2.4 GHz / Compatibil cu la plui part dai dispositîfs</string>
+    <string name="wifi_hotspot_speed_summary_5g">5 GHz / Compatibil cun tancj dispositîfs</string>
+    <string name="wifi_hotspot_speed_summary_6g">6 GHz / Compatibil cun pôcs dispositîfs</string>
+    <string name="wifi_hotspot_speed_summary_2g_and_5g">2.4 e 5 GHz / Compatibil cu la plui part dai dispositîfs</string>
+    <string name="wifi_hotspot_speed_intro">Sielç une frecuence pal to pont di acès. La frecuence e determine la velocitât de conession e i gjenars di dispositîfs che a cjataran il to pont di acès.</string>
+    <string name="wifi_hotspot_speed_category">Frecuence preferide</string>
     <string name="wifi_hotspot_speed_2g">2.4 GHz</string>
+    <string name="wifi_hotspot_speed_2g_summary">Velocitâts plui lentis. Compatibil cu la plui part dai dispositîfs.</string>
     <string name="wifi_hotspot_speed_5g">5 GHz</string>
+    <string name="wifi_hotspot_speed_5g_summary">Velocitâts sveltis. Compatibil cun tancj dispositîfs.</string>
+    <string name="wifi_hotspot_speed_2g_5g">2.4 e 5 GHz</string>
+    <string name="wifi_hotspot_speed_2g_5g_summary">Velocitâts svelits. Chest pont di acès a dople bande al è compatibil cu la plui part dai dispositîfs.</string>
     <string name="wifi_hotspot_speed_6g">6 GHz</string>
+    <string name="wifi_hotspot_speed_6g_summary">Lis velocitâts plui sveltis. Compatibil cun pôcs dispositîfs.</string>
+    <string name="wifi_hotspot_speed_summary_unavailable">No disponibil tal to paîs o te tô regjon</string>
+    <string name="wifi_hotspot_speed_footer">Se la tô frecuence preferide no je disponibile, il to pont di acès al podarès doprânt une diferente. Lis impostazions di sigurece dal pont di acès a podaressin cambiâ se tu cambiis la frecuence.</string>
+    <string name="wifi_hotspot_security_summary_unavailable">No disponibil cui 6 GHz</string>
+    <string name="wifi_hotspot_security_footer">Lis impostazions di sigurece a podaressin cambiâ se tu cambiis la frecuence dal pont di acès</string>
+    <string name="wifi_hotspot_instant_title">Pont di acès istantani</string>
     <string name="wifi_hotspot_instant_summary_on">On</string>
     <string name="wifi_hotspot_instant_summary_off">Off</string>
     <string name="wifi_tether_starting">Daûr a ativâ il pont di acès\u2026</string>
@@ -798,6 +1023,7 @@
     <string name="account_settings">Accounts</string>
     <string name="accessibility_category_work">Accounts dai profîi di lavôr - <xliff:g id="managed_by" example="Managed by Corporate application">%s</xliff:g></string>
     <string name="accessibility_category_personal">Accounts dai profîi personâi</string>
+    <string name="accessibility_category_clone">Accounts dai profîi clon</string>
     <string name="accessibility_work_account_title">Account di lavôr - <xliff:g id="managed_by" example="Email provider">%s</xliff:g></string>
     <string name="accessibility_personal_account_title">Account personâl - <xliff:g id="managed_by" example="Email provider">%s</xliff:g></string>
     <string name="search_settings">Ricercje</string>
@@ -824,6 +1050,7 @@
     <string name="auto_brightness_summary_on">On</string>
     <string name="auto_brightness_summary_off">Off</string>
     <string name="display_white_balance_title">Belançament blanc dal schermi</string>
+    <string name="fold_lock_behavior_title">Continue a doprâ lis aplicazions se tu sieris (il tapon)</string>
     <string name="peak_refresh_rate_title">Schermi fluit</string>
     <string name="force_high_refresh_rate_toggle">Sfuarce frecuence di inzornament massime</string>
     <string name="force_high_refresh_rate_desc">La plui alte frecuence di inzornament pe rispueste tatile miorade e pe cualitât di animazion. Al aumente il consum di batarie.</string>
@@ -914,12 +1141,18 @@
     <string name="force_bold_text">Test in neret</string>
     <string name="title_font_size">Dimension dal caratar</string>
     <string name="short_summary_font_size">Ingrandìs o impiçulìs il test</string>
+    <string name="sim_lock_settings">Impostazions di bloc de SIM</string>
+    <string name="sim_lock_settings_category">Bloc de SIM</string>
+    <string name="sim_pin_toggle">Bloche SIM</string>
     <string name="sim_pin_change">Cambie il PIN de SIM</string>
     <string name="sim_enter_pin">PIN de SIM</string>
+    <string name="sim_enable_sim_lock">Bloche SIM</string>
+    <string name="sim_disable_sim_lock">Sbloche SIM</string>
     <string name="sim_enter_old">PIN vecjo de SIM</string>
     <string name="sim_enter_new">PIN gnûf de SIM</string>
     <string name="sim_reenter_new">Torne scrîf il PIN gnûf</string>
     <string name="sim_change_pin">PIN de SIM</string>
+    <string name="sim_invalid_pin_hint">Scrîf un PIN che al vedi di 4 a 8 numars</string>
     <string name="sim_pins_dont_match">I PINs no corispuindin</string>
     <string name="sim_change_succeeded">PIN de SIM cambiât cun sucès</string>
     <string name="sim_pin_disable_failed">Impussibil disativâ il PIN.</string>
@@ -935,8 +1168,16 @@
     </string>
     <string name="sim_change_data_ok">        Dopre <xliff:g id="carrier" example="Verizon">%1$s</xliff:g>
     </string>
+    <string name="sim_preferred_title">Inzornâ la SIM preferide?</string>
     <string name="sim_preferred_message"><xliff:g id="new_sim">%1$s</xliff:g> e je la uniche SIM tal dispositîf. Desideristu doprâ cheste SIM pai dâts mobii, clamadis e messaçs SMS?</string>
+    <string name="enable_auto_data_switch_dialog_title">Miorâ cuvierture dâts mobii?</string>
+    <string name="enable_auto_data_switch_dialog_message">Permet al to dispositîf di passâ in automatic a <xliff:g id="backup_carrier" example="T-mobile">%1$s</xliff:g> pai dâts mobii se chest al à une conession miôr.</string>
+    <string name="auto_data_switch_dialog_managed_profile_warning">\n\nLa tô organizazion e podarà viodi clamadis, messaçs e trafic di rêt.</string>
     <string name="wrong_pin_code_pukked">Codiç PIN de SIM sbaliât, cumò tu scugnis contatâ il to operadôr par sblocâ il dispositîf.</string>
+    <string name="wrong_pin_code">{count, plural,
+      one {}=1      {Codiç PIN de SIM sbaliât, ti reste # tentatîf prime che al sedi necessari contatâ il to operadôr par sblocâ il dispositîf.}
+      other   {Codiç PIN de SIM sbaliât, ti restin # tentatîfs.}
+    }</string>
     <string name="wrong_pin_code_one">Codiç PIN de SIM sbaliât, ti reste 1 tentatîf prime che al sedi necessari contatâ il to operadôr par sblocâ il dispositîf.</string>
     <string name="pin_failed">Operazion PIN de SIM falide!</string>
     <string name="system_update_settings_list_item_title">Inzornaments di sisteme</string>
@@ -944,16 +1185,21 @@
     <string name="security_patch">Inzornament di sigurece di Android</string>
     <string name="model_info">Model</string>
     <string name="hardware_revision">Version hardware</string>
+    <string name="manufactured_year">An di produzion</string>
     <string name="fcc_equipment_id">ID imprest</string>
     <string name="baseband_version">Version bande di base</string>
     <string name="kernel_version">Version dal kernel</string>
     <string name="build_number">Numar di compilazion</string>
     <string name="module_version">Inzornament di sisteme di Google Play</string>
+    <string name="battery_info">Informazions su la batarie</string>
     <string name="device_info_not_available">No disponibil</string>
     <string name="storage_settings">Spazi di archiviazion</string>
     <string name="storage_settings_for_app">Spazi di archiviazion e cache</string>
     <string name="storage_settings_title">Impostazions memorie</string>
     <string name="status_eid">EID</string>
+    <string name="eid_multi_sim">EID (fressure sim <xliff:g id="eid_slot_id">%1$d</xliff:g>)</string>
+    <string name="imei_multi_sim">IMEI (fressure sim <xliff:g id="imei_slot_id">%1$d</xliff:g>)</string>
+    <string name="imei_multi_sim_primary">IMEI (fressure sim <xliff:g id="imei_slot_id_primary">%1$d</xliff:g>) (primarie)</string>
     <string name="view_saved_network">Par visualizâle, sielç la rêt salvade</string>
     <string name="status_imei">IMEI</string>
     <string name="status_imei_sv">IMEI SV</string>
@@ -961,6 +1207,8 @@
     <string name="status_min_number">MIN</string>
     <string name="status_msid_number">MSID</string>
     <string name="status_prl_version">Version PRL</string>
+    <string name="meid_multi_sim">MEID (fressure sim <xliff:g id="meid_slot_id">%1$d</xliff:g>)</string>
+    <string name="meid_multi_sim_primary">MEID (fressure sim <xliff:g id="meid_slot_id_primary">%1$d</xliff:g>) (primarie)</string>
     <string name="scanning_status_text_on">On</string>
     <string name="scanning_status_text_off">Off</string>
     <string name="status_meid_number">MEID</string>
@@ -979,6 +1227,9 @@
     <string name="status_bt_address">Direzion Bluetooth</string>
     <string name="status_serial_number">Numar di serie</string>
     <string name="status_up_time">Timp impiât</string>
+    <string name="battery_manufacture_date">Date di produzion</string>
+    <string name="battery_first_use_date">Date de prime utilizazion</string>
+    <string name="battery_cycle_count">Conte dai ciclis</string>
     <string name="battery_cycle_count_not_available">No disponibil</string>
     <string name="memory_calculating_size">Daûr a calcolâ\u2026</string>
     <string name="storage_menu_rename">Cambie non</string>
@@ -1105,15 +1356,24 @@
     <string name="menu_restore">Ripristine valôrs predefinîts</string>
     <string name="restore_default_apn_completed">Ripristinament completât des impostazions APN predefinidis.</string>
     <string name="reset_dashboard_title">Opzions di ripristinament</string>
+    <string name="reset_mobile_network_settings_title">Ristabilìs Impostazions di rêt mobile</string>
+    <string name="reset_mobile_network_settings_desc">Cheste operazion e ripristinarà lis impostazions di rêt mobile</string>
+    <string name="reset_mobile_network_settings_confirm_title">Ristabilî lis impostazions di rêt mobile?</string>
+    <string name="reset_bluetooth_wifi_title">Ristabilî Bluetooth e Wi\u2011Fi</string>
+    <string name="reset_bluetooth_wifi_desc">Cheste operazion e ripristinarà lis impostazions dal Wi\u2011Fi e dal Bluetooth. Nol sarà pussibil tornâ indaûr di cheste operazion.</string>
     <string name="reset_bluetooth_wifi_button_text">Ristabilìs</string>
+    <string name="reset_bluetooth_wifi_complete_toast">Bluetooth e Wi\u2011Fi a son stâts ripristinâts</string>
+    <string name="reset_esim_title">Scancele lis eSIMs</string>
     <string name="reset_esim_desc">Chest nol anularà nissun plan pai servizis mobii. Par discjariâ lis SIMs sostitutivis, contate il to operadôr.</string>
     <string name="reset_network_button_text">Ristabilìs impostazions</string>
     <string name="reset_network_final_desc">Ripristinâ dutis lis impostazions di rêt? Nol sarà pussibil anulâ cheste azion.</string>
+    <string name="reset_network_final_desc_esim">Ristabilî dutis lis impostazions di rêt e scancelâ lis eSIMs? Nol sarà pussibil anulâ di cheste azion.</string>
     <string name="reset_network_final_button_text">Ristabilìs impostazions</string>
     <string name="reset_network_confirm_title">Ristabilî?</string>
     <string name="network_reset_not_available">Il ripristinament de rêt nol è disponibil par chest utent</string>
     <string name="reset_network_complete_toast">Lis impostazions di rêt a son stadis ristabilidis</string>
     <string name="reset_esim_error_title">Impussibil scancelâ lis SIMs</string>
+    <string name="reset_esim_error_msg">Nol è pussibil scancelâ lis eSIMs par vie di un erôr.\n\nTorne invie il dispositîf e torne prove.</string>
     <string name="main_clear_title">Cancele ducj i dâts (ripristinament di fabriche)</string>
     <string name="main_clear_short_title">Cancele ducj i dâts (ripristinament di fabriche)</string>
     <string name="main_clear_desc_also_erases_external"><li>Musiche</li>\n<li>Fotos</li>\n<li>Altris dâts di utent</li></string>
@@ -1153,16 +1413,6 @@
     <string name="tether_settings_summary_all">Pont di acès, USB, Bluetooth, Ethernet</string>
     <string name="tether_settings_summary_off">No tu stâs condividint la conession a internet cun altris dispositîfs</string>
     <string name="tether_preference_summary_off">Off</string>
-    <string name="tethering_interface_options">Tethering</string>
-    <string name="disable_wifi_hotspot_title">No sta doprâ il pont di acès Wi\u2011Fi</string>
-    <string name="disable_wifi_hotspot_when_usb_on">Condivît internet dome vie USB</string>
-    <string name="disable_wifi_hotspot_when_bluetooth_on">Condivît internet dome vie Bluetooth</string>
-    <string name="disable_wifi_hotspot_when_ethernet_on">Condivît internet dome vie Ethernet</string>
-    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on">Condivît internet dome vie USB e Bluetooth</string>
-    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on">Condivît internet dome vie USB e Ethernet</string>
-    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on">Condivît internet dome vie Bluetooth e Ethernet</string>
-    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on">Condivît internet dome vie USB, Bluetooth e Ethernet</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">Tethering USB</string>
     <string name="bluetooth_tether_checkbox_text">Tethering Bluetooth</string>
     <string name="ethernet_tether_checkbox_text">Tethering Ethernet </string>
@@ -1170,7 +1420,6 @@
     <string name="tethering_footer_info_sta_ap_concurrency">Dopre il pont di acès e il tethering par puartâ internet su altris dispositîfs midiant la tô conession dâts mobii o il to Wi\u2011Fi. Lis aplicazions a puedin ancje creâ un pont di acès par condividi contignûts cui dispositîfs tai contors.</string>
     <string name="tethering_help_button_text">Jutori</string>
     <string name="network_settings_title">Rêt mobile</string>
-    <string name="manage_mobile_plan_title" translatable="true">Plan dâts mobii</string>
     <string name="sms_application_title" translatable="true">Aplicazion di SMS</string>
     <string name="sms_change_default_dialog_title" translatable="true">Cambiâ la aplicazion pai SMS?</string>
     <string name="sms_change_default_dialog_text" translatable="true">Doprâ <xliff:g id="new_app">%1$s</xliff:g> al puest di <xliff:g id="current_app">%2$s</xliff:g> come tô aplicazion pai SMS?</string>
@@ -1178,14 +1427,14 @@
     <string name="network_scorer_change_active_dialog_title">Cambiâ assistent Wi\u2011Fi?</string>
     <string name="network_scorer_change_active_dialog_text">Doprâ <xliff:g id="new_app">%1$s</xliff:g> al puest di <xliff:g id="current_app">%2$s</xliff:g> par gjestî lis tôs conessions di rêt?</string>
     <string name="network_scorer_change_active_no_previous_dialog_text">Doprâ <xliff:g id="new_app">%s</xliff:g> par gjestî lis tôs conessions di rêt?</string>
-    <string name="mobile_unknown_sim_operator" translatable="true">Operadôr SIM no cognossût</string>
-    <string name="mobile_no_provisioning_url"><xliff:g id="operator">%1$s</xliff:g> nol à nissun sît web di furniment cognossût</string>
-    <string name="mobile_insert_sim_card" translatable="true">Inserìs la schede SIM e torne invie</string>
-    <string name="mobile_connect_to_internet" translatable="true">Conetiti a internet</string>
     <string name="location_category_recent_location_requests">Richiestis di posizion resintis</string>
     <string name="managed_profile_location_switch_title">Posizion pal profîl di lavôr</string>
     <string name="location_app_level_permissions">Permès pe posizion</string>
     <string name="location_app_permission_summary_location_off">La gjeolocalizazion e je disativade</string>
+    <string name="location_app_permission_summary_location_on">{count, plural,
+      one {}=1      {# di {total} aplicazions e à acès ae posizion}
+      other   {# di {total} aplicazions a àn acès ae posizion}
+    }</string>
     <string name="location_category_recent_location_access">Acès resint</string>
     <string name="location_recent_location_access_see_all">Viôt ducj</string>
     <string name="location_recent_location_access_view_details">Viôt i detais</string>
@@ -1200,14 +1449,18 @@
     <string name="location_services_preference_title">Servizis di localizazion</string>
     <string name="location_services_screen_title">Servizis di localizazion</string>
     <string name="location_time_zone_detection_toggle_title">Dopre posizion</string>
+    <string name="location_time_zone_detection_status_title">Impussibil stabilî il fûs orari in automatic</string>
+    <string name="location_time_zone_detection_status_summary_blocked_by_settings">La posizion o i serivzis pe posizion a son disativâts</string>
     <string name="location_time_zone_detection_location_is_off_dialog_title">Gjeolocalizazion dal dispositîf necessarie</string>
     <string name="location_time_zone_detection_location_is_off_dialog_message">Par stabilî il fûs orari doprant la tô posizion, ative la gjeolocalizazion, dopo inzorne lis impostazions dal fûs orari</string>
     <string name="location_time_zone_detection_location_is_off_dialog_ok_button">Impostazions di gjeolocalizazion</string>
+    <string name="location_time_zone_provider_fix_dialog_ok_button">Comede</string>
     <string name="location_time_zone_detection_location_is_off_dialog_cancel_button">Anule</string>
     <string name="location_time_zone_detection_auto_is_off">Il fûs orari automatic al è disativât</string>
     <string name="location_time_zone_detection_not_applicable">Il rilevament dal fûs orari in base ae posizion al è disativât</string>
     <string name="location_time_zone_detection_not_supported">Il rilevament dal fûs orari in base ae posizion nol è supuartât</string>
     <string name="location_time_zone_detection_not_allowed">Lis modifichis dal rilevament dal fûs orari in base ae posizion no son consintudis</string>
+    <string name="location_time_zone_detection_auto_is_on">Al è pussibil che e vegni doprade la posizion par stabilî il fûs orari</string>
     <string name="about_settings_summary">Visualize informazions legâls, stât, version dal software</string>
     <string name="legal_information">Informazions legâls</string>
     <string name="manual">Manuâl</string>
@@ -1261,6 +1514,10 @@
     <string name="lockpassword_forgot_password">Âstu dismenteât la password?</string>
     <string name="lockpassword_forgot_pattern">Âstu dismenteât la cumbinazion?</string>
     <string name="lockpassword_forgot_pin">Âstu dismenteât il PIN?</string>
+    <string name="lockpassword_confirm_your_pattern_generic">Dissegne la cumbinazion par continuâ</string>
+    <string name="lockpassword_confirm_your_pin_generic">Inserìs il PIN par continuâ</string>
+    <string name="lockpassword_confirm_your_password_generic">Inserìs la password par continuâ</string>
+    <string name="lockpassword_confirm_your_pattern_generic_profile">Dissegne la cumbinazion di lavôr par continuâ</string>
     <string name="lockpassword_confirm_your_pin_generic_profile">Inserìs il PIN di lavôr par continuâ</string>
     <string name="lockpassword_confirm_your_password_generic_profile">Inserìs la password di lavôr par continuâ</string>
     <string name="lockpassword_strong_auth_required_device_pattern">Par vê plui sigurece, dopre la cumbinazion dal dispositîf</string>
@@ -1272,6 +1529,13 @@
     <string name="lockpassword_confirm_your_pattern_header_frp">Verifiche cumbinazion</string>
     <string name="lockpassword_confirm_your_pin_header_frp">Verifiche PIN</string>
     <string name="lockpassword_confirm_your_password_header_frp">Verifiche password</string>
+    <string name="lockpassword_remote_validation_header">Verifiche la tô identitât</string>
+    <string name="lockpassword_remote_validation_pattern_details">Par trasferî Google Accounts, lis impostazions e ancjemò altri, inserìs la cumbinazion dal altri dispositîf. La tô cumbinazion e je cifrade.</string>
+    <string name="lockpassword_remote_validation_pin_details">Par trasferî Google Accounts, lis impostazions e ancjemò altri, inserìs il PIN dal altri dispositîf. Il to PIN al è cifrât.</string>
+    <string name="lockpassword_remote_validation_password_details">Par trasferî Google Accounts, lis impostazions e ancjemò altri, inserìs la password dal altri dispositîf. La tô password e je cifrade.</string>
+    <string name="lockpassword_remote_validation_set_pattern_as_screenlock">Sore dopre la cumbinazion par sblocâ chest dispositîf</string>
+    <string name="lockpassword_remote_validation_set_pin_as_screenlock">Sore dopre il PIN par sblocâ chest dispositîf</string>
+    <string name="lockpassword_remote_validation_set_password_as_screenlock">Sore dopre la password par sblocâ chest dispositîf</string>
     <string name="lockpassword_confirm_repair_mode_pattern_header">Verifiche cumbinazion</string>
     <string name="lockpassword_confirm_repair_mode_pin_header">Verifiche PIN</string>
     <string name="lockpassword_confirm_repair_mode_password_header">Verifiche password</string>
@@ -1281,6 +1545,7 @@
     <string name="lockpassword_invalid_pin">PIN sbaliât</string>
     <string name="lockpassword_invalid_password">Password sbaliade</string>
     <string name="lockpattern_need_to_unlock_wrong">Cumbinazion sbaliade</string>
+    <string name="work_challenge_emergency_button_text">Emergjence</string>
     <string name="lock_settings_title">Sigurece dal dispositîf</string>
     <string name="lockpattern_change_lock_pattern_label">Cambie cumbinazion di sbloc</string>
     <string name="lockpattern_change_lock_pin_label">Cambie PIN di sbloc</string>
@@ -1326,6 +1591,10 @@
     <string name="install_applications">Origjins no cognossudis</string>
     <string name="install_applications_title">Permet dutis lis origjins</string>
     <string name="recent_app_category_title">Aplicazions viertis di resint</string>
+    <string name="see_all_apps_title">{count, plural,
+      one {}=1      {Viôt dutis lis aplicazions}
+      other   {Viôt dutis # lis aplicazions}
+    }</string>
     <string name="forgot_password_title">Contate il to aministradôr di IT</string>
     <string name="forgot_password_text">A puedin judâti a ristabilî il PIN, la cumbinazion o la password</string>
     <string name="advanced_settings">Impostazions avanzadis</string>
@@ -1339,6 +1608,10 @@
     <string name="cache_header_label">Cache</string>
     <string name="clear_cache_btn_text">Nete memorie cache</string>
     <string name="cache_size_label">Cache</string>
+    <string name="uri_permissions_text">{count, plural,
+      one {}=1      {1 element}
+      other   {# elements}
+    }</string>
     <string name="clear_uri_btn_text">Nete acès</string>
     <string name="controls_label">Controi</string>
     <string name="force_stop">Sfuarce interuzion</string>
@@ -1469,6 +1742,7 @@
     <string name="language_keyboard_settings_title">Lenghis e imission</string>
     <string name="input_assistance">Struments</string>
     <string name="keyboard_settings_category">Tastiere e metodis di imission</string>
+    <string name="system_language">Lenghis di sisteme</string>
     <string name="phone_language">Lenghis</string>
     <string name="auto_replace">Sostituzion automatiche</string>
     <string name="auto_replace_summary">Corêç lis peraulis cun erôrs ortografics</string>
@@ -1496,21 +1770,56 @@
     <string name="show_ime">Dopre tastiere su schermi</string>
     <string name="show_ime_summary">Tegnile sul schermi intant che la tastiere fisiche e je ative</string>
     <string name="keyboard_shortcuts_helper">Scurtis di tastiere</string>
+    <string name="keyboard_shortcuts_helper_summary">Mostre la liste des scurtis</string>
     <string name="language_and_input_for_work_category_title">Tastieris e struments dal profîl di lavôr</string>
     <string name="virtual_keyboards_for_work_title">Tastiere su schermi pal lavôr</string>
     <string name="keyboard_default_layout">Predefinide</string>
+    <string name="trackpad_settings">Touchpad</string>
+    <string name="trackpad_mouse_settings">Touchpad e mouse</string>
+    <string name="trackpad_settings_summary">Veloctât pontadôr, mots</string>
+    <string name="trackpad_tap_to_click">Tocje par fâ clic</string>
+    <string name="trackpad_touchpad_gesture_title">Mots dal touchpad</string>
+    <string name="trackpad_touchpad_gesture_summary">Personalize i singui mots di navigazion dal touchpad</string>
+    <string name="trackpad_reverse_scrolling_title">Scoriment invertît</string>
+    <string name="trackpad_reverse_scrolling_summary">Il contignût si sposte in sù cuant che tu scoris in jù</string>
+    <string name="trackpad_bottom_right_tap_title">Tocjade in bas a diestre</string>
+    <string name="trackpad_bottom_right_tap_summary">Tocje il cjanton bas di diestre dal touchpad par altris opzions</string>
     <string name="trackpad_pointer_speed">Velocitât dal pontadôr</string>
+    <string name="trackpad_touch_gesture">Impare i mots dal touchpad</string>
+    <string name="gesture_title_go_home">Va al Inizi</string>
+    <string name="gesture_summary_go_home">Scor in sù cun trê dêts là che tu vûs sul touchpad</string>
     <string name="gesture_title_go_back">Tone indaûr</string>
+    <string name="gesture_summary_go_back">Scor di çampe a diestre cun trê dêts</string>
+    <string name="gesture_title_recent_apps">Viôt lis aplicazions resintis</string>
+    <string name="gesture_summary_recent_apps">Scor in sù cun trê dêts, ten fracât e dopo mole</string>
+    <string name="gesture_title_notifications">Viôt notifichis e impostaz. rapidis</string>
+    <string name="gesture_summary_notifications">Scor in jù cun trê dêts su la schermade di inizi</string>
+    <string name="gesture_title_switch_apps">Cambie aplicazions</string>
+    <string name="gesture_summary_switch_apps">Scor a çampe o a diestre cun cuatri dêts</string>
     <string name="gesture_button_skip">Salte</string>
     <string name="gesture_button_next">Indenant</string>
     <string name="gesture_button_restart">Torne invie</string>
     <string name="gesture_button_done">Fat</string>
     <string name="trackpad_go_back_title">Tone indaûr</string>
+    <string name="trackpad_go_back_summary">Scor a çampe o a diestre cun trê dêts</string>
+    <string name="trackpad_go_home_title">Va al Inizi</string>
+    <string name="trackpad_go_home_summary">Scor in sù cun trê dêts</string>
+    <string name="trackpad_recent_apps_title">Aplicazions resintis</string>
+    <string name="trackpad_recent_apps_summary">Scor in sù cun trê dêts, dopo ten fracât</string>
     <string name="trackpad_notifications_title">Notifichis</string>
+    <string name="trackpad_notifications_summary">Scor in jù cun trê dêts</string>
+    <string name="trackpad_switch_apps_title">Cambie aplicazions</string>
+    <string name="trackpad_switch_apps_summary">Scor a çampe o a diestre cun cuatri dêts</string>
+    <string name="modifier_keys_settings">Tascj modificadôrs</string>
+    <string name="modifier_keys_settings_summary">Cambie il compuartament dai tascj</string>
+    <string name="modifier_keys_reset_title">Ripristine dut</string>
     <string name="modifier_keys_default_summary">Predefinide</string>
+    <string name="modifier_keys_reset_message">Desideristu pardabon ripristinâ ducj i tascj modificadôrs al lôr valôr predefinît?</string>
     <string name="modifier_keys_done">Fat</string>
     <string name="modifier_keys_cancel">Anule</string>
     <string name="modifier_keys_reset">Ristabilìs</string>
+    <string name="modifier_keys_picker_title">Sielç tast modificadôr</string>
+    <string name="modifier_keys_picker_summary">Sielç un gnûf tast par <xliff:g id="modifier_key_default_name">%1$s</xliff:g>:</string>
     <string name="default_keyboard_layout">Predefinide</string>
     <string name="speech_category_title">Vôs</string>
     <string name="pointer_speed">Velocitât dal pontadôr</string>
@@ -1522,6 +1831,7 @@
     <string name="keyboard_layout_dialog_switch_hint">Par cambiâ, frache Control-Sbare di spazi</string>
     <string name="keyboard_layout_default_label">Predefinide</string>
     <string name="keyboard_layout_picker_title">Disposizions tastiere</string>
+    <string name="keyboard_layout_picker_category_title">Disposizions di tastiere fisiche</string>
     <string name="user_dict_settings_title">Dizionari personâl</string>
     <string name="user_dict_settings_for_work_title">Dizionari personâl pal lavôr</string>
     <string name="user_dict_settings_summary">Zonte peraulis di doprâ in aplicazions come il coretôr ortografic</string>
@@ -1544,13 +1854,19 @@
     <string name="user_dict_settings_more_languages">Altris lenghis…</string>
     <string name="testing">Verifiche</string>
     <string name="testing_sim_toolkit">SIM toolkit</string>
+    <string name="keyboard_settings_summary">Tastiere su schermi, struments</string>
+    <string name="keyboard_settings_with_physical_keyboard_summary">Tastiere su schermi, tastiere fisiche, struments</string>
     <string name="builtin_keyboard_settings_title">Tastiere fisiche</string>
+    <string name="enabled_locales_keyboard_layout">Disposizion</string>
     <string name="gadget_picker_title">Sielç gadget</string>
     <string name="widget_picker_title">Sielç widget</string>
     <string name="allow_bind_app_widget_activity_allow_bind_title">Creâ il widget e permeti l\'acès?</string>
     <string name="allow_bind_app_widget_activity_allow_bind">Dopo che tu âs creât il widget, la aplicazion e rivarà a acedi a dut ce che al ven visualizât.\n\nAplicazion: <xliff:g id="widget_host_name">%1$s</xliff:g>\nWidget: <xliff:g id="widget_label">%2$s</xliff:g>\n</string>
     <string name="allow_bind_app_widget_activity_always_allow_bind">Permet simpri a <xliff:g id="widget_host_name">%1$s</xliff:g> di creâ widgets e acedi ai lôr dâts</string>
     <string name="testing_usage_stats">Statistichis di utilizazion</string>
+    <string name="usage_stats_sort_by_usage_time">Ordene par timp di utilizazion</string>
+    <string name="usage_stats_sort_by_last_time_used">Ordene par ultime volte doprât</string>
+    <string name="usage_stats_sort_by_app_name">Ordene par non di aplicazion</string>
     <string name="last_time_used_label">Ultime volte doprât</string>
     <string name="usage_time_label">Timp di utilizazion</string>
     <string name="accessibility_settings">Acès facilitât</string>
@@ -1572,16 +1888,27 @@
     <string name="user_installed_services_category_title">Aplicazions discjariadis</string>
     <string name="experimental_category_title">Sperimentâls</string>
     <string name="feature_flags_dashboard_title">Opzions di funzionalitât</string>
+    <string name="bt_hci_snoop_log_filters_dashboard_title">Filtradure dal regjistri di intercetazion des comunicazions HCI dal Bluetooth</string>
+    <string name="bt_hci_snoop_log_filters_dashboard_summary">Stabilìs i filtris</string>
+    <string name="bt_hci_snoop_log_filters_dashboard_footer">Disative e ative il Bluetooth par aplicâ lis modifichis</string>
+    <string name="bt_hci_snoop_log_filter_pbap_title">Filtradure PBAD dal regjistri di intercetazion des comunicazions HCI dal Bluetooth</string>
+    <string name="bt_hci_snoop_log_filter_map_title">Filtradure MAP dal regjistri di intercetazion des comunicazions HCI dal Bluetooth</string>
+    <string name="bt_hci_snoop_log_filter_summary">Stabilìs la modalitât di filtradure. (Disative e ative il Bluetooth par aplicâ lis modifichis)</string>
+    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary">Par cambiâ cheste opzion, met a Filtrament ativât la modalitât regjistri intercetazion HCI Bluetooth</string>
     <string name="talkback_title">Talkback</string>
     <string name="talkback_summary">Letôr di schermi indreçât soredut aes personis vuarbis o che a viodin pôc</string>
     <string name="select_to_speak_summary">Tocje i elements sul schermi par scoltâ la lôr leture a dute vôs</string>
     <string name="accessibility_captioning_title">Preferencis sottitui</string>
     <string name="accessibility_captioning_about_title">Informazions su preferencis dai sottitui</string>
-    <string name="accessibility_captioning_footer_learn_more_content_description">Scuvierç di plui su lis preferencis relativisa ai sottitui</string>
+    <string name="accessibility_captioning_footer_learn_more_content_description">Scuvierç di plui su lis preferencis relativis ai sottitui</string>
     <string name="accessibility_screen_magnification_title">Ingrandiment</string>
     <string name="accessibility_screen_magnification_shortcut_title">Scurte pal ingrandiment</string>
     <string name="accessibility_screen_magnification_follow_typing_title">Ingrandìs scriture</string>
     <string name="accessibility_screen_magnification_follow_typing_summary">La lint di ingrandiment al sta daûr al test che tu scrivis</string>
+    <string name="accessibility_screen_magnification_always_on_title">Ten atîf intant che tu passis di une aplicazion a chê altre</string>
+    <string name="accessibility_screen_magnification_always_on_summary">L\'ingrandidôr al reste atîf e al impiçulìs l\'ingrandiment cuant che tu passis di une aplicazion a chê altre</string>
+    <string name="accessibility_screen_magnification_joystick_title">Jeve di control</string>
+    <string name="accessibility_screen_magnification_joystick_summary">Ative e sposte l\'ingrandidôr cuntune jeve di control su schermi. Tocje e ten fracât, dopo strissine la jeve di control par controlâ l\'ingrandidôr. Tocje e strissine par spostâ la stesse jeve di control.</string>
     <string name="accessibility_screen_magnification_about_title">Informazions sul ingrandiment</string>
     <string name="accessibility_screen_magnification_footer_learn_more_content_description">Scuvierç di plui sul ingrandiment</string>
     <string name="accessibility_magnification_mode_title">Gjenar di ingrandiment</string>
@@ -1603,7 +1930,6 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button">Continue distès</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button">Anule</string>
     <string name="accessibility_magnification_service_settings_title">Impostazions di ingrandiment</string>
-    <string name="accessibility_screen_magnification_gestures_title">Ingrandìs cun tocjade triple</string>
     <string name="accessibility_screen_magnification_navbar_title">Ingrandìs cun scurte</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture">Ingrandìs cun scurte e tocjade triple</string>
     <string name="accessibility_introduction_title">Informazions su <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
@@ -1685,8 +2011,6 @@
     <string name="accessibility_button_gesture_footer_learn_more_content_description">Scuvierç di plui sul boton e sul mot dal acès facilitât</string>
     <string name="accessibility_button_intro">Al ven doprât il boton di acès facilitât. Il mot nol è disponibil cu la navigazion a 3 botons.</string>
     <string name="accessibility_button_summary">Rive in mût rapit aes funzions di acès facilitât</string>
-    <string name="accessibility_button_gesture_description"><b>Par scomençâ</b>\n1. Va tes impostazions di acès facilitât\n2. Selezione une funzion e tocje la scurte\n3. Sielç se tu desideris doprâ un boton o un mot par acedi ae funzion</string>
-    <string name="accessibility_button_description"><b>Par scomençâ</b>\n1. Va tes impostazions di acès facilitât\n2. Selezione une funzion e tocje la scurte\n3. Sielç il boton par acedi ae funzion</string>
     <string name="accessibility_button_or_gesture_title">Dopre boton o mot</string>
     <string name="accessibility_button_location_title">Gjeolocalizazion</string>
     <string name="accessibility_button_size_title">Dimension</string>
@@ -1732,6 +2056,7 @@
             <li>\u00a0Par visualizâ un fonts scûr, al è pussibil doprâ in alternative il teme scûr</li>
         </ol>
         ]]></string>
+    <string name="accessibility_action_label_panel_slice">jentrâ tes impostazions</string>
     <string name="accessibility_autoclick_preference_title">Clic automatic (timp di stasi)</string>
     <string name="accessibility_autoclick_about_title">Informazions sul clic automatic (timp di stasi)</string>
     <string name="accessibility_autoclick_footer_learn_more_content_description">Scuvierç di plui sul clic automatic (timp di stasi)</string>
@@ -1774,6 +2099,7 @@
     <string name="accessibility_reduce_bright_colors_qs_tooltip_content">Tu puedis ancje zontâ aes impostazions rapidis la atenuazion extra de part superiôr dal schermi</string>
     <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content">Modalitât a une man zontade a impostazions rapidis. Scor in jù par ativâle o disativâle cuant che tu vûs.</string>
     <string name="accessibility_one_handed_mode_qs_tooltip_content">Tu puedis ancje zontâ aes impostazions rapidis  la modalitât a une man de part superiôr dal schermi</string>
+    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content">Dimension caratar zontade ae impostazions rapidis. Scor in jù par cambiâ la dimension dal caratar cuant che tu vûs.</string>
     <string name="accessibility_quick_settings_tooltip_dismiss">Scarte</string>
     <string name="accessibility_daltonizer_primary_switch_title">Dopre corezion dai colôrs</string>
     <string name="accessibility_daltonizer_shortcut_title">Scurte pe corezion dai colôrs</string>
@@ -1793,6 +2119,9 @@
     <string name="accessibility_shortcut_type_hardware">Ten fracâts i tascj dal volum</string>
     <string name="accessibility_shortcut_type_triple_tap">Triple tocjade di schermi</string>
     <string name="accessibility_hearingaid_instruction_continue_button">Continue</string>
+    <string name="accessibility_hearingaid_title">Dispositîfs pe scolte</string>
+    <string name="accessibility_hearingaid_intro">Tu puedis doprâ cul to telefon i aparâts acustics, i implants cocleârs e altris dispositîfs di amplificazion</string>
+    <string name="accessibility_hearingaid_not_connected_summary">Nissun dispositîf pe scolte colegât</string>
     <string name="accessibility_hearingaid_adding_summary">Zonte aparât acustic</string>
     <string name="accessibility_hearingaid_pair_instructions_title">Associe aparât acustic</string>
     <string name="accessibility_hearingaid_pair_instructions_message">Te schermade sucessive, tocje i tiei aparâts acustics. Tu podaressis vê di associâ la orele di çampe e chê di diestre in mût separât.\n\nControle che i tiei aparâts acustics a sedin impiâts e pronts pe associazion.</string>
@@ -1802,7 +2131,19 @@
     <string name="accessibility_hearingaid_left_and_right_side_device_summary"><xliff:g id="device_name" example="GN Hearing Aids">%1$s</xliff:g>, çampe e diestre</string>
     <string name="accessibility_hearingaid_more_device_summary"><xliff:g id="device_name" example="GN Hearing Aids">%1$s</xliff:g> plui un altri</string>
     <string name="accessibility_hearing_device_pairing_title">Associe gnûf dispositîf</string>
+    <string name="accessibility_pair_hearing_device_about_title">Informazions su Associe gnûf dispositîf</string>
+    <string name="accessibility_hearing_device_connected_title">Dispositîfs pe scolte</string>
     <string name="accessibility_hearing_device_saved_title">Dispositîfs salvâts</string>
+    <string name="accessibility_hearing_device_control">Controi dispositîfs pe scolte</string>
+    <string name="accessibility_hearing_device_shortcut_title">Scurte dispositîfs pe scolte</string>
+    <string name="accessibility_hac_mode_title">Compatibilitât aparâts acustics</string>
+    <string name="accessibility_hac_mode_summary">Miore la compatibilitât cun bobinis telefonichis e ridûs il rumôr</string>
+    <string name="accessibility_hearing_device_about_title">Informazions su dispositîfs pe scolte</string>
+    <string name="accessibility_hearing_device_footer_summary">Controle che il to dispositîf pe scolte al sedi atîf e pront pe associazion</string>
+    <string name="accessibility_hearing_device_pairing_page_title">Associe disp. pe scolte</string>
+    <string name="accessibility_found_hearing_devices">Disp. pe scolte disponibii</string>
+    <string name="accessibility_found_all_devices">No cjatistu il to dispositîf pe scolte?</string>
+    <string name="accessibility_list_all_devices_title">Viôt plui dispositîfs</string>
     <string name="accessibility_audio_adjustment_title">Regolazion dal audio</string>
     <string name="accessibility_toggle_audio_description_preference_title">Descrizion audio</string>
     <string name="accessibility_audio_description_summary">Scolte une descrizion di ce che al sta sucedint sul schermi tai films e spetacui supuartâts</string>
@@ -1831,6 +2172,22 @@
     <string name="reduce_bright_colors_intensity_start_label">Mancul luminôs</string>
     <string name="reduce_bright_colors_intensity_end_label">Plui luminôs</string>
     <string name="reduce_bright_colors_persist_preference_title">Ten ative la opzion dopo dal gnûf inviament dal dispositîf</string>
+    <string name="accessibilty_autoclick_preference_subtitle_short_delay">{count, plural,
+      one {}=1      {Curt ({time} secont)}
+      other   {Curt ({time} seconts)}
+    }</string>
+    <string name="accessibilty_autoclick_preference_subtitle_medium_delay">{count, plural,
+      one {}=1      {Medi ({time} secont)}
+      other   {Medi ({time} seconts)}
+    }</string>
+    <string name="accessibilty_autoclick_preference_subtitle_long_delay">{count, plural,
+      one {}=1      {Lunc ({time} secont)}
+      other   {Lunc ({time} seconts)}
+    }</string>
+    <string name="accessibilty_autoclick_delay_unit_second">{count, plural,
+      one {}=1      {{time} secont}
+      other   {{time} seconts}
+    }</string>
     <string name="accessibility_menu_item_settings">Impostazions</string>
     <string name="accessibility_feature_state_on">On</string>
     <string name="accessibility_feature_state_off">Off</string>
@@ -1887,27 +2244,30 @@
         cun une aplicazion o un sensôr hardware e interagjî cun aplicazions al to puest.</string>
     <string name="accessibility_dialog_button_allow">Permet</string>
     <string name="accessibility_dialog_button_deny">Dinee</string>
-    <string name="accessibility_dialog_button_stop">Ferme</string>
-    <string name="accessibility_dialog_button_cancel">Anule</string>
-    <string name="disable_service_title">Fermâ <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
-    <string name="disable_service_message">Tocjant <xliff:g id="stop" example="Stop">%1$s</xliff:g> tu
-        interomparâs <xliff:g id="service" example="TalkBack">%2$s</xliff:g>.</string>
+    <string name="accessibility_dialog_button_stop">Disative</string>
     <string name="accessibility_no_services_installed">Nissun servizi instalât</string>
     <string name="accessibility_no_service_selected">Nissun servizi selezionât</string>
     <string name="accessibility_service_default_description">Nissune descrizion furnide.</string>
     <string name="settings_button">Impostazions</string>
     <string name="keywords_reduce_bright_colors">sensibilitât ae lûs, fotofobie, teme scûr, emicranie, mal di cjâf, modalitât leture, modalitât gnot, ridûs luminositât, pont dal blanc</string>
-    <string name="keywords_accessibility">Facilitât di utilizazion, facilitât di acès, assistence, assistenziâl</string>
     <string name="keywords_magnification">ingrandiment dal barcon, zoom, ingrandiment, viste scjarse, slargje, rint plui grant</string>
     <string name="keywords_live_caption">sottitui, CC, trascrizion in timp reâl, problemis di uldide, pierdite di uldide, CART, conversion vôs in test, fevele in test, sottitul</string>
     <string name="keywords_display_size">dimension schermi, schermi grant</string>
     <string name="keywords_bold_text">contrast elevât, viste scjarse, caratar neret, neret</string>
     <string name="keywords_color_correction">regolazion colôr</string>
     <string name="keywords_color_inversion">impostazion schermi scûr, impostazion schermi clâr</string>
-    <string name="keywords_auto_click">motôr, mouse</string>
+    <string name="keywords_contrast">contrast colôrs</string>
     <string name="keywords_rtt">fadie a sintî, pierdite di uldide, sort, sottitui, Teletype, tty</string>
     <string name="print_settings">Stampe</string>
     <string name="print_settings_summary_no_service">Off</string>
+    <string name="print_settings_summary">{count, plural,
+      one {}=1      {1 servizi di stampe atîf}
+      other   {# servizis di stampe atîfs}
+    }</string>
+    <string name="print_jobs_summary">{count, plural,
+      one {}=1      {1 lavôr di stampe}
+      other   {# lavôrs di stampe}
+    }</string>
     <string name="print_settings_title">Servizis di stampe</string>
     <string name="print_no_services_installed">Nissun servizi instalât</string>
     <string name="print_no_printers_found">Nissune stampadore cjatade</string>
@@ -1939,11 +2299,13 @@
             - <xliff:g id="status">%2$s</xliff:g></string>
     <string name="power_discharge_remaining">A restin <xliff:g id="remain">%1$s</xliff:g></string>
     <string name="power_charge_remaining"><xliff:g id="until_charged">%1$s</xliff:g> ae ricjarie</string>
+    <string name="power_usage_detail_screen_time">Timp di utilizazion</string>
     <string name="low_battery_summary">Batarie in esauriment</string>
     <string name="background_activity_summary">Permet ae aplicazion di zirâ in sotfont</string>
     <string name="background_activity_warning_dialog_title">Limitâ in sotfont la ativitât?</string>
     <string name="background_activity_warning_dialog_text">Se tu limitis la ativitât in sotfont par une aplicazion, cheste aplicazion e podarès funzionâ in mût anomal</string>
     <string name="background_activity_disabled_dialog_text">Par limitâ la aplicazion, prime ative la otimizazion de batarie.</string>
+    <string name="manager_battery_usage_category_title">Gjestìs utilizazion de batarie</string>
     <string name="manager_battery_usage_unrestricted_title">Cence limitazions</string>
     <string name="manager_battery_usage_optimized_title">Otimizade</string>
     <string name="manager_battery_usage_restricted_title">Cun limitazions</string>
@@ -1973,10 +2335,12 @@
     <string name="battery_tip_early_heads_up_title">Ative Sparagn energjetic</string>
     <string name="battery_tip_early_heads_up_summary">La batarie e podarès esaurîsi prime dal solit</string>
     <string name="battery_tip_early_heads_up_done_title">Sparagn energjetic on</string>
+    <string name="battery_saver_link_a11y">Scuvierç di plui sul sparagn energjetic</string>
     <string name="battery_tip_early_heads_up_done_summary">Cualchi funzion e podarès vê limitazions</string>
     <string name="battery_tip_high_usage_title">Consum elevât di batarie</string>
     <string name="battery_tip_high_usage_summary">Viôt lis aplicazions che a consumin di plui</string>
     <string name="battery_tip_limited_temporarily_title">Ricjarie otimizade par protezi la batarie</string>
+    <string name="battery_tip_limited_temporarily_summary">Par judâ a slungjâ la vite de batarie, la ricjarie e je otimizade</string>
     <string name="battery_tip_dock_defender_future_bypass_title">Ricjarie otimizade par protezi la batarie</string>
     <string name="battery_tip_dock_defender_future_bypass_summary">Par judâ a slungjâ la vite de batarie, la ricjarie e je otimizade intant che il dispositîf al è colegât ae base</string>
     <string name="battery_tip_dock_defender_active_title">Ricjarie otimizade par protezi la batarie</string>
@@ -1986,6 +2350,26 @@
     <string name="battery_tip_limited_temporarily_sec_button_content_description">Plui informazions su la ricjarie in pause</string>
     <string name="battery_tip_limited_temporarily_dialog_resume_charge">Ripie la ricjarie</string>
     <string name="battery_tip_dialog_message_footer">Al inclût lis ativitâts in sotfont che a consumin tant</string>
+    <string name="battery_tip_restrict_title">{count, plural,
+      one {}=1      {Limite # aplicazion}
+      other   {Limite # aplicazions}
+    }</string>
+    <string name="battery_tip_restrict_handled_title">{count, plural,
+      one {}=1      {{label} limitade di resint}
+      other   {# aplicazions limitadis di resint}
+    }</string>
+    <string name="battery_tip_restrict_summary">{count, plural,
+      one {}=1      {{label} e consume tante batarie in sotfont}
+      other   {# aplicazions e consumin tante batarie in sotfont}
+    }</string>
+    <string name="battery_tip_restrict_handled_summary">{count, plural,
+      one {}=1      {Cheste aplicazion no pues zirâ in sotfont}
+      other   {Chestis aplicazions no puedin zirâ in sotfont}
+    }</string>
+    <string name="battery_tip_restrict_app_dialog_title">{count, plural,
+      one {}=1      {Limitâ la aplicazion?}
+      other   {Limitâ # aplicazions?}
+    }</string>
     <string name="battery_tip_restrict_app_dialog_message">Par sparagnâ batarie, ferme <xliff:g id="app">%1$s</xliff:g> dal consumâ batarie in sotfont. Al è pussibil che cheste aplicazion no funzioni ben e che lis notifichis a rivedin in ritart.</string>
     <string name="battery_tip_restrict_apps_less_than_5_dialog_message">Par sparagnâ batarie, ferme chestis aplicazions dal consumâ batarie in sotfont. Al è pussibil che lis aplicazions limitadis no funzionin ben e che lis notifichis a rivedin in ritart.\n\nAplicazions:</string>
     <string name="battery_tip_restrict_apps_more_than_5_dialog_message">Par sparagnâ batarie, ferme chestis aplicazions dal consumâ batarie in sotfont. Al è pussibil che lis aplicazions limitadis no funzionin ben e che lis notifichis a rivedin in ritart.\n\nAplicazions:\n<xliff:g id="app_list">%1$s</xliff:g>.</string>
@@ -1995,20 +2379,31 @@
     <string name="battery_tip_unrestrict_app_dialog_ok">Gjave</string>
     <string name="battery_tip_unrestrict_app_dialog_cancel">Anule</string>
     <string name="battery_tip_charge_to_full_button">Ricjarie dal dut</string>
+    <string name="battery_tip_incompatible_charging_title">Proleme cul acessori pe ricjarie</string>
+    <string name="battery_tip_incompatible_charging_content_description">Scuvierç di plui su la ricjarie incompatibile</string>
     <string name="smart_battery_manager_title">Gjestôr batarie</string>
     <string name="smart_battery_title">Gjestìs aplicazions in automatic</string>
     <string name="smart_battery_footer">Cuant che Gjestôr batarie al rileve che lis aplicazions a consumin batarie, tu podarâs decidi se limitâlis. Al è pussibil che lis aplicazions limitadis no funzionin ben e che lis notifichis a rivedin in ritart.</string>
     <string name="restricted_app_title">Aplicazions limitadis</string>
+    <string name="restricted_app_summary">{count, plural,
+      one {}=1      {Daûr a limitâ il consum di batarie par # aplicazion}
+      other   {Daûr a limitâ il consum di batarie par # aplicazions}
+    }</string>
     <string name="restricted_app_time_summary">Limitazion aplicade <xliff:g id="time" example="5 days ago">%1$s</xliff:g></string>
     <string name="restricted_app_detail_footer">Chestis aplicazion a àn limitazions pal ûs de batarie in sotfont. Al è pussibil che no funzionin come intindût e lis notifichis a podaressin rivâ in ritart.</string>
     <string name="battery_auto_restriction_title">Dopre Gjestôr batarie</string>
     <string name="battery_auto_restriction_summary">Rileve se lis aplicazions a consumin batarie</string>
     <string name="battery_manager_summary">Rilevament dal moment che lis aplicazions a discjariin batarie</string>
     <string name="battery_manager_summary_unsupported">Rilevament dal moment che lis aplicazions a discjariin batarie</string>
+    <string name="battery_manager_app_restricted">{count, plural,
+      one {}=1      {# aplicazion limitade}
+      other   {# aplicazions limitadis}
+    }</string>
     <string name="battery_header_title_alternate"><xliff:g id="number" example="88">^1</xliff:g><small> <font size="20"><xliff:g id="unit" example="%">%</xliff:g></font></small></string>
     <string name="battery_missing_message">Probleme tal lei l\'indicadôr di nivel de batarie.</string>
     <string name="battery_missing_link_a11y_message">Tocje par savênt di plui su chest erôr</string>
     <string name="power_screen">Schermi</string>
+    <string name="power_cpu">CPU</string>
     <string name="power_flashlight">Torce</string>
     <string name="power_camera">Fotocjamare</string>
     <string name="power_gps">GPS</string>
@@ -2022,9 +2417,12 @@
     <string name="battery_detail_since_full_charge">Analisi detaiade de ultime ricjarie complete</string>
     <string name="battery_last_full_charge">Ultime ricjarie complete</string>
     <string name="battery_full_charge_last">La cjarie complete e dure cirche</string>
+    <string name="battery_footer_summary">La durade de batarie che e reste e je aprossimative e e pues variâ in base ae utilizazion</string>
     <string name="battery_detail_power_usage">Ûs de batarie</string>
     <string name="battery_not_usage">Nissune utilizazion de ultime ricjarie complete</string>
     <string name="battery_not_usage_24hr">Nissune utilizazion tes ultimis 24 oris</string>
+    <string name="battery_usage_since_last_full_charge">de ultime ricjarie complete</string>
+    <string name="battery_usage_system_apps">Aplicazions di sisteme</string>
     <string name="battery_usage_others">Altris</string>
     <string name="estimated_time_left">Timp restant stimât</string>
     <string name="estimated_charging_time_left">Timp restant ae cjarie complete</string>
@@ -2044,6 +2442,8 @@
     <string name="battery_saver_schedule_settings_title">Stabilìs une programazion</string>
     <string name="battery_saver_turn_on_summary">Slungje la durade de batarie</string>
     <string name="battery_saver_sticky_title_new">Disative co e je cjame</string>
+    <string name="battery_saver_sticky_title_percentage">Disative al <xliff:g id="battery_percentage" example="80%">%1$s</xliff:g></string>
+    <string name="battery_saver_sticky_description_new">Il Sparagn energjetic si disative cuant che la batarie e rive al <xliff:g id="battery_percentage" example="80%">%1$s</xliff:g></string>
     <string name="battery_saver_seekbar_title"><xliff:g id="percent">%1$s</xliff:g></string>
     <string name="battery_saver_seekbar_title_placeholder">Ative</string>
     <string name="battery_saver_master_switch_title">Dopre Sparagn energjetic</string>
@@ -2060,14 +2460,29 @@
     <string name="battery_system_usage_for_past_24">Utilizazion de bande dal sisteme tes ultimis 24 oris</string>
     <string name="battery_system_usage_for">Utilizazion de bande dal sisteme te dade di timp <xliff:g id="slot">%s</xliff:g></string>
     <string name="battery_app_usage_for">Utilizazion de bande des aplicazions te dade di timp <xliff:g id="slot">%s</xliff:g></string>
+    <string name="battery_system_usage_since_last_full_charge_to">Consum dal sisteme partint de ultime ricjarie complete fin <xliff:g id="slot_timestamp" example="Friday 10 am">%s</xliff:g></string>
+    <string name="battery_app_usage_since_last_full_charge_to">Consum de aplicazion partint de ultime ricjarie complete fin <xliff:g id="slot_timestamp" example="Friday 10 am">%s</xliff:g></string>
     <string name="battery_usage_total_less_than_one_minute">Totâl: mancul di un minût</string>
     <string name="battery_usage_background_less_than_one_minute">In sotfont: mancul di un minût</string>
+    <string name="battery_usage_screen_time_less_than_one_minute">Timp di utilizazion: mancul di un min</string>
     <string name="battery_usage_for_total_time">Totâl: <xliff:g id="time">%s</xliff:g></string>
     <string name="battery_usage_for_background_time">In sotfont: <xliff:g id="time">%s</xliff:g></string>
+    <string name="battery_usage_screen_time">Timp di utilizazion: <xliff:g id="time">%s</xliff:g></string>
     <string name="battery_usage_screen_footer_empty">I dâts di utilizazion de batarie a saran disponibii ca di pocjis oris une volte cjamade dal dut</string>
+    <string name="battery_usage_chart_label_now">cumò</string>
+    <string name="battery_usage_timestamps_hyphen"><xliff:g id="from_timestamp">%1$s</xliff:g> - <xliff:g id="to_timestamp">%2$s</xliff:g></string>
+    <string name="battery_usage_day_and_hour"><xliff:g id="day">%1$s</xliff:g> <xliff:g id="hour">%2$s</xliff:g></string>
     <string name="battery_usage_chart">Grafic de utilizazion de batarie</string>
     <string name="daily_battery_usage_chart">Grafic zornalîr de utilizazion de batarie</string>
     <string name="hourly_battery_usage_chart">Grafic orari de utilizazion de batarie</string>
+    <string name="battery_usage_breakdown_title_since_last_full_charge">Consum di batarie partint de ultime ricjarie complete</string>
+    <string name="battery_usage_breakdown_title_for_slot">Consum di batarie tal periodi <xliff:g id="slot">%s</xliff:g></string>
+    <string name="screen_time_category_last_full_charge">Timp di utilizazion de ultime ricjarie complete</string>
+    <string name="screen_time_category_for_slot">Timp di utilizazion tal periodi <xliff:g id="slot">%s</xliff:g></string>
+    <string name="battery_usage_spinner_view_by_apps">Viôt par aplicazions</string>
+    <string name="battery_usage_spinner_view_by_systems">Viôt par sistemis</string>
+    <string name="battery_usage_less_than_percent">&lt; <xliff:g id="percentage">%1$s</xliff:g></string>
+    <string name="battery_cycle_count_footer">Par vie dai controi di cualitât prime de spedizion, al è pussibil che la conte dai ciclis no sedi zero ae prime utilizazion</string>
     <string name="process_stats_summary_title">Statistichis sui procès</string>
     <string name="process_stats_summary">Statistichis tecnichis sui procès in esecuzion</string>
     <string name="app_memory_use">Memorie doprade</string>
@@ -2141,6 +2556,7 @@
     <string name="adaptive_connectivity_summary">E slungje la durade de batarie e e miore lis prestazions dal dispositîf gjestint in automatic lis conessions di rêt</string>
     <string name="adaptive_connectivity_switch_on">On</string>
     <string name="adaptive_connectivity_switch_off">Off</string>
+    <string name="adaptive_connectivity_main_switch_title">Dopre conetivitât adative</string>
     <string name="credentials_title">Archivi credenziâls</string>
     <string name="credentials_install">Instale un certificât</string>
     <string name="credentials_reset">Nete lis credenziâls</string>
@@ -2152,6 +2568,8 @@
     <string name="advanced_security_title">Avanzadis</string>
     <string name="credentials_settings_not_available">Lis credenziâls no son disponibilis par chest utent</string>
     <string name="credential_for_vpn_and_apps">Instaladis par VPN e aplicazions</string>
+    <string name="credential_for_wifi">Instalade pal Wi\u2011Fi</string>
+    <string name="credential_for_wifi_in_use">Instalade pal Wi\u2011Fi (In ûs)</string>
     <string name="credentials_reset_hint">Gjavâ ducj i contignûts?</string>
     <string name="credentials_erased">Memorie credenziâls scancelade.</string>
     <string name="credentials_not_erased">Impuss. scancelâ mem. credenz.</string>
@@ -2176,11 +2594,13 @@
     <string name="remove_credential_management_app">Gjave aplicazion</string>
     <string name="remove_credential_management_app_dialog_title">Gjavâ cheste aplicazion?</string>
     <string name="remove_credential_management_app_dialog_message">Cheste aplicazion no gjestirà i certificâts, ma e restarà sul to dispositîf. Ducj i certificâts instalâts de aplicazion a vignaran disinstalâts.</string>
+    <string name="number_of_urls">{count, plural,
+      one {}=1      {# URL}
+      other   {# URLs}
+    }</string>
     <string name="emergency_tone_title">Segnâl clamade di emergjence</string>
     <string name="emergency_tone_summary">Stabilìs il compuartament tal câs di clamade di emergjence</string>
     <string name="privacy_settings_title">Backup</string>
-    <string name="backup_summary_state_on">On</string>
-    <string name="backup_summary_state_off">Off</string>
     <string name="backup_section_title">Backup e ripristinament</string>
     <string name="personal_data_section_title">Dâts personâi</string>
     <string name="backup_data_title">Backup dai miei dâts</string>
@@ -2225,8 +2645,13 @@
     <string name="admin_more_details">Plui informazions</string>
     <string name="notification_log_title">Regjistri notifichis</string>
     <string name="notification_history_title">Cronologjie des notifichis</string>
+    <string name="notification_history_today">Ultimis %d oris</string>
     <string name="notification_history_snooze">Posticipadis</string>
     <string name="notification_history_dismiss">Scartadis di resint</string>
+    <string name="notification_history_count">{count, plural,
+      one {}=1      {# notifiche}
+      other   {# notifichis}
+    }</string>
     <string name="sound_category_call_ringtone_vibrate_title">Sunarie e vibrazion clamade</string>
     <string name="wifi_setup_detail">Detais de rêt</string>
     <string name="accessibility_sync_enabled">Sincronizazion abilitade</string>
@@ -2239,6 +2664,7 @@
     <string name="sync_is_failing">In chest moment la sincronizazion e sta vint problemis. In curt si ripiarà.</string>
     <string name="add_account_label">Zonte account</string>
     <string name="managed_profile_not_available_label">Il profîl di lavôr nol è ancjemò disponibil</string>
+    <string name="work_mode_label">Aplicazions di lavôr</string>
     <string name="remove_managed_profile_label">Gjave profîl di lavôr</string>
     <string name="background_data">Dâts in sotfont</string>
     <string name="background_data_summary">Lis aplicaz. a puedin sincronizâ, inviâ e ricevi dâts simpri</string>
@@ -2322,30 +2748,18 @@
     <string name="vpn_name">Non</string>
     <string name="vpn_type">Gjenar</string>
     <string name="vpn_server">Direzion servidôr</string>
-    <string name="vpn_mppe">Criptografie PPP (MPPE)</string>
-    <string name="vpn_l2tp_secret">Segret L2TP</string>
     <string name="vpn_ipsec_identifier">Identificadôr IPSec</string>
     <string name="vpn_ipsec_secret">Clâf pre-condividude IPSec</string>
     <string name="vpn_ipsec_user_cert">Certificât utent IPSec</string>
     <string name="vpn_ipsec_ca_cert">Certificât CA IPSec</string>
     <string name="vpn_ipsec_server_cert">Certificât servidôr IPSec</string>
     <string name="vpn_show_options">Mostre opzions avanzadis</string>
-    <string name="vpn_search_domains">Dominis di ricercje DNS</string>
-    <string name="vpn_dns_servers">Servidôrs DNS (p.e. 8.8.8.8)</string>
-    <string name="vpn_routes">Direzions par mandâ indenant (p.e. 10.0.0.0/8)</string>
     <string name="vpn_username">Non utent</string>
     <string name="vpn_password">Password</string>
     <string name="vpn_save_login">Salve informazions account</string>
     <string name="vpn_not_used">(no doprât)</string>
     <string name="vpn_no_ca_cert">(no sta verificâ il servidôr)</string>
     <string name="vpn_no_server_cert">(ricevût dal servidôr)</string>
-    <string name="vpn_always_on_invalid_reason_type">Chest gjenar di VPN nol pues restâ simpri conetût</string>
-    <string name="vpn_always_on_invalid_reason_server">La VPN simpri ative e supuarte dome direzions di servidôr
-        numerichis</string>
-    <string name="vpn_always_on_invalid_reason_no_dns">Al è necessari specificâ un servidôr DNS pe VPN
-        simpri ative</string>
-    <string name="vpn_always_on_invalid_reason_dns">Lis direzions di servidôr DNS a scugnin sei numerichis pe
-        VPN simpri ative</string>
     <string name="vpn_always_on_invalid_reason_other">Lis informazions inseridis no supuartin la
         VPN simpri ative</string>
     <string name="vpn_cancel">Anule</string>
@@ -2398,6 +2812,11 @@
     <string name="trusted_credentials_enable_confirmation">Abilitâ il certificât CA di sisteme?</string>
     <string name="trusted_credentials_disable_confirmation">Disabilitâ il certificât CA di sisteme?</string>
     <string name="trusted_credentials_remove_confirmation">Gjavâ par simpri il certificât CA dal utent?</string>
+    <string name="credential_being_used_by">In ûs di</string>
+    <string name="credential_contains">Cheste vôs e conten</string>
+    <string name="one_userkey">1 clâf utent</string>
+    <string name="one_usercrt">1 certificât utent</string>
+    <string name="one_cacrt">1 Certificât CA</string>
     <string name="n_cacrts">%d certificâts de CA</string>
     <string name="user_credential_title">Detais des credenziâls</string>
     <string name="user_credential_removed">Credenziâl gjavade: <xliff:g id="credential_name" example="signing key">%s</xliff:g></string>
@@ -2412,6 +2831,10 @@
     <string name="additional_system_update_settings_list_item_title">Inzornaments di sisteme adizionâi</string>
     <string name="ssl_ca_cert_warning">La rêt e podarès jessi monitorade</string>
     <string name="done_button">Fat</string>
+    <string name="ssl_ca_cert_dialog_title">{count, plural,
+      one {}=1      {Fiditi o gjave il certificât}
+      other   {Fiditi o gjave i certificâts}
+    }</string>
     <string name="ssl_ca_cert_info_message_device_owner"> {numberOfCertificates, plural,
         one {}=1 {{orgName} al à instalât une autoritât di certificazion sul to dispositîf, che ur podarès permeti di monitorâ la ativitât di rêt dal to dispositîf, includudis e-mails, apliazions e sîts web signûrs.\n\nPar vê plui informazions su chest certificât, contate il to aministradôr.}
         other {{orgName} al à instalât autoritâts di certificazion sul to dispositîf, che ur podarès permeti di monitorâ la ativitât di rêt dal to dispositîf, includudis e-mails, aplicazions e sîts web sigûrs.\n\nPar vê plui informazions su chescj certificâts, contate il to aministradôr.}
@@ -2421,6 +2844,10 @@
         other {{orgName} al à instalât autoritâts di certificazion pal to profîl di lavôr, che ur podarès permeti di monitorâ la ativitât di rêt di lavôr, includudis e-mails, aplicazions e sîts web sigûrs.\n\nPar vê plui informazions su chescj certificâts, contate il to aministradôr.}
         }</string>
     <string name="ssl_ca_cert_warning_message">Une tierce part e pues monitorâ la tô ativitât in rêt, includudis lis e-mails, lis aplicazions e i sîts web di sigurece.\n\nChest al è pussibil par vie di une credenziâl atendibile instalade.</string>
+    <string name="ssl_ca_cert_settings_button">{count, plural,
+      one {}=1      {Controle certificât}
+      other   {Controle certificâts}
+    }</string>
     <string name="user_settings_title">Utents multiplis</string>
     <string name="user_list_title">Utents e profîi</string>
     <string name="user_add_user_or_profile_menu">Zonte utent o profîl</string>
@@ -2457,10 +2884,16 @@
     <string name="remove_guest_on_exit_dialog_title">Eliminâ la ativitât dal ospit?</string>
     <string name="remove_guest_on_exit_dialog_message">Lis aplicazions e i dâts di cheste session a vignaran
         eliminâts cumò e dutis lis ativitâts dal ospit futuris a vignaran eliminadis ogni volte che tu jessarâs de modalitât ospit</string>
+    <string name="remove_guest_on_exit_keywords">elimine, ospit, ativitât, gjave, dâts, visitadôr, scancele</string>
+    <string name="enable_guest_calling">Permet al ospit di fâ clamadis cul tel.</string>
+    <string name="enable_guest_calling_summary">La cronologjie des clamadis e vignarà condividude cul utent ospit</string>
     <string name="user_enable_calling_sms">Ative clamadis telefonichis e SMS</string>
+    <string name="user_grant_admin">Rint aministradôr chest utent</string>
     <string name="user_remove_user">Elimine utent</string>
     <string name="user_enable_calling_and_sms_confirm_title">Ativâ lis clamadis telefonichis e i SMS?</string>
     <string name="user_enable_calling_and_sms_confirm_message">La cronologjie des clamadis e dai SMS e vignarà condividude cun chest utent.</string>
+    <string name="user_revoke_admin_confirm_title">Gjavâ i privileçs di aministradôr?</string>
+    <string name="user_revoke_admin_confirm_message">Se tu gjavis i privileçs di aministradôr a chest utent, tu o un altri aministradôr o podarês tornâ a dâjai plui indevant.</string>
     <string name="emergency_info_title">Informazions di emergjence</string>
     <string name="emergency_info_summary">Dâts e contats di <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>
     <string name="open_app_button">Vierç <xliff:g id="app_name" example="Safety">%1$s</xliff:g></string>
@@ -2515,10 +2948,6 @@
     <string name="amber_alerts_title">Alertis AMBER</string>
     <string name="amber_alerts_summary">Ricêf boletins su secuestris di fruts</string>
     <string name="repeat_title">Ripet</string>
-    <string name="call_manager_enable_title">Abilite gjestôr clamadis</string>
-    <string name="call_manager_enable_summary">Permet a chest servizi di gjestî cemût che a vegnin fatis lis clamadis.</string>
-    <string name="call_manager_title">Gjestôr clamadis</string>
-    <string name="call_manager_summary"><xliff:g id="app">%1$s</xliff:g></string>
     <string name="cell_broadcast_settings">Alertis di emergjence wireless</string>
     <string name="network_operators_settings">Operadôrs di rêt</string>
     <string name="access_point_names">Nons dai ponts di acès</string>
@@ -2539,6 +2968,9 @@
     <string name="preferred_network_type_summary">LTE (opzion conseade)</string>
     <string name="mms_message_title">Messaçs MMS</string>
     <string name="mms_message_summary">Invie e ricêf cuant che i dâts mobii no son atîfs</string>
+    <string name="auto_data_switch_title">Cambie dâts mobii in automatic</string>
+    <string name="auto_data_switch_summary">        Dopre cheste rêt se e à une conession miôr
+    </string>
     <string name="work_sim_title">SIM di lavôr</string>
     <string name="user_restrictions_title">Acès a aplicazions e contignûts</string>
     <string name="user_rename">CAMBIE NON</string>
@@ -2573,13 +3005,14 @@
     <string name="sim_status_title">Stât de SIM</string>
     <string name="sim_status_title_sim_slot">Stât de SIM (fressure sim %1$d)</string>
     <string name="sim_signal_strength"><xliff:g id="dbm">%1$d</xliff:g> dBm <xliff:g id="asu">%2$d</xliff:g> asu</string>
+    <string name="sim_notification_title">SIMs cambiadis.</string>
     <string name="sim_notification_summary">Tocje par configurâ</string>
     <string name="sim_calls_ask_first_prefs_title">Domande ogni volte</string>
     <string name="sim_selection_required_pref">Fâs une sielte</string>
     <string name="sim_selection_channel_title">Selezion de SIM</string>
     <string name="dashboard_title">Impostazions</string>
     <string name="network_dashboard_title">Rêt e internet</string>
-    <string name="network_dashboard_summary_mobile">Mobil, Wi\u2011Fi, pont di acès</string>
+    <string name="network_dashboard_summary_mobile">Mobile, Wi\u2011Fi, pont di acès</string>
     <string name="network_dashboard_summary_no_mobile">Wi\u2011Fi, pont di acès</string>
     <string name="connected_devices_dashboard_title">Dispositîfs conetûts</string>
     <string name="connected_devices_dashboard_default_summary">Bluetooth, associazion</string>
@@ -2598,7 +3031,18 @@
     <string name="account_dashboard_title">Passwords e accounts</string>
     <string name="account_dashboard_default_summary">Passwords salvadis, compilazion automatiche, accounts sincronizâts</string>
     <string name="app_default_dashboard_title">Aplicazions predefinidis</string>
+    <string name="cloned_apps_dashboard_title">Aplicazions clonadis</string>
+    <string name="desc_cloned_apps_intro_text">Cree une seconde istance di une aplicazion, in mût che tu podedis doprâ doi accounts tal stes timp.</string>
+    <string name="desc_cloneable_app_list_text">Aplicazions che tu puedis clonâ.</string>
+    <string name="cloned_apps_summary"><xliff:g id="cloned_apps_count">%1$s</xliff:g> clonadis, <xliff:g id="allowed_apps_count">%2$d</xliff:g> disponibilis pe clonazion</string>
+    <string name="delete_all_app_clones">Elimine dutis lis aplicazions clon</string>
+    <string name="delete_all_app_clones_failure">Elimine ducj i clons di aplicazion falîts</string>
+    <string name="cloned_app_creation_summary">Daûr a creâ…</string>
+    <string name="cloned_app_created_summary">Clonade</string>
+    <string name="cloned_app_creation_toast_summary">Creazion dal clon di <xliff:g id="package_label">%1$s</xliff:g></string>
+    <string name="cloned_app_created_toast_summary">Clon di <xliff:g id="package_label">%1$s</xliff:g> creât</string>
     <string name="system_dashboard_summary">Lenghis, mots, ore, backup</string>
+    <string name="languages_setting_summary">Lenghis di sisteme, lenghis aplicazions, preferencis regjonâls, fevelade</string>
     <string name="keywords_wifi">wifi, wi-fi, conession di rêt, internet, cence fîi, dâts, wi fi</string>
     <string name="keywords_wifi_notify_open_networks">notifiche Wi\u2011Fi, notifiche wifi</string>
     <string name="keywords_wifi_data_usage">utilizazion dai dâts</string>
@@ -2648,16 +3092,22 @@
     <string name="keywords_app_pinning">fissâ sul schermi</string>
     <string name="keywords_profile_challenge">sfide lavôr, lavôr, profîl</string>
     <string name="keywords_unification">profîl di lavôr, profîl gjestît, unificâ, unificazion, lavôr, profîl</string>
+    <string name="keywords_fold_lock_behavior">        dismovi, polsâ, no sta blocâ, reste sblocât sierant il tapon, sierâ il tapon, sierâ, schermi distudât
+    </string>
     <string name="keywords_gesture">mots</string>
     <string name="keywords_wallet">tacuin</string>
     <string name="keywords_payment_settings">paie, tocje, paiaments</string>
     <string name="keywords_backup">backup</string>
-    <string name="keywords_assist_gesture_launch">mot</string>
     <string name="keywords_face_unlock">muse, sbloc, jentrâ, autorizâ</string>
     <string name="keywords_biometric_unlock">muse, sbloc, autorizazion, jentrâ, impront, biometrie</string>
     <string name="keywords_imei_info">imei, meid, min, version prl, imei sv</string>
+    <string name="keywords_sim_status">rêt, stât de rêt mobile, stât dal servizi, fuarce dal segnâl, gjenar di rêt mobile, roaming</string>
+    <string name="keywords_sim_status_esim">rêt, stât de rêt mobile, stât dal servizi, fuarce dal segnâl, gjenar di rêt mobile, roaming, eid</string>
+    <string name="keywords_sim_status_iccid">rêt, stât de rêt mobile, stât dal servizi, fuarce dal segnâl, gjenar di rêt mobile, roaming, iccid</string>
     <string name="keywords_sim_status_iccid_esim">rêt, stât de rêt mobile, stât dal servizi, fuarce dal segnâl, gjenar di rêt mobile, roaming, iccid, eid</string>
+    <string name="keywords_esim_eid">eid</string>
     <string name="keywords_model_and_hardware">numar di serie, version hardware</string>
+    <string name="keywords_battery_info">informazions batarie, date di produzion, conte dai ciclis, prime utilizazion</string>
     <string name="keywords_android_version">nivel de corezion di sigurece android, version bande di base, version dal kernel</string>
     <string name="keywords_dark_ui_mode">teme, clâr, scûr, modalitât, sensibilitât ae lûs, fotofobie, rint plui scûr, scurìs, modalitât scure, emicranie</string>
     <string name="keywords_systemui_theme">teme scûr</string>
@@ -2667,6 +3117,7 @@
     <string name="keywords_face_settings">muse</string>
     <string name="keywords_fingerprint_settings">impront, zonte impront</string>
     <string name="keywords_biometric_settings">muse, impront, zontâ impront</string>
+    <string name="keywords_active_unlock_settings">sbloc cul orloi, zonte sbloc cul orloi</string>
     <string name="keywords_display_auto_brightness">atenuazion schermi, schermi tatil, batarie, luminositât inteligjente, luminositât dinamiche, luminositât automatiche</string>
     <string name="keywords_display_adaptive_sleep">inteligjente, atenuazion schermi, polse, batarie, timp di spiete, atenuazion, schermi, visôr, inativitât</string>
     <string name="keywords_auto_rotate">fotocjamare, inteligjente, rotazion automatiche, auto-rotazion, voltâ, zirâ, verticâl, orizontâl, orientament, ritrat, panorame</string>
@@ -2676,6 +3127,7 @@
     <string name="keywords_storage_settings">memorie, cache, dâts, elimine, nete, libere, spazi</string>
     <string name="keywords_bluetooth_settings">conetût, dispositîf, auricolârs, scufis, casse, cence fîi, associâ, musiche, contignûts multimediâi</string>
     <string name="keywords_wallpaper">fonts, teme, gridele, personalize</string>
+    <string name="keywords_styles">icone, acent, colôr, schermade di inizi, schermade di bloc, scurte, dimension orloi</string>
     <string name="keywords_assist_input">predefinît, assistent</string>
     <string name="keywords_default_payment_app">paiament, predefinît</string>
     <string name="keywords_ambient_display">notifiche in jentrade</string>
@@ -2694,6 +3146,8 @@
     <string name="keywords_nr_advanced_calling">vo5g, vonr, clamadis avanzade, clamadis 5g</string>
     <string name="keywords_add_language">zonte lenghe, zonte une lenghe</string>
     <string name="keywords_font_size">dimension test, stampe grande, caratar grant, test grant, vision scjarse, ingrandiment di test, ingrandidôr di caratar, ingrandiment di caratar</string>
+    <string name="keywords_always_show_time_info">simpri su schermi ambientâl, AOD</string>
+    <string name="keywords_change_nfc_tag_apps_state">nfc, etichete, letôr</string>
     <string name="sound_dashboard_summary">Volum, vibrazion, No Sta Disturbâ</string>
     <string name="media_volume_option_title">Volum contignûts multimediâi</string>
     <string name="remote_media_volume_option_title">Volum di trasmission</string>
@@ -2702,6 +3156,10 @@
     <string name="ring_volume_option_title">Volum di sunarie e notifichis</string>
     <string name="separate_ring_volume_option_title">Volum sunarie</string>
     <string name="notification_volume_option_title">Volum notifichis</string>
+    <string name="ringer_content_description_silent_mode">Sunarie cidine</string>
+    <string name="ringer_content_description_vibrate_mode">Sunarie vibrazion</string>
+    <string name="notification_volume_content_description_vibrate_mode">Volum notifichis cidinât, vibrazion aes notifichis</string>
+    <string name="volume_content_description_silent_mode"> <xliff:g id="volume type" example="notification volume">%1$s</xliff:g> cidinât</string>
     <string name="notification_volume_disabled_summary">No disponibil parcè che la sunarie e je cidinade</string>
     <string name="ringtone_title">Sunarie dal telefon</string>
     <string name="notification_ringtone_title">Sun di notifiche predefinît</string>
@@ -2714,6 +3172,7 @@
     <string name="screen_locking_sounds_title">Sun di bloc dal schermi</string>
     <string name="charging_sounds_title">Suns e vibrazions ricjarie</string>
     <string name="docking_sounds_title">Suns base di ancorament</string>
+    <string name="touch_sounds_title">Suns di tocjade e clic</string>
     <string name="vibrate_icon_title">Mostre simpri la icone in modalitât vibrazion</string>
     <string name="dock_audio_media_title">Riproduzion cun cassis de base di ancorament</string>
     <string name="dock_audio_media_disabled">Dut l\'audio</string>
@@ -2909,6 +3368,7 @@
     <string name="notification_pulse_title">Lampâ de lusute</string>
     <string name="lock_screen_notifications_title">Riservatece</string>
     <string name="lockscreen_bypass_title">Ignore schermade di bloc</string>
+    <string name="lockscreen_bypass_summary">Dopo dal sbloc, va dret ae ultime schermade doprade. Lis notifichis no vignaran fûr su la schermade di bloc. Scor in jù di parsore par viodilis.</string>
     <string name="keywords_lockscreen_bypass">Bloc dal schermi, Bloc scermi, Salte, Passe</string>
     <string name="locked_work_profile_notification_title">Se profîl di lavôr al è blocât</string>
     <string name="unseen_notifs_lock_screen">Sul bloc schermi mostre nome lis gnovis notifichis</string>
@@ -2925,7 +3385,6 @@
     <string name="lock_screen_notifications_summary_show">Mostre ducj i contignûts des notifichis</string>
     <string name="lock_screen_notifications_summary_hide">Mostre contignûts sensibii dome cuant che il dispositîf al è sblocât</string>
     <string name="lock_screen_notifications_summary_disable">No sta mostrâ dal dut lis notifichis</string>
-    <string name="lock_screen_notifications_interstitial_message">Ce desideristu visualizâ te schermade di bloc?</string>
     <string name="lock_screen_notifications_interstitial_title">Schermade di bloc</string>
     <string name="lock_screen_notifications_summary_show_profile">Mostre ducj i contignûts des notifichis di lavôr</string>
     <string name="lock_screen_notifications_summary_hide_profile">Plate ducj i contignûts sensibii di lavôr</string>
@@ -2943,6 +3402,10 @@
     <string name="promote_conversation_title">Cheste e je une conversazion</string>
     <string name="promote_conversation_summary">Zonte te sezion conversazions</string>
     <string name="priority_conversation_count_zero">Nissune conversazion cun prioritât</string>
+    <string name="priority_conversation_count">{count, plural,
+      one {}=1      {# conversazion prioritarie}
+      other   {# conversazions prioritariis}
+    }</string>
     <string name="important_conversations">Conversazions cun prioritât</string>
     <string name="important_conversations_summary_bubbles">A vegnin fûr insom de sezion conversazions e come bufulis mobilis</string>
     <string name="important_conversations_summary">A vegnin fûr insom de sezion conversazions</string>
@@ -2969,9 +3432,18 @@
     <string name="notification_channel_summary_min">Te tende a tirâ jù, strenç lis notifichis intune sole rie</string>
     <string name="notification_channel_summary_low">Nissun sun o vibrazion</string>
     <string name="notification_conversation_summary_low">Nissun sun o vibrazion e al somee plui in bas te sezion des conversazions</string>
+    <string name="notification_channel_summary_default">Al podarès sunâ o vibrâ in base aes impostazions dal dispositîf</string>
     <string name="notification_channel_summary_high">Cuant che il dispositîf al è sblocât, mostre lis notifichis come un strisson te part superiôr dal schermi</string>
     <string name="notification_switch_label">Dutis lis notifichis di \"<xliff:g id="app_name" example="Android Services">%1$s</xliff:g>\"</string>
     <string name="notification_app_switch_label">Dutis lis notifichis di <xliff:g id="app_name" example="Android Services">%1$s</xliff:g></string>
+    <string name="notifications_sent_daily">{count, plural,
+      one {}=1      {Cirche # notifiche par dì}
+      other   {Cirche # notifichis par dì}
+    }</string>
+    <string name="notifications_sent_weekly">{count, plural,
+      one {}=1      {Cirche # notifiche par setemane}
+      other   {Cirche # notifichis par setemane}
+    }</string>
     <string name="notifications_sent_never">Mai</string>
     <string name="manage_notification_access_title">Notifichis aplicazions e dispositîf</string>
     <string name="manage_notification_access_summary">Controle cualis aplicazions e dispositîfs a pudin lei lis notifichis</string>
@@ -2989,6 +3461,12 @@
     </string>
     <string name="notification_listener_security_warning_title">Permeti l\'acès aes notifichis a
          <xliff:g id="service" example="NotificationReader">%1$s</xliff:g>?</string>
+    <string name="notification_listener_security_warning_summary">        La aplicazion <xliff:g id="notification_listener_name">%1$s</xliff:g> e rivarà a lei dutis lis notifichis,
+        includudis informazions personâls come nons di contat, fotos e i tescj di messaçs che tu ricevis.
+        Cheste aplicazion e rivarà ancje a posticipâ o scartâ lis notifichis o fâ azions sui botons des notifichis, includût rispuindi aes clamadis telefonichis.
+        \n\nChest al darà ae aplicazion la pussibilitât di ativâ o disativâ il No Sta Disturbâ e cambiâ lis relativis impostazions.
+    </string>
+    <string name="nls_warning_prompt">La aplicazion <xliff:g id="notification_listener_name">%1$s</xliff:g> e rivarà a:</string>
     <string name="nls_feature_read_title">Lei lis tôs notifichis</string>
     <string name="nls_feature_read_summary">Al pues lei lis tôs notifichis, includudis lis informazions personâls come contats, messaçs e fotos.</string>
     <string name="nls_feature_reply_title">Rispuindi ai messaçs</string>
@@ -3014,6 +3492,7 @@
     <string name="notif_listener_excluded_app_screen_title">Aplicazions mostradis sul dispositîf</string>
     <string name="notif_listener_not_migrated">Cheste aplicazion no supuarte lis impostazions avanzadis</string>
     <string name="notif_listener_more_settings">Altris impostazions</string>
+    <string name="notif_listener_more_settings_desc">Altris impostazions a son disponibilis dentri di cheste aplicazion</string>
     <string name="vr_listeners_title">Servizis di assistence pe realtât virtuâl</string>
     <string name="no_vr_listeners">Nissune aplicazion instalade e à domandât di zirâ come servizi di assistence pe realtât virtuâl.</string>
     <string name="vr_listener_security_warning_title">Permeti l\'acès al servizi di realtât virtuâl a
@@ -3047,6 +3526,10 @@
     <string name="interact_across_profiles_consent_dialog_permissions_title">Permès</string>
     <string name="interact_across_profiles_consent_dialog_permissions_summary">Cheste aplicazion e pues doprâ i permès de aplicazion personâl <xliff:g id="name" example="Calendar">%1$s</xliff:g>, come acedi ae posizion, la memorie di archiviazion o i contats.</string>
     <string name="interact_across_profiles_number_of_connected_apps_none">Nissune aplicazion colegade</string>
+    <string name="interact_across_profiles_number_of_connected_apps">{count, plural,
+      one {}=1      {# aplicazion conetude}
+      other   {# aplicazions conetudis}
+    }</string>
     <string name="interact_across_profiles_install_work_app_title">Par colegâ chestis aplicazions, instale <xliff:g id="name" example="Calendar">%1$s</xliff:g> tal to profîl di lavôr</string>
     <string name="interact_across_profiles_install_personal_app_title">Par colegâ chestis aplicazions, instale <xliff:g id="name" example="Calendar">%1$s</xliff:g> tal to profîl personâl</string>
     <string name="interact_across_profiles_install_app_summary">Tocje par otignî la aplicazion</string>
@@ -3061,10 +3544,16 @@
     <string name="notification_channels_other">Altri</string>
     <string name="no_channels">Cheste aplicazion no à publicât nissune notifiche</string>
     <string name="app_settings_link">Impostazions adizionâls te aplicazion</string>
+    <string name="deleted_channels">{count, plural,
+      one {}=1      {# categorie eliminade}
+      other   {# categoriis eliminadis}
+    }</string>
     <string name="app_notification_block_title">Bloche dut</string>
     <string name="app_notification_block_summary">No sta mostrâ mai chestis notifichis</string>
     <string name="notification_content_block_title">Mostre notifichis</string>
     <string name="notification_content_block_summary">No sta mostrâ mai notifichis te sbare de tende o su dispositîfs periferics</string>
+    <string name="app_notification_fsi_permission_title">Permet notifichis a plen schermi</string>
+    <string name="app_notification_fsi_permission_summary">Permet aes notifichis di doprâ dut il schermi se il dispositîf al è blocât</string>
     <string name="notification_badge_title">Permet indicadôr di notifiche</string>
     <string name="notification_channel_badge_title">Mostre indicadôr di notifiche</string>
     <string name="app_notification_override_dnd_title">Ignore il No Sta Disturbâ</string>
@@ -3221,6 +3710,14 @@
     <string name="zen_mode_end_time">Ore di fin</string>
     <string name="zen_mode_end_time_next_day_summary_format"><xliff:g id="formatted_time" example="7:00 AM">%s</xliff:g> dì sucessîf</string>
     <string name="zen_mode_summary_alarms_only_indefinite">Cambie in mût indefinît su Dome sveis</string>
+    <string name="zen_mode_summary_alarms_only_by_minute">{count, plural,
+      one {}=1      {Passe a Dome sveis par un minût fintremai lis {time}}
+      other   {Passe a Dome sveis par # minûts (fintremai lis {time})}
+    }</string>
+    <string name="zen_mode_summary_alarms_only_by_hour">{count, plural,
+      one {}=1      {Passe a Dome sveis par une ore fintremai lis {time}}
+      other   {Passe a Dome sveis par # oris fintremai lis {time}}
+    }</string>
     <string name="zen_mode_summary_alarms_only_by_time">Cambie su Dome sveis fintremai lis <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g></string>
     <string name="zen_mode_summary_always">Cambie su Interomp simpri</string>
     <string name="warning_button_text">Avertiment</string>
@@ -3235,19 +3732,6 @@
     <string name="screen_pinning_switch_off_text">Off</string>
     <string name="screen_pinning_title">Fissâ de aplicazion</string>
     <string name="app_pinning_intro">Il fissâ lis aplicazions ti permet di tignî la aplicazion atuâl inte viodude fintant che no tu le molis. Al è pussibil doprâ cheste funzion, par esempli, par permeti a un amì fidât di zuiâ cuntun specific zûc.</string>
-    <string name="screen_pinning_description">        Cuant che une aplicazion e je fissade, cheste e podarès vierzi altris aplicazions e i dâts personâi a podaressin jessi acessibii.
-        \n\nPar fissâ lis aplicazions:
-        \t\n1. Ative il fissâ de aplicazion
-        \t\n2. Vierç la panoramiche
-        \t\n3. Tocje la icone de aplicazion te part superiôr dal schermi, dopo tocje Fisse
-    </string>
-    <string name="screen_pinning_guest_user_description">        Se une aplicazion e je fissade, cheste e podarès vierzi altris aplicazions e i dâts personâi a podaressin jessi acessibii.
-        \n\nSe tu desideris condividi in sigurece il to dispositîf cun cualchidun, prove invezit a doprâ l\'utent ospit.
-        \n\nPar fissâ une aplicazion:
-        \t\n1. Ative il fissâ de aplicazion
-        \t\n2. Vierç la panoramiche
-        \t\n3. Tocje la icone de aplicazion te part superiôr dal schermi, dopo tocje Fisse
-    </string>
     <string name="screen_pinning_dialog_message">        Cuant che une aplicazion e je fissade:
         \n\n\u2022\t\tI dâts personâi a podaressin jessi acessibii
         \n\t\t(come i contats e i contignûts di e-mail)
@@ -3259,11 +3743,23 @@
     <string name="screen_pinning_unlock_password">Domande la password prime di molâ</string>
     <string name="screen_pinning_unlock_none">Bloche il dispositîf cuant che tu molis</string>
     <string name="confirm_sim_deletion_title">Conferme eliminazion SIM</string>
+    <string name="confirm_sim_deletion_description">Verifiche la tô identitât prime di scancelâ une eSIM</string>
+    <string name="memtag_title">Beta de protezion avanzade de memorie</string>
+    <string name="memtag_toggle">Protezion avanzade de memorie</string>
+    <string name="memtag_intro">Cheste beta de funzionalitât ti jude a protezi il dispositîf dai erôrs che a podaressin creâ un risi pe sigurece.</string>
     <string name="memtag_on">On</string>
     <string name="memtag_off">Off</string>
+    <string name="memtag_on_pending">Atîf dopo il prossim inviament</string>
+    <string name="memtag_off_pending">Disativât dopo il prossim inviament</string>
+    <string name="memtag_force_off">Cumò no disponibil pal to dispositîf</string>
+    <string name="memtag_force_on">Simpri atîf pal to dispositîf</string>
+    <string name="memtag_footer">Tu varâs di tornâ a inviâ il dispositîf par ativâ o disativâ la protezion avanzade de memorie. Cuant che e je ative, al è pussibil notâ un câl des prestazions dal dispositîf.</string>
     <string name="memtag_reboot_title">Tornâ a inviâ il dispositîf?</string>
+    <string name="memtag_reboot_message_on">Tu varâs di tornâ a inviâ il dispositîf par ativâ la protezion avanzade de memorie.</string>
+    <string name="memtag_reboot_message_off">Tu varâs di tornâ a inviâ il dispositîf par disativâ la protezion avanzade de memorie.</string>
     <string name="memtag_reboot_yes">Torne invie</string>
     <string name="memtag_reboot_no">No cumò</string>
+    <string name="memtag_learn_more">Scuvierç di plui su la protezion avanzade de memorie.</string>
     <string name="opening_paragraph_delete_profile_unknown_company">Chest profîl di lavôr al è gjestît di:</string>
     <string name="managing_admin">Gjestît di <xliff:g id="admin_app_label">%s</xliff:g></string>
     <string name="launch_by_default">Vierç par impostazion predefinide</string>
@@ -3274,10 +3770,22 @@
     <string name="app_launch_other_defaults_title">Altris preferencis predefinidis</string>
     <string name="app_launch_add_link">Zonte colegament</string>
     <string name="app_launch_footer">Une aplicazion e pues verificâ i colegaments di vierzi in automatic te aplicazion.</string>
+    <string name="app_launch_verified_links_title">{count, plural,
+      one {}=1      {# colegament verificât}
+      other   {# colegaments verificâts}
+    }</string>
+    <string name="app_launch_verified_links_message">{count, plural,
+      one {}=1      {Chest colegament al è stât verificât e si vierzarà in automatic in cheste aplicazion.}
+      other   {Cescj colegaments a son stâts verificâts e si vierzaran in automatic in cheste aplicazion.}
+    }</string>
     <string name="app_launch_dialog_ok">Va ben</string>
     <string name="app_launch_verified_links_info_description">Mostre la liste dai colegaments verificâts</string>
     <string name="app_launch_checking_links_title">Daûr a controlâ atris colegaments supuartâts\u2026</string>
     <string name="app_launch_dialog_cancel">Anule</string>
+    <string name="app_launch_supported_links_title">{count, plural,
+      one {}=1      {# colegament supuartât}
+      other   {# colegaments supuartâts}
+    }</string>
     <string name="app_launch_supported_links_add">Zonte</string>
     <string name="app_launch_supported_links_subtext">Si vierç in <xliff:g id="app_label" example="Reddit">%s</xliff:g></string>
     <string name="storage_summary_format"><xliff:g id="size" example="30.00MB">%1$s</xliff:g> doprâts te <xliff:g id="storage_type" example="internal memory">%2$s</xliff:g></string>
@@ -3291,12 +3799,24 @@
     <string name="notifications_enabled">On</string>
     <string name="notifications_enabled_with_info"><xliff:g id="notifications_sent" example="~6 per week">%1$s</xliff:g> / <xliff:g id="notifications_categories_off" example="3 categories turned off">%2$s</xliff:g> </string>
     <string name="notifications_disabled">Off</string>
+    <string name="notifications_categories_off">{count, plural,
+      one {}=1      {# categorie disativade}
+      other   {# categoriis disativadis}
+    }</string>
+    <string name="runtime_permissions_additional_count">{count, plural,
+      one {}=1      {# altri permès}
+      other   {# altris permès}
+    }</string>
     <string name="runtime_permissions_summary_no_permissions_granted">Nissun permès concedût</string>
     <string name="runtime_permissions_summary_no_permissions_requested">Nissun permès domandât</string>
     <string name="runtime_permissions_summary_control_app_access">Controle l\'acès des aplicazions ai tiei dâts</string>
     <string name="permissions_usage_title">Panel di control de riservatece</string>
     <string name="permissions_usage_summary">Mostre lis aplicazions che di resint a àn doprât permès</string>
     <string name="unused_apps">Aplicazions no dopradis</string>
+    <string name="unused_apps_summary">{count, plural,
+      one {}=1      {# aplicazion no doprade}
+      other   {# aplicazions no dopradis}
+    }</string>
     <string name="unused_apps_category">Impostazions aplicazion no doprade</string>
     <string name="unused_apps_switch">Ferme ativitât de aplicaz. se no doprade</string>
     <string name="unused_apps_switch_summary">Gjave i permès, elimine i files temporanis e interomp lis notifichis</string>
@@ -3306,6 +3826,8 @@
     <string name="filter_notif_blocked_apps">Disativadis</string>
     <string name="advanced_apps">Avanzadis</string>
     <string name="app_permissions">Gjestôr dai permès</string>
+    <string name="app_data_sharing_updates_title">Inzornaments condivision dâts pe posizion</string>
+    <string name="app_data_sharing_updates_summary">Torne esamine lis aplicazions che a àn cambiât la maniere di condividi i dâts de posizion</string>
     <string name="tap_to_wake">Tocje par riativâ</string>
     <string name="tap_to_wake_summary">Tocje dôs voltis là che tu vûs sul schermi par riativâil dispositîf</string>
     <string name="domain_urls_title">Viertidure dai colegaments</string>
@@ -3315,6 +3837,10 @@
     <string name="app_link_open_always">Permet ae aplicazion di vierzi i colegaments supuartâts</string>
     <string name="app_link_open_ask">Domande ogni volte</string>
     <string name="app_link_open_never">No sta permeti ae aplicazion di vierzi i colegaments</string>
+    <string name="app_link_open_always_summary">{count, plural,
+      one {}=1      {La aplic. e rivendiche la gjestion di # link}
+      other   {La aplic. e rivendiche la gjestion di # links}
+    }</string>
     <string name="open_supported_links_footer">La aplicazion e pretint di gjestî chescj colegaments:</string>
     <string name="assist_and_voice_input_title">Assistence e input vocâl</string>
     <string name="default_assist_title">Aplicazion assistent digjitâl</string>
@@ -3354,6 +3880,7 @@
     <string name="usb_use_power_only">Ricjarie il dispositîf colegât</string>
     <string name="usb_use_file_transfers">Trasferiment di files</string>
     <string name="usb_use_photo_transfers">PTP</string>
+    <string name="usb_use_uvc_webcam">Webcam</string>
     <string name="usb_transcode_files">Convertìs i videos in AVC</string>
     <string name="usb_transcode_files_summary">I videos a vignaran riprodots su plui riprodutôrs multimediâi, ma al è pussibil che la cualitât e peiori</string>
     <string name="usb_use_tethering">Tethering USB</string>
@@ -3376,10 +3903,12 @@
     <string name="usb_summary_tether">Tethering USB</string>
     <string name="usb_summary_photo_transfers">PTP</string>
     <string name="usb_summary_MIDI">MIDI</string>
+    <string name="usb_summary_UVC">Webcam</string>
     <string name="usb_summary_file_transfers_power">Trasferiment files e alimentazion</string>
     <string name="usb_summary_tether_power">Tethering USB e alimentazion</string>
     <string name="usb_summary_photo_transfers_power">PTP e alimentazion</string>
     <string name="usb_summary_MIDI_power">MIDI e alimentazion</string>
+    <string name="usb_summary_UVC_power">Webcam e alimentazion</string>
     <string name="background_check_pref">Control in sotfont</string>
     <string name="assist_access_context_title">Dopre il test dal schermi</string>
     <string name="assist_access_context_summary">Permet ae aplicazion di assistence di acedi ai contignûts testuâi dal schermi</string>
@@ -3402,6 +3931,10 @@
     <string name="average_used">Utilizazion medie (%)</string>
     <string name="free_memory">Memorie libare</string>
     <string name="memory_usage_apps">Memorie doprade des aplicazions</string>
+    <string name="memory_usage_apps_summary">{count, plural,
+      one {}=1      {1 aplicazion e à doprât memorie intes ultimis {time}}
+      other   {# aplicazions a àn doprât memorie intes ultimis {time}}
+    }</string>
     <string name="running_frequency">Frecuence</string>
     <string name="memory_maximum_usage">Utilizazion massime</string>
     <string name="no_data_usage">Nissune utilizazion dâts</string>
@@ -3424,6 +3957,9 @@
     <string name="permit_manage_external_storage">Permet l\'acès par gjestî ducj i files</string>
     <string name="allow_manage_external_storage_description">Permet a cheste aplicazion di lei, modificâ e eliminâ ducj i files su chest dispositîf o su cualsisei volum di memorie colegât. Se il permès al ven concedût, la aplicazion e podarès acedi ai files cence che tu lu savedis.</string>
     <string name="filter_manage_external_storage">A puedin acedi a ducj i files</string>
+    <string name="full_screen_intent_title">Notifichis a plen schermi</string>
+    <string name="permit_full_screen_intent">Permet notifichis a plen schermi di cheste aplicazion</string>
+    <string name="footer_description_full_screen_intent">Permet a cheste aplicazion di mostrâ notifichis che a doprin dut il schermi cuant che il dispositîf al è blocât. Lis aplicazions a puedin doprâ chestis notifichis par evidenziâ sveis, clamadis in jentrade o altris notifichis urgjentis.</string>
     <string name="media_management_apps_title">Aplicazions di gjestion multimediâl</string>
     <string name="media_management_apps_toggle_label">Permet ae aplicazion di gjestî il multimedia</string>
     <string name="media_management_apps_description">Se consintude, cheste aplicazion e podarà modificâ o eliminâ i files multimediâi creâts cun altris aplicazions cence che ti lu domandi. La aplicazion e varà di vê il permès par acedi ai files e ai contignûts multimediâi.</string>
@@ -3460,6 +3996,7 @@
     <string name="users_summary">Jentrât come <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>
     <string name="android_version_summary">Inzornât a Android <xliff:g id="version" example="6.0">%1$s</xliff:g></string>
     <string name="android_version_pending_update_summary">Inzornament disponibil</string>
+    <string name="disabled_by_policy_title">Blocade des politichis di lavôr</string>
     <string name="disabled_by_policy_title_adjust_volume">Impussibil cambiâ il volum</string>
     <string name="disabled_by_policy_title_outgoing_calls">Impussibil fâ clamadis</string>
     <string name="disabled_by_policy_title_sms">Impussibil mandâ messaçs SMS</string>
@@ -3469,6 +4006,8 @@
     <string name="disabled_by_policy_title_financed_device">Impostazion blocade dal furnidôr di credit</string>
     <string name="disabled_by_policy_title_biometric_parental_consent">Al covente un gjenitôr</string>
     <string name="disabled_by_policy_content_biometric_parental_consent">Da il telefon a un to gjenitôr par scomençâ cheste configurazion</string>
+    <string name="disabled_by_policy_parental_consent">Da il telefon al to gjenitôr par permeti la modifiche di cheste impostazion.</string>
+    <string name="default_admin_support_msg">Par vê plui informazions, contate il to aministradôr di IT</string>
     <string name="admin_support_more_info">Plui detais</string>
     <string name="admin_profile_owner_message">Il to aministradôr al pues monitorâ e gjestî lis aplicazions e i dâts
         associâts al to profîl di lavôr, includudis lis impostazions, i permès, l\'acès aziendâl,
@@ -3533,7 +4072,6 @@
     <string name="cell_data_warning">Avîs sui dâts: <xliff:g name="amount" example="1 GB">^1</xliff:g></string>
     <string name="cell_data_limit">Limit dâts: <xliff:g name="amount" example="1 GB">^1</xliff:g></string>
     <string name="cell_data_warning_and_limit">Avîs sui dâts: <xliff:g name="amount" example="1 GB">^1</xliff:g> / Limit dâts: <xliff:g name="amount" example="2 GB">^2</xliff:g></string>
-    <string name="operator_warning">Il cont dai dâts dal operadôr al podarès diferenziâsi di chel dal dispositîf.</string>
     <string name="non_carrier_data_usage_warning">Al esclût i dâts doprâts des rêts dal operadôr</string>
     <string name="data_used_template"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> doprâts</string>
     <string name="set_data_warning">Stabilìs avîs sui dâts</string>
@@ -3544,6 +4082,10 @@
     <string name="data_usage_template"><xliff:g name="amount" example="200 MB">%1$s</xliff:g> doprâts tal periodi <xliff:g name="date_range" example="Jan 1 -- Feb 2">%2$s</xliff:g></string>
     <string name="configure">Configure</string>
     <string name="data_usage_other_apps">Altris aplicazions includudis te utilizazion</string>
+    <string name="data_saver_unrestricted_summary">{count, plural,
+      one {}=1      {1 aplicazion e pues doprâ dâts cence restrizions cuant che il Sparagn dâts al è atîf}
+      other   {# aplicazions a puedin doprâ dâts cence restrizions cuant che il Sparagn dâts al è atîf}
+    }</string>
     <string name="data_usage_title">Dâts primaris</string>
     <string name="data_usage_wifi_title">Dâts Wi\u2011Fi</string>
     <string name="data_used_formatted"><xliff:g name="value" example="500">^1</xliff:g> <xliff:g name="units" example="GB">^2</xliff:g> doprâts</string>
@@ -3551,13 +4093,16 @@
     <string name="data_remaining">A mancjin <xliff:g name="bytes" example="2 GB">^1</xliff:g></string>
     <string name="data_usage_chart_brief_content_description">Grafic che al mostre la utilizazion dai dâts tra <xliff:g id="start_date" example="August 19">%1$s</xliff:g> e <xliff:g id="end_date" example="September 16">%2$s</xliff:g>.</string>
     <string name="data_usage_chart_no_data_content_description">Nissun dât in cheste dade di timp</string>
+    <string name="billing_cycle_days_left">{count, plural,
+      one {}=1      {Al mancje # dì}
+      other   {A mancjin # dîs}
+    }</string>
     <string name="billing_cycle_none_left">Timp dal cicli di faturazion scjadût</string>
     <string name="billing_cycle_less_than_one_day_left">Al mancje mancul di 1 dì</string>
     <string name="carrier_and_update_text">Inzornât di <xliff:g name="carrier" example="T-mobile">^1</xliff:g> <xliff:g name="time" example="3m">^2</xliff:g> indaûr</string>
     <string name="no_carrier_update_text">Inzornât <xliff:g name="time" example="3m">^2</xliff:g> indaûr</string>
     <string name="carrier_and_update_now_text">Inzornât di <xliff:g name="carrier" example="T-mobile">^1</xliff:g> juste cumò</string>
     <string name="no_carrier_update_now_text">Inzornât juste cumò</string>
-    <string name="launch_mdp_app_text">Visualize plan</string>
     <string name="launch_wifi_text">Viôt i detais</string>
     <string name="data_saver_title">Sparagn dâts</string>
     <string name="unrestricted_data_saver">Dâts cence limitazions</string>
@@ -3575,7 +4120,22 @@
     <string name="battery_saver_off_summary">Off</string>
     <string name="app_battery_usage_title">Utilizazion de batarie pe aplicazion</string>
     <string name="app_battery_usage_summary">Stabilìs utilizazion batarie pes aplicazions</string>
+    <string name="battery_tips_card_action_button">Viôt impostazions</string>
+    <string name="battery_tips_card_action_button_check">Controle</string>
     <string name="battery_tips_card_dismiss_button">Capît</string>
+    <string name="battery_tips_card_feedback_info">Isal util chest messaç?</string>
+    <string name="battery_hints_warning_icon_a11y">Icone di avîs dai sugjeriments pe batarie</string>
+    <string name="battery_tips_settings_summary_brightness">Ative la luminositât adative par slungjâ la durade de batarie</string>
+    <string name="battery_tips_settings_summary_screen_timeout">Ridûs il timp pal distudament dal schermi par slungjâ la durade de batarie</string>
+    <string name="battery_tips_apps_summary_always_high"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> al à consumât plui batarie</string>
+    <string name="battery_tips_apps_summary_higher_than_usual"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> al à consumât plui batarie dal solit</string>
+    <string name="battery_tips_apps_summary_always_high_in_background"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> al à consumât plui batarie intant che al stave in sotfont</string>
+    <string name="battery_tips_apps_summary_higher_than_usual_in_background"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> al à doprât plui batarie dal solit intant che al stave in sotfont</string>
+    <string name="battery_tips_apps_summary_always_high_in_foreground"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> al à consumât plui batarie intant che al stave in prin plan</string>
+    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> al à doprât plui batarie dal solit intant che al stave in prin plan</string>
+    <string name="battery_app_item_hint">Consum elevât di batarie</string>
+    <string name="battery_app_item_hint_in_bg">Consum di batarie elevât in sotfont</string>
+    <string name="battery_app_item_hint_in_fg">Consum di batarie elevât in prin plan</string>
     <string name="filter_battery_unrestricted_title">Cence limitazions</string>
     <string name="filter_battery_optimized_title">Otimizade</string>
     <string name="filter_battery_restricted_title">Cun limitazions</string>
@@ -3613,6 +4173,15 @@
     <string name="overlay_toast_failed_to_apply">Aplicazion soreposizion falide</string>
     <string name="special_access">Acès speciâl pes aplicazions</string>
     <string name="special_access_more">Viôt di plui</string>
+    <string name="long_background_tasks_label">Ativitâts in sotfont lungjis</string>
+    <string name="long_background_tasks_switch_title">Permet ativitâts in sotfont a lungje esecuzion</string>
+    <string name="long_background_tasks_title">Ativitâts in sotfont lungjis</string>
+    <string name="long_background_tasks_footer_title">        Permet a chest aplicazion di eseguî lungjis ativitâts in sotfont. La aplicazion e podarà
+        eseguî ativitâts che a durin plui di cualchi minût, come discjariâ e cjariâ in rêt.
+        \n\nSe chest permès al ven dineât, al sarà il sisteme a determinâ il timp limit
+        par eseguî lis ativitâts de aplicazion in sotfont.
+    </string>
+    <string name="keywords_long_background_tasks">lavôrs luncs, trasferiment dâts, ativitâts in sotfont</string>
     <string name="reset_shortcut_manager_throttling">Ripristine il limit di frecuence in ShortcutManager</string>
     <string name="reset_shortcut_manager_throttling_complete">Il limit di frecuence di ShortcutManager al è stât ripristinât</string>
     <string name="notification_suggestion_title">Controle lis informazions su la schermade di bloc</string>
@@ -3636,13 +4205,13 @@
     <string name="quick_settings_developer_tiles">Ricuadris svilupadôr pes impostazions rapidis</string>
     <string name="adb_authorization_timeout_title">Disative scjadince autorizazion adb</string>
     <string name="adb_authorization_timeout_summary">Disative la revoche automatiche des autorizazions di adb pai sistemis che no àn tornât a colegâsi tal periodi di timp predefinît (7 dîs) o configurât dal utent (minim 1 dì).</string>
-    <string name="winscope_trace_quick_settings_title">Winscope Trace</string>
     <string name="sensors_off_quick_settings_title">Sensôrs disativâts</string>
     <string name="managed_profile_settings_title">Impostazions profîl di lavôr</string>
     <string name="managed_profile_contact_search_title">Cîr i contats de cartele di lavôr tes aplicazion personâls</string>
     <string name="managed_profile_contact_search_summary">Il to aministradôr di IT al podarès viodi lis tôs ricercjis e lis clamadis in jentrade </string>
     <string name="cross_profile_calendar_title">Calendari di plui profîi</string>
     <string name="cross_profile_calendar_summary">Mostre i events di lavôr sul to calendari personâl</string>
+    <string name="managed_profile_settings_footer">Cuant che lis aplicazions di lavôr a son distudadis, a son in pause e nol è pussibil doprâlis o inviâti notifichis</string>
     <string name="automatic_storage_manager_settings">Gjestìs archiviazion</string>
     <string name="automatic_storage_manager_text">Par judâ a liberâ spazi di archiviazion, il gjestôr de memorie di archiviazion al gjave fotos e video dal dispositîf, dopo che al è stât fat il lôr backup.</string>
     <string name="automatic_storage_manager_days_title">Gjave fotos e videos</string>
@@ -3652,17 +4221,18 @@
     <string name="double_tap_power_for_camera_title">Vierç daurman la fotocjamare</string>
     <string name="double_tap_power_for_camera_summary">Par vierzi daurman la fotocjamare, frache il boton di impiament dôs voltis. Al funzione di cualsisei schermade.</string>
     <string name="double_twist_for_camera_mode_title">Cambie fotocjamare pal selfie</string>
+    <string name="system_navigation_title">Modalitât navigazion</string>
     <string name="swipe_up_to_switch_apps_title">Navigazion a 2 botons</string>
     <string name="swipe_up_to_switch_apps_summary">Par cambiâ aplicazion, scor in sù sul boton di Inizi. Par viodi dutis lis aplicazions, torne scor in sù. Par tornâ indaûr, tocje il boton indaûr.</string>
     <string name="emergency_settings_preference_title">Sigurece e emergjence</string>
     <string name="emergency_dashboard_summary">SOS emergjence, informazions medichis, avîs</string>
     <string name="edge_to_edge_navigation_title">Navigazion a mots</string>
+    <string name="edge_to_edge_navigation_summary">Par lâ ae schermade iniziâl, scor in sù dal bas dal schermi. Par cambiâ aplicazions, scor in sù dal bas, ten fracât e dopo mole. Par lâ indaûr, scor dal ôr di çampe o di diestre.</string>
     <string name="legacy_navigation_title">Navigazion a 3 botons</string>
     <string name="legacy_navigation_summary">Lâ indaûr, schermade di inizi e cambiâ aplicazions cui botons te part basse dal schermi.</string>
     <string name="keywords_system_navigation">navigazion di sisteme, navigazion a 2 botons, navigazion a 3 botons, navigazion a mots, scoriment</string>
     <string name="assistant_gesture_category_title">Assistent digjitâl</string>
     <string name="assistant_corner_gesture_title">Scor par clamâ l\'assistent</string>
-    <string name="assistant_corner_gesture_summary">Scor in sù di un angul in bas par clamâ la aplicazions dal assistent digjitâl.</string>
     <string name="assistant_long_press_home_gesture_title">Ten fracât Inizi pal assitent</string>
     <string name="assistant_long_press_home_gesture_summary">Frache e ten fracâ il boton di Inizi par clamâ la aplicazion dal assistent.</string>
     <string name="low_label">Basse</string>
@@ -3745,10 +4315,18 @@
     <string name="enterprise_privacy_none">Nissune</string>
     <string name="enterprise_privacy_enterprise_installed_packages">Aplicazions instaladis</string>
     <string name="enterprise_privacy_apps_count_estimation_info">Il numar di aplicazions al è stimât. Al è pussibil che no sedin includudis lis aplicazion instaladis fûr dal Play Store.</string>
+    <string name="enterprise_privacy_number_packages_lower_bound">{count, plural,
+      one {}=1      {Minim # aplicazion}
+      other   {Minim # aplicazions}
+    }</string>
     <string name="enterprise_privacy_location_access">Autorizazions di localizazion</string>
     <string name="enterprise_privacy_microphone_access">Autorizazions al microfon</string>
     <string name="enterprise_privacy_camera_access">Autorizazions ae fotocjamare</string>
     <string name="enterprise_privacy_enterprise_set_default_apps">Aplicazions predefinidis</string>
+    <string name="enterprise_privacy_number_packages">{count, plural,
+      one {}=1      {# aplicazion}
+      other   {# aplicazions}
+    }</string>
     <string name="enterprise_privacy_input_method">Tastiere predefinide</string>
     <string name="enterprise_privacy_input_method_name">Metodi metût a: <xliff:g id="app_label" example="Example Keyboard">%s</xliff:g></string>
     <string name="enterprise_privacy_always_on_vpn_device">VPN simpri-ative ativade</string>
@@ -3758,10 +4336,18 @@
     <string name="enterprise_privacy_ca_certs_device">Credenziâls atendibilis</string>
     <string name="enterprise_privacy_ca_certs_personal">Credenziâls atendibilis tal to profîl personâl</string>
     <string name="enterprise_privacy_ca_certs_work">Credenziâls atendibilis tal to profîl di lavôr</string>
+    <string name="enterprise_privacy_number_ca_certs">{count, plural,
+      one {}=1      {Minim # certificât CA}
+      other   {Minim # certificâts CA}
+    }</string>
     <string name="enterprise_privacy_lock_device">L\'aministradôr al pues blocâ il dispositîf e azerâ la password</string>
     <string name="enterprise_privacy_wipe_device">L\'aministradôr al pues eliminâ ducj i dâts dal dispositîf</string>
     <string name="enterprise_privacy_failed_password_wipe_device">Tentatîfs di password falîts prime di eliminâ ducj i dâts dal dispositîf</string>
     <string name="enterprise_privacy_failed_password_wipe_work">Tentatîfs di password falîts prime di eliminâ i dâts dal profîl di lavôr</string>
+    <string name="enterprise_privacy_number_failed_password_wipe">{count, plural,
+      one {}=1      {# tentatîf}
+      other   {# tentatîfs}
+    }</string>
     <string name="do_disclosure_generic">Chest dispositîf al è gjestît de tô organizazion.</string>
     <string name="do_disclosure_with_name">Chest dispositîf al è gjestît di <xliff:g id="organization_name" example="Foo, Inc.">%s</xliff:g>.</string>
     <string name="learn_more">Plui informazions</string>
@@ -3769,14 +4355,16 @@
     <string name="toast_allows_restricted_settings_successfully">Impostazions limitadis consintudis par <xliff:g id="app_name" example="Gmail">%s</xliff:g></string>
     <string name="blocked_by_restricted_settings_content">Pe tô sigurece, pal moment cheste impostazions no je disponibile.</string>
     <string name="financed_privacy_settings">Informazions sul dispositîf finanziât</string>
+    <string name="financed_privacy_intro">Il to furnidôr di credit al pues cambiâ impostazions e instalâ software su chest dispositîf dulinvie la configurazion.\n\nSe tu saltis un paiament, il furnidôr di credit al pues blocâ il dispositîf e cambiâ lis impostazions dal dispositîf.\n\nPar vê plui informazions, contate il to furnidôr di credit.</string>
     <string name="financed_privacy_restrictions_category">Se il to dispositîf al è finanziât, no tu puedis:</string>
-    <string name="financed_privacy_install_apps">Instale aplicazions che a rivin di difûr dal Play Store</string>
-    <string name="financed_privacy_safe_mode">Torne invie il dispositîf in modalitât sigure</string>
-    <string name="financed_privacy_multi_users">Zonte plui utents al to dispositîf</string>
-    <string name="financed_privacy_config_date_time">Cambie date, ore e fûs oraris</string>
+    <string name="financed_privacy_install_apps">Instalâ aplicazions che a rivin di difûr dal Play Store</string>
+    <string name="financed_privacy_safe_mode">Tornâ a inviâ il dispositîf in modalitât sigure</string>
+    <string name="financed_privacy_multi_users">Zontâ plui utents al to dispositîf</string>
+    <string name="financed_privacy_config_date_time">Cambiâ date, ore e fûs oraris</string>
     <string name="financed_privacy_developer_options">Dopre opzions svilupadôr</string>
     <string name="financed_privacy_credit_provider_capabilities_category">Il to furnidôr di credit al pues:</string>
     <string name="financed_privacy_IMEI">Acedi al to numar IMEI</string>
+    <string name="financed_privacy_factory_reset">Ripristine il dispositîf aes impostazions di fabriche se alc al va strucj</string>
     <string name="financed_privacy_locked_mode_category">Se il to dispositîf al è blocât, tu puedis doprâlu dome par:</string>
     <string name="financed_privacy_emergency_calls">Fâ clamadis di emergjence</string>
     <string name="financed_privacy_system_info">Viodi informazions di sisteme come date, ore, stât de rêt e batarie</string>
@@ -3787,9 +4375,21 @@
     <string name="financed_privacy_restrictions_removed">A vegnin gjavadis dal dispositîf dutis lis restrizions</string>
     <string name="financed_privacy_uninstall_creditor_app">Tu puedis disinstalâ la aplicazion dal creditôr</string>
     <string name="financed_device_info">Informazions sul dispositîf finanziât</string>
+    <string name="default_camera_app_title">{count, plural,
+      one {}=1      {Aplicazion fotocjamare}
+      other   {Aplicazions fotocjamare}
+    }</string>
     <string name="default_calendar_app_title">Aplicazion di calendari</string>
     <string name="default_contacts_app_title">Aplicazion di contats</string>
+    <string name="default_email_app_title">{count, plural,
+      one {}=1      {Aplicazion client e-mail}
+      other   {Aplicazions client e-mail}
+    }</string>
     <string name="default_map_app_title">Aplicazion di mapis</string>
+    <string name="default_phone_app_title">{count, plural,
+      one {}=1      {Aplicazion telefon}
+      other   {Aplicazions telefon}
+    }</string>
     <string name="app_names_concatenation_template_2"><xliff:g id="first_app_name">%1$s</xliff:g>, <xliff:g id="second_app_name">%2$s</xliff:g></string>
     <string name="app_names_concatenation_template_3"><xliff:g id="first_app_name">%1$s</xliff:g>, <xliff:g id="second_app_name">%2$s</xliff:g>, <xliff:g id="third_app_name">%3$s</xliff:g></string>
     <string name="storage_default_internal_storage">Chest dispositîf</string>
@@ -3816,14 +4416,32 @@
     <string name="webview_uninstalled_for_user">(disinstalât pal utent <xliff:g id="user" example="John Doe">%s</xliff:g>)</string>
     <string name="webview_disabled_for_user">(disativât pal utent <xliff:g id="user" example="John Doe">%s</xliff:g>)</string>
     <string name="autofill_app">Servizi di compilazion automatiche</string>
+    <string name="default_autofill_app">Servizi di compilazion automatiche predefinît</string>
     <string name="autofill_passwords">Passwords</string>
+    <string name="credman_credentials">Altris furnidôrs</string>
+    <string name="autofill_passwords_count">{count, plural,
+      one {}=1      {# password}
+      other   {# passwords}
+    }</string>
     <string name="autofill_keywords">automatic, completament, compilazion, completament automatic, password</string>
+    <string name="credman_keywords">dâts, passkey, password</string>
+    <string name="credman_autofill_keywords">automatiche, compilazion, compilazion automatiche, passkey, password</string>
     <string name="autofill_confirmation_message"><![CDATA[        <b>Verifiche che cheste aplicazion e sedi atendibile</b>
         <br/>
         <br/>
         <xliff:g id="app_name" example="Google Autofill">%1$s</xliff:g> al dopre ce che al è
         sul schermi par determinâ ce che al pues compilâ in automatic.
         ]]></string>
+    <string name="credman_confirmation_message_title">Disativâ %1$s\?</string>
+    <string name="credman_confirmation_message"><![CDATA[        <b>Disativâ chest servizi?</b>
+        <br/>
+        <br/>
+        Lis informazions salvadis come passwords, passkeys, metodis di paiament e altris informazions no vignaran compiladis
+        cuant che tu fasis un acès. Par doprâ lis tôs informazions salvadis, sielç une
+        password, passkey o servizi dâts.
+        ]]></string>
+    <string name="credman_enable_confirmation_message_title">Doprâ %1$s\?</string>
+    <string name="credman_enable_confirmation_message">%1$s al dopre ce che al è sul to schermi par determinâ ce che al pues compilâ in automatic.</string>
     <string name="credman_confirmation_message_positive_button">Disative</string>
     <string name="debug_autofill_category">Compilazion automatiche</string>
     <string name="autofill_logging_level_title">Nivel di regjistrazion</string>
@@ -3874,6 +4492,9 @@
         <item>@string/graphics_driver_app_preference_production_driver</item>
         <item>@string/graphics_driver_app_preference_system</item>
     </string-array>
+    <string name="enable_angle_as_system_driver">Sperimentâl: ative ANGLE</string>
+    <string name="enable_angle_as_system_driver_summary">Atenzion: ative ANGLE come driver OpenGL ES predefinît. Cheste funzion e je sperimentâl e al è pussibil che no sedi compatibile cun cualchi aplicazion di fotocjamare o video.</string>
+    <string name="reboot_dialog_enable_angle_as_system_driver">Al covente tornâ a inviâ il dispositîf par cambiâ il driver OpenGL ES di sisteme</string>
     <string name="platform_compat_dashboard_title">Modifichis di compatibilitât de aplicazion</string>
     <string name="platform_compat_dashboard_summary">Ative/disative lis modifichis di compatibilitât de aplicazion</string>
     <string name="platform_compat_default_enabled_title">Modifichis ativadis come impostazion predefinide</string>
@@ -3890,6 +4511,9 @@
     <string name="change_wifi_state_title">Control dal Wi-Fi</string>
     <string name="change_wifi_state_app_detail_switch">Permet ae aplicazion di controlâ il Wi-Fi</string>
     <string name="change_wifi_state_app_detail_summary">Permet a cheste aplicazion di ativâ o disativâ il Wi-Fi, scansionâ e conetiti a rêts Wi-Fi, zontâ o gjavâ rêts o inviâ un pont di acès dome-locâl</string>
+    <string name="change_nfc_tag_apps_title">Invie vie NFC</string>
+    <string name="change_nfc_tag_apps_detail_switch">Permet inviament su scansion NFC</string>
+    <string name="change_nfc_tag_apps_detail_summary">Permet a cheste aplicazion di inviâsi ae scansion di une etichete NFC.\nSe chest permès al è atîf, la aplicazion e sarà disponibile come opzion ogni volte che e ven rilevade une etichete.</string>
     <string name="media_output_title">Rirpodûs contignûts multimediâi su</string>
     <string name="media_output_label_title">Riprodûs <xliff:g id="label" example="Music Player">%s</xliff:g> su</string>
     <string name="media_output_default_summary">Chest dispositîf</string>
@@ -3905,7 +4529,6 @@
     <string name="prevent_ringing_option_mute_summary">Cidin</string>
     <string name="prevent_ringing_option_unavailable_lpp_summary">Par ativâ, prime cambie la opzion \"Frache e ten fracât il boton di inviament\" sul menù di impiament.</string>
     <string name="pref_title_network_details">Detais de rêt</string>
-    <string name="about_phone_device_name_warning">Il non dal to dispositîf al è visibil aes aplicazions sul to telefon. Al podarès jessi viodût ancje di altris personis cuant che tu ti coleghis a dispositîfs Bluetooth, tu ti conetis a une rêt Wi-Fi o tu configuris un pont di acès Wi-Fi.</string>
     <string name="devices_title">Dispositîfs</string>
     <string name="choose_network_title">Sielç rêt</string>
     <string name="network_disconnected">Disconetude</string>
@@ -3968,6 +4591,7 @@
     <string name="mobile_data_settings_summary">Acêt ai dâts doprant la rêt mobile</string>
     <string name="mobile_data_settings_summary_auto_switch">        Il telefon al passarà in automatic a chest operadôr se al cjape la sô rêt
     </string>
+    <string name="mobile_data_settings_summary_unavailable">Nissune SIM disponibile</string>
     <string name="calls_preference">Preference pes clamadis</string>
     <string name="sms_preference">Preference pai SMS</string>
     <string name="calls_and_sms_ask_every_time">Domande ogni volte</string>
@@ -3979,8 +4603,11 @@
     <string name="mobile_data_active">Dâts mobii atîfs</string>
     <string name="mobile_data_off">Dâts mobii disativâts</string>
     <string name="subscription_available">Disponibile</string>
+    <string name="mobile_network_list_add_more">Zonte SIM</string>
     <string name="mobile_network_active_sim">Atîf / SIM</string>
-    <string name="mobile_network_inactive_sim">No atîf / SIM</string>
+    <string name="mobile_network_inactive_sim">Inatîf / SIM</string>
+    <string name="mobile_network_active_esim">Atîf / eSIM</string>
+    <string name="mobile_network_inactive_esim">Inatîf / eSIM</string>
     <string name="mobile_network_sim_name">Non e colôr SIM</string>
     <string name="mobile_network_sim_name_label">Non</string>
     <string name="mobile_network_sim_color_label">Colôr (doprât des aplic. compatibilis)</string>
@@ -4020,6 +4647,7 @@
     <string name="sim_action_switch_psim_dialog_title">Passâ ae schede SIM?</string>
     <string name="sim_action_switch_sub_dialog_mep_title">Doprâ <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>?</string>
     <string name="sim_action_switch_sub_dialog_text">Al è pussibil ativâ dome une SIM ae volte.\n\nPassant a <xliff:g id="to_carrier_name" example="Google Fi">%1$s</xliff:g> no tu anularâs il servizi di <xliff:g id="from_carrier_name" example="Sprint">%2$s</xliff:g>.</string>
+    <string name="sim_action_switch_sub_dialog_text_downloaded">Al è pussibil ativâ dome 1 eSIM ae volte.\n\nPassant a <xliff:g id="to_carrier_name" example="Google Fi">%1$s</xliff:g> no tu anularâs il servizi <xliff:g id="from_carrier_name" example="Sprint">%2$s</xliff:g>.</string>
     <string name="sim_action_switch_sub_dialog_text_single_sim">Al è pussibil ativâ dome une SIM ae volte.\n\nIl passaç nol anularà il servizi di <xliff:g id="to_carrier_name" example="Google Fi">%1$s</xliff:g>.</string>
     <string name="sim_action_switch_sub_dialog_mep_text">Tu puedis doprâ 2 SIMs tal stes timp. Par doprâ <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>, disative une altre SIM.</string>
     <string name="sim_action_switch_sub_dialog_confirm">Passe a <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g></string>
@@ -4042,6 +4670,7 @@
     <string name="sim_action_no_thanks">No, graciis</string>
     <string name="sim_action_cancel">Anule</string>
     <string name="sim_switch_button">Cambie</string>
+    <string name="sim_action_turn_off">Disative</string>
     <string name="dsds_activation_failure_title">Impussibil ativâ la SIM</string>
     <string name="dsds_activation_failure_body_msg2">Prove a ativâ di gnûf la SIM. Se il probleme al persist, torne invie il dispositîf.</string>
     <string name="sim_setup_channel_id">Ativazion de rêt</string>
@@ -4066,6 +4695,7 @@
     <string name="switch_sim_dialog_no_switch_title">Nissune SIM ative disponibile</string>
     <string name="switch_sim_dialog_no_switch_text">Par doprâ i dâts mobii, lis funzions di clamade e i SMS intun secont moment, va in impostazions di rêt</string>
     <string name="sim_card_label">SIM</string>
+    <string name="erase_sim_dialog_title">Scancelâ cheste eSIM?</string>
     <string name="erase_sim_dialog_text">La cancelazion di cheste SIM e gjave il servizi di <xliff:g id="carrier_name_a" example="Google Fi">%1$s</xliff:g> di chest dispositîf.\n\nIl servizi par <xliff:g id="carrier_name_b" example="Google Fi">%1$s</xliff:g> nol vignarà anulât.</string>
     <string name="erase_sim_confirm_button">Elimine</string>
     <string name="erasing_sim">Cancelazion SIM…</string>
@@ -4104,6 +4734,10 @@
     <string name="contextual_card_feedback_confirm_message">Desideristu dânus une opinion su chest sugjeriment?</string>
     <string name="copyable_slice_toast"><xliff:g id="copy_content" example="Phone number">%1$s</xliff:g> copiât intes notis.</string>
     <string name="accessibility_usage_title">Utilizazion acès facilitât</string>
+    <string name="accessibility_usage_summary">{count, plural,
+      one {}=1      {1 aplicazion e à acès complet al to dispositîf}
+      other   {# aplicazions a àn acès complet al to dispositîf}
+    }</string>
     <string name="wfc_disclaimer_title_text">Informazions impuartantis</string>
     <string name="wfc_disclaimer_agree_button_text">CONTINUE</string>
     <string name="wfc_disclaimer_disagree_text">NO GRACIIS</string>
@@ -4113,6 +4747,17 @@
     <string name="content_capture">Contignûts aplicazions</string>
     <string name="content_capture_summary">Al permet aes aplicazions di mandâ contignûts al sisteme Android</string>
     <string name="capture_system_heap_dump_title">Acuisizion scaric dal heap di sisteme</string>
+    <string name="development_memtag_page_title">Estension par etichetâ memorie</string>
+    <string name="development_memtag_intro">La estension par etichetâ la memorie (MTE) e permet di cjatâ cun plui facilitât i problemis di sigurece de memorie te tô aplicazion e e rint plui sigûr il so codiç natîf.</string>
+    <string name="development_memtag_footer">La ativazion di MTE e podarès puartâ a ralentaments des prestazions dal dispositîf.</string>
+    <string name="development_memtag_learn_more">Scuvierç di plui su MTE</string>
+    <string name="development_memtag_toggle">Ative MTE fintremai che no tu le disativis</string>
+    <string name="development_memtag_reboot_message_on">Tu varâs di tornâ a inviâ il dispositîf par ativâ MTE.</string>
+    <string name="development_memtag_reboot_message_off">Tu varâs di tornâ a inviâ il dispositîf par disativâ MTE.</string>
+    <string name="reboot_with_mte_title">Ative MTE par une singule session</string>
+    <string name="reboot_with_mte_message">Il sisteme si tornarà a inviâ e al consintarà di sperimentâ la estension par etichetâ la memorie (MTE - Memory Tagging Extension). Al è pussibil che MTE al influissi in mût negatîf su prestazions e stabilitât dal sisteme. Al vignarà ripristinât al sucessîf gnûf inviament dal sisteme.</string>
+    <string name="reboot_with_mte_summary">Torne invie par une singule session cun MTE ativade</string>
+    <string name="reboot_with_mte_already_enabled">MTE e je za ativade</string>
     <string name="capturing_system_heap_dump_message">Acuisizion dal scaric dal heap di sisteme</string>
     <string name="error_capturing_system_heap_dump_message">Impussibil cjapâ sù il scaric dal heap di sisteme</string>
     <string name="automatic_system_heap_dump_title">Cjape sù in automatic i scarics dal heap di sisteme</string>
@@ -4121,9 +4766,6 @@
     <string name="wfc_disclaimer_emergency_limitation_title_text">Clamadis di emergjence</string>
     <string name="wfc_disclaimer_emergency_limitation_desc_text">Lis clamadis di emergjence midiant Wi\u2011Fi no son supuartadis dal to operadôr.\nIl dispositîf al passe in automatic a une rêt celulâr par fâ une clamade di emergjence.\nLis clamadis di emergjence a son pussibilis dome in areis cun cuvierture celulâr.</string>
     <string name="wifi_calling_summary">Dopre il Wi\u2011Fi pes clamadis par miorâ la cualitât</string>
-    <string name="backup_calling_settings_title">Clamadis di backup</string>
-    <string name="backup_calling_setting_summary">Se <xliff:g id="backup_calling_operator_text" example="Google Fi">%1$s</xliff:g> nol è disponibil o al è in roaming, dopre la tô SIM pai dâts mobii par fâ clamadis midiant <xliff:g id="backup_calling_carrier_text" example="Google Fi">%1$s</xliff:g>.</string>
-    <string name="keywords_backup_calling">clamadis di backup</string>
     <string name="enable_receiving_mms_notification_title">Messaç SMS in jentrade</string>
     <string name="enable_sending_mms_notification_title">Impussibil inviâ il massaç MMS</string>
     <string name="enable_mms_notification_summary">Tocje par permeti la spedizion di messaçs MMS su <xliff:g id="operator_name" example="T-Mobile">%1$s</xliff:g> cuant che i dâts mobii a son disativâts</string>
@@ -4156,8 +4798,14 @@
     <string name="power_menu_long_press_for_assist_sensitivity_high_label">Lunc</string>
     <string name="lockscreen_privacy_wallet_setting_toggle">Mostre tacuin</string>
     <string name="lockscreen_privacy_wallet_summary">Permet l\'acès al tacuin da la schermade di bloc</string>
+    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle">Mostre scansionadôr di codiçs QR</string>
+    <string name="lockscreen_privacy_qr_code_scanner_summary">Permet l\'acès al scansionadôr di codiçs QR da la schermade di bloc</string>
     <string name="lockscreen_privacy_controls_setting_toggle">Mostre controi dai dispositîfs</string>
+    <string name="lockscreen_privacy_controls_summary">Dal bloc schermi</string>
+    <string name="lockscreen_trivial_controls_setting_toggle">Doprâ controi dal dispositîf</string>
     <string name="lockscreen_trivial_disabled_controls_summary">Par doprâ i controi, prime ative \u0022Mostre controi dai dispositîfs\u0022</string>
+    <string name="lockscreen_double_line_clock_summary">La dimension dal orloi e cambie in base al contignût de schermade di bloc</string>
+    <string name="lockscreen_double_line_clock_setting_toggle">Orloi dinamic</string>
     <string name="lockscreen_quick_affordances_title">Scurtis</string>
     <plurals name="lockscreen_quick_affordances_summary">
         <item quantity="one"><xliff:g id="first">%1$s</xliff:g></item>
@@ -4177,7 +4825,6 @@
     <string name="media_controls_resume_description">Par ripiâ daurman la riproduzion, il riprodutôr multimediâl al reste viert tes Impostazions rapidis</string>
     <string name="media_controls_lockscreen_title">Mostre contignûts multimediâi te schermade di bloc</string>
     <string name="media_controls_lockscreen_description">Par ripiâ daurman la riproduzion, il riprodutôr multimediâl al reste viert te schermade di bloc</string>
-    <string name="media_controls_recommendations_title">Mostre conseis su contignûts multimediâi</string>
     <string name="media_controls_recommendations_description">In base aes tôs ativitâts</string>
     <string name="media_controls_hide_player">Plate riprodutôr</string>
     <string name="media_controls_show_player">Mostre riprodutôr</string>
@@ -4197,7 +4844,7 @@
     <string name="calls_sms_temp_unavailable">Pal moment no disponibil</string>
     <string name="calls_sms_no_sim">Nissune SIM</string>
     <string name="network_and_internet_preferences_title">Preferencis di rêt</string>
-    <string name="keywords_internet">conession di rêt, internet, wireless, cence fîi, dâts, wifi, wi-fi, celulâr, mobil, operadôr telefonic, 4g, 3g, 2g, lte</string>
+    <string name="keywords_internet">conession di rêt, internet, wireless, cence fîi, dâts, wifi, wi-fi, celulâr, mobile, operadôr telefonic, 4g, 3g, 2g, lte</string>
     <string name="reset_your_internet_title">Ristabilî la conession a internet?</string>
     <string name="resetting_internet_text">Daûr a ripristinâ la conession a internet\u2026</string>
     <string name="fix_connectivity">Risolf i problemis di conession</string>
@@ -4207,8 +4854,10 @@
     <string name="carrier_wifi_offload_summary">Permet a Google Fi di doprâ lis rêts W+ par miorâ la velocitât e la cuvierture</string>
     <string name="carrier_wifi_network_title">Rêt W+</string>
     <string name="sim_category_title">SIM</string>
+    <string name="downloaded_sim_category_title">eSIM</string>
+    <string name="downloaded_sims_category_title">eSIMs</string>
     <string name="sim_category_active_sim">Ative</string>
-    <string name="sim_category_inactive_sim">No ative</string>
+    <string name="sim_category_inactive_sim">Inativis</string>
     <string name="sim_category_default_active_sim">\u0020/ Predefinide par <xliff:g name="default_sim_config" example=" / Default for calls">%1$s</xliff:g></string>
     <string name="default_active_sim_calls">clamadis</string>
     <string name="default_active_sim_sms">SMS</string>
@@ -4217,6 +4866,8 @@
     <string name="wifi_scan_change">Cambie</string>
     <string name="preference_summary_default_combination"><xliff:g id="state" example="Connected">%1$s</xliff:g> / <xliff:g id="networkMode" example="LTE">%2$s</xliff:g></string>
     <string name="mobile_data_connection_active">Conetût</string>
+    <string name="mobile_data_temp_connection_active">Conetude in mût temporani</string>
+    <string name="mobile_data_temp_using"><xliff:g id="subName" example="Google Fi">%1$s</xliff:g> doprât in mût temporani</string>
     <string name="mobile_data_no_connection">Nissune conession</string>
     <string name="mobile_data_off_summary">I dâts mobii no si conetaran in automatic</string>
     <string name="mobile_data_disable_title">Disativâ i dâts mobii?</string>
@@ -4246,6 +4897,7 @@
     <string name="developer_options_main_switch_title">Dopre opzions svilupadôr</string>
     <string name="default_print_service_main_switch_title">Dopre servizi di stampe</string>
     <string name="multiple_users_main_switch_title">Permet utents multiplis</string>
+    <string name="multiple_users_main_switch_keywords">permeti, multiplis, utents, consinti, tancj</string>
     <string name="wireless_debugging_main_switch_title">Dopre debug vie wireless</string>
     <string name="graphics_driver_main_switch_title">Dopre preferencis dal driver grafic</string>
     <string name="night_light_main_switch_title">Dopre lûs noturne</string>
@@ -4259,6 +4911,7 @@
     <string name="smart_forwarding_ongoing_title">Impostazions di clamade</string>
     <string name="smart_forwarding_ongoing_text">Inzornament impostazions in cors...</string>
     <string name="smart_forwarding_failed_title">Erôr des impostazions di clamade</string>
+    <string name="smart_forwarding_failed_text">Erôr di rêt o de SIM.</string>
     <string name="smart_forwarding_failed_not_activated_text">La sim no je ativade.</string>
     <string name="smart_forwarding_input_mdn_title">Inserìs i numars di telefon</string>
     <string name="smart_forwarding_input_mdn_dialog_title">Inserìs il numar di telefon</string>
@@ -4267,6 +4920,9 @@
     <string name="enable_2g_title">Permet il 2G</string>
     <string name="enable_2g_summary">Il 2G al è mancul sigûr, ma al podarès miorâ la tô conession in cualchi lûc. Pes clamadis di emergjence, il 2G al è simpri consintût.</string>
     <string name="enable_2g_summary_disabled_carrier"><xliff:g id="carrier_name_2g" example="Google Fi">%1$s</xliff:g> al à bisugne che il 2G al sedi disponibil</string>
+    <string name="require_cellular_encryption_title">Pretindi cifradure</string>
+    <string name="require_cellular_encryption_summary">La cifradure e je plui sigure, ma no tu rivarâs a conetiti dapardut. Pes clamadis di emergjence, la cifradure no ven mai domandade</string>
+    <string name="app_info_all_services_label">Ducj i servizis</string>
     <string name="show_clip_access_notification">Mostre acès aes notis</string>
     <string name="show_clip_access_notification_summary">Mostre un messaç cuant che lis aplicazions a doprin test, imagjins o altris contignûts che tu âs copiâts</string>
     <string name="all_apps">Dutis lis aplicazions</string>
@@ -4274,6 +4930,7 @@
     <string name="uwb_settings_title">Bande ultra-largje (UWB)</string>
     <string name="uwb_settings_summary">E jude a identificâ la posizion relative dai dispositîfs tai contors che a àn la UWB</string>
     <string name="uwb_settings_summary_airplane_mode">Disative la modalitât avion par doprâ UWB</string>
+    <string name="uwb_settings_summary_no_uwb_regulatory">UWB nol è disponibil in chest lûc</string>
     <string name="camera_toggle_title">Acès ae fotocjamare</string>
     <string name="mic_toggle_title">Acès al microfon</string>
     <string name="perm_toggle_description">Par aplicazions e servizis</string>
@@ -4282,6 +4939,9 @@
     <string name="next_page_content_description">Indenant</string>
     <string name="colors_viewpager_content_description">Anteprime dal colôr</string>
     <string name="bluetooth_sim_card_access_notification_title">Richieste di acès ae SIM</string>
+    <string name="bluetooth_sim_card_access_notification_content">Un dispositîf al vûl acedi ae tô SIM. Tocje pai detais.</string>
+    <string name="bluetooth_sim_card_access_dialog_title">Permeti l\'acès ae SIM?</string>
+    <string name="bluetooth_sim_card_access_dialog_content">Un dispositîf Bluetooth, <xliff:g id="device_name" example="My device">%1$s</xliff:g>, al vûl acedi ai dâts de tô SIM. Chest al inclût i tiei contats.\n\nIntant che al è colegât, <xliff:g id="device_name" example="My device">%2$s</xliff:g> al ricevarà dutis lis clamadis fatis a <xliff:g id="phone_number" example="0912345678">%3$s</xliff:g>.</string>
     <string name="bluetooth_connect_access_notification_title">Dispositîf Bluetooth disponibil</string>
     <string name="bluetooth_connect_access_notification_content">Un dispositîf al vûl conetisi. Tocje pai detais.</string>
     <string name="bluetooth_connect_access_dialog_title">Conetisi al dispositîf Bluetooth?</string>
@@ -4297,6 +4957,7 @@
     <string name="tare_balances">Salts</string>
     <string name="tare_consumption_limits">Limits di consum</string>
     <string name="tare_initial_consumption_limit">Limit di consum iniziâl</string>
+    <string name="tare_min_consumption_limit">Limit di consum minim</string>
     <string name="tare_max_consumption_limit">Limit di consum massim</string>
     <string name="tare_modifiers">Modificadôrs</string>
     <string name="tare_actions_ctp">Azions (cost di produzion)</string>
@@ -4304,6 +4965,7 @@
     <string name="tare_rewards_instantaneous">Premis par singul event</string>
     <string name="tare_rewards_ongoing">Premis al secont di durade dal event</string>
     <string name="tare_rewards_max">Numar massim di premis al dì</string>
+    <string name="tare_app_install">Instalazion aplicazion</string>
     <string name="tare_top_activity">Prime ativitât</string>
     <string name="tare_notification_seen">Notifiche visualizade</string>
     <string name="tare_notification_seen_15_min">Notifiche visualizade dentri di 15 minûts</string>
@@ -4324,6 +4986,7 @@
     <string name="tare_min_balance_exempted">Salt minim cun dispositîf cjariât dal dut (esentadis aplicazions)</string>
     <string name="tare_min_balance_headless_app">Salt minim cun dispositf cjariât dal dut (aplicazions di sisteme cence IU)</string>
     <string name="tare_min_balance_other_app">Salt minim cun dispositîf cjariât dal dut (aplicazions che a restin)</string>
+    <string name="tare_min_balance_addition_app_updater">Zonte di belanç saturât minim (Inzornadôrs aplicazion)</string>
     <string-array name="tare_modifiers_subfactors">
         <item>In cjarie</item>
         <item>Polse</item>
@@ -4352,12 +5015,21 @@
     <string name="bluetooth_details_spatial_audio_summary">L\'audio dai dispositîfs multimediâi compatibii al cjape plui dentri</string>
     <string name="bluetooth_details_head_tracking_title">Rilevament dai moviments dal cjâf</string>
     <string name="bluetooth_details_head_tracking_summary">L\'audio al cambie in base a cemût che tu spostis il cjâf par rindi il sun plui naturâl</string>
+    <string name="bluetooth_details_audio_device_types_title">Gjenar di dipositîf audio</string>
     <string name="bluetooth_details_audio_device_type_unknown">No cognossût</string>
+    <string name="bluetooth_details_audio_device_type_speaker">Casse amplificade</string>
+    <string name="bluetooth_details_audio_device_type_headphones">Scufis</string>
+    <string name="bluetooth_details_audio_device_type_hearing_aid">Aparât acustic</string>
+    <string name="bluetooth_details_audio_device_type_carkit">Pacut par automobil</string>
     <string name="bluetooth_details_audio_device_type_other">Altri</string>
     <string name="ingress_rate_limit_title">Limit di velocitât par discjariâ de rêt</string>
     <string name="ingress_rate_limit_summary">Configure il limit di velocitât in jentrade de largjece di bande de rêt, chest al ven aplicât a dutis lis rêt che a dan conession a internet.</string>
     <string name="ingress_rate_limit_dialog_title">Configure limit di velocitât par discjariâ de rêt</string>
     <string name="ingress_rate_limit_no_limit_entry">Nissun limit</string>
+    <string name="disable_phantom_process_monitor_title">Disative limitazions dai procès fi</string>
+    <string name="disable_phantom_process_monitor_summary">Disative lis restrizions su la utilizazion des risorsis di sisteme pai procès fi de aplicazion</string>
+    <string name="enable_notes_role_title">Sfuarce la abilitazion de regule des Notis</string>
+    <string name="enable_notes_role_summary">Ative lis integrazions dal sisteme par cjapâ notis midiant la regule des Notis. Se la regule des Notis e je za ativade, nol fâs nuie. Al covente tornâ a inviâ.</string>
     <string name="bluetooth_broadcast_dialog_title">Trasmission</string>
     <string name="bluetooth_broadcast_dialog_broadcast_app">Trasmet <xliff:g id="currentApp" example="App Name 2">%1$s</xliff:g></string>
     <string name="bluetooth_broadcast_dialog_find_message">Scolte lis trasmissions in riproduzion tai contors</string>
@@ -4370,22 +5042,94 @@
     <string name="find_broadcast_password_dialog_title">Inserìs password</string>
     <string name="find_broadcast_password_dialog_connection_error">Impussibil conetisi. Torne prove.</string>
     <string name="find_broadcast_password_dialog_password_error">Password sbaliade</string>
+    <string name="find_broadcast_join_broadcast_error">Impussibil unîsi ae trasmission</string>
     <string name="bt_le_audio_scan_qr_code_scanner">Par scomençâ a scoltâ, centre il codiç QR chi sot</string>
     <string name="bt_le_audio_qr_code_is_not_valid_format">Il formât dal codiç QR nol è valit</string>
+    <string name="convert_to_esim_title">Convertìs a eSIM</string>
+    <string name="transfer_esim_to_another_device_title">Trasferìs eSIM suntun altri dispositîf</string>
+    <string name="background_install_preference_summary">{count, plural,
+    one {}=1    {# aplicazion}
+    other {# aplicazions}
+    }</string>
+    <string name="background_install_title">Aplicazions instaladis in sotfont</string>
+    <string name="background_install_summary">Il produtôr dal to dispositîf al podarès instalâ aplicazion sul dispositîf in sotfont, o permeti al to operadôr e altris colaboradôrs di fâlu.\u000a\u000aDutis lis aplicazions listadis achì no son necessaris pal normâl funzionament dal to dispositîf. Tu puedis disinstalâ lis aplicazions che no ti interessin. </string>
+    <string name="background_install_feature_list_no_entry">Nissune aplicazion instalade in sotfont</string>
     <string name="background_install_uninstall_button_description">Disinstale aplicazion</string>
+    <string name="background_install_before">{count, plural,
+    one {}=1    {Aplicazions instaladis tal ultin (#) mês}
+    other {Aplicazions instaladis tai ultins # mês}
+    }</string>
+    <string name="background_install_after">{count, plural,
+    one {}=1    {Aplicazions instaladis plui di # mês indaûr}
+    other {Aplicazions instaladis plui di # mês indaûr}
+    }</string>
+    <string name="aspect_ratio_title">Proporzions</string>
+    <string name="aspect_ratio_summary">Prove gnovis proporzions par viodi cheste aplicazion se no je progjetade par stâ tal schermi dal to <xliff:g id="device_name">%1$s</xliff:g></string>
+    <string name="aspect_ratio_main_summary">Prove gnovis proporzions par viodi cheste aplicazion se no je stade progjetade par stâ tal schermi dal to <xliff:g id="device_name">%1$s</xliff:g>. Al è pussibil che cualchi aplicazion no sedi otimizade par ciertis proporzions.</string>
+    <string name="aspect_ratio_summary_text">Prove gnovis proporzions par viodi une aplicazion se no je stade progjetade par stâ tal schermi dal to <xliff:g id="device_name">%1$s</xliff:g></string>
+    <string name="aspect_ratio_main_summary_text">Prove gnovis proporzions par viodi une aplicazion se no je stade progjetade par stâ tal schermi dal to <xliff:g id="device_name">%1$s</xliff:g>. Cualchi aplicazion no je otimizade par ciertis proporzions.</string>
+    <string name="user_aspect_ratio_suggested_apps_label">Aplicazions sugjeridis</string>
+    <string name="user_aspect_ratio_changed_apps_label">Aplicazions cambiadis</string>
+    <string name="user_aspect_ratio_app_default">Predefinidis de aplicazion</string>
     <string name="user_aspect_ratio_fullscreen">Plen schermi</string>
+    <string name="user_aspect_ratio_half_screen">Mieç schermi</string>
+    <string name="user_aspect_ratio_device_size">Proporzions schermi dispositîf</string>
+    <string name="user_aspect_ratio_16_9">16:9</string>
+    <string name="user_aspect_ratio_3_2">3:2</string>
+    <string name="user_aspect_ratio_4_3">4:3</string>
+    <string name="user_aspect_ratio_option_a11y"><xliff:g id="numerator">%1$s</xliff:g> par <xliff:g id="denominator">%2$s</xliff:g></string>
+    <string name="app_aspect_ratio_footer">Cuant che tu cambiis lis proporzions la aplicazion si tornarà a inviâ. Tu podaressis pierdi lis modifichis che no son stadis salvadis. Al è pussibil che cualchi aplicazion no sedi otimizade par ciertis proporzions.</string>
+    <string name="aspect_ratio_experimental_title">Proporzions (sperimentâl)</string>
+    <string name="aspect_ratio_experiment_title">Proporzions (esperiment)</string>
+    <string name="aspect_ratio_labs_title">Proporzions (laboratoris)</string>
     <string name="aspect_ratio_experimental_label">Sperimentâls</string>
+    <string name="aspect_ratio_experiment_label">Esperiment</string>
+    <string name="aspect_ratio_labs_label">Laboratoris</string>
+    <string name="accessibility_fingerprint_label">Sensôr di impronts digjitâi</string>
+    <string name="flash_notifications_title">Notifichis lamp</string>
+    <string name="flash_notifications_about_title">Informazions su notifichis lamp</string>
     <string name="flash_notifications_summary_off">Off</string>
+    <string name="flash_notifications_summary_on_camera">On / Lamp de fotocjamare</string>
+    <string name="flash_notifications_summary_on_screen">On / Lamp dal schermi</string>
+    <string name="flash_notifications_summary_on_camera_and_screen">On / Lamp di fotocjamare e schermi</string>
+    <string name="flash_notifications_intro">Fâs lampâ la lûs de fotocjamare o chê dal schermi cuant che tu ricevis notifichis o cuant che a sunin lis sveis</string>
+    <string name="flash_notifications_intro_without_camera_flash">Fâs lampâ il schermi cuant che tu ricevis notifichis o cuant che a sunin lis sveis</string>
+    <string name="flash_notifications_note">Dopre cun cautele lis notifichis lamp se tu âs une sensibilitât ae lûs</string>
+    <string name="flash_notifications_keywords">lamp, lûs, fadie a sintî, pierdite di uldide</string>
     <string name="flash_notifications_preview">Anteprime</string>
+    <string name="camera_flash_notification_title">Lamp de fotocjamare</string>
+    <string name="screen_flash_notification_title">Lamp dal schermi</string>
+    <string name="screen_flash_notification_color_title">Colôr de lampade dal schermi</string>
     <string name="screen_flash_color_blue">Blu</string>
+    <string name="screen_flash_color_azure">Turchin</string>
     <string name="screen_flash_color_cyan">Ciano</string>
+    <string name="screen_flash_color_spring_green">Vert di vierte</string>
     <string name="screen_flash_color_green">Vert</string>
+    <string name="screen_flash_color_chartreuse_green">Vert certose</string>
     <string name="screen_flash_color_yellow">Zâl</string>
     <string name="screen_flash_color_orange">Naranç</string>
     <string name="screen_flash_color_red">Ros</string>
+    <string name="screen_flash_color_rose">Rose</string>
     <string name="screen_flash_color_magenta">Magenta</string>
+    <string name="screen_flash_color_violet">Viole</string>
     <string name="color_selector_dialog_done">Fat</string>
     <string name="color_selector_dialog_cancel">Anule</string>
+    <string name="contrast_title">Contrast</string>
+    <string name="contrast_standard">Standard</string>
     <string name="contrast_medium">Medie</string>
     <string name="contrast_high">Alte</string>
+    <string name="dock_multi_instances_not_supported_text">"Al è pussibil vierzi cheste aplicazion dome in 1 barcon"</string>
+    <string name="generic_accessibility_service_on">On</string>
+    <string name="generic_accessibility_service_off">Off</string>
+    <string name="generic_accessibility_feature_shortcut_off">Off</string>
+    <string name="accessibility_shortcut_state_off">Off</string>
+    <string name="daltonizer_state_on">On</string>
+    <string name="daltonizer_state_off">Off</string>
+    <string name="color_inversion_state_on">On</string>
+    <string name="color_inversion_state_off">Off</string>
+    <string name="autoclick_disabled">Off</string>
+    <string name="show_captions_disabled">Off</string>
+    <string name="show_captions_enabled">On</string>
+    <string name="live_caption_disabled">Off</string>
+    <string name="live_caption_enabled">On</string>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-gd/strings.xml b/overlay/packages/apps/Settings/res/values-gd/strings.xml
index 575b70a..e386377 100644
--- a/overlay/packages/apps/Settings/res/values-gd/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-gd/strings.xml
@@ -89,6 +89,7 @@
     <string name="connected_device_previously_connected_screen_title">Bha ceangal ris roimhe</string>
     <string name="connected_device_bluetooth_turned_on_toast">Tha Bluetooth air</string>
     <string name="previous_connected_see_all">Seall na h-uile</string>
+    <string name="connected_device_fast_pair_device_see_all">Seall na h-uile</string>
     <string name="date_and_time">Ceann-là ⁊ àm</string>
     <string name="proxy_settings_title">Progsaidh</string>
     <string name="proxy_clear_text">Falamhaich</string>
@@ -218,6 +219,13 @@
     <string name="setup_fingerprint_enroll_skip_after_adding_lock_text">Cha doir suidheachadh luirg-mheòir ach mionaid no dhà. Ma ghearras tu leum thairis air, ’s urrainn dhut do lorg-meòir a chur ris uaireigin eile sna roghainnean.</string>
     <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2">Mar a dh’obraicheas e</string>
     <string name="security_settings_activeunlock_biometric_setup">Suidhich</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">Chan ann an-dràsta</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">Air adhart</string>
+    <string name="security_settings_remoteauth_enroll_introduction_more">Barrachd</string>
+    <string name="security_settings_remoteauth_enroll_introduction_how_title">Mar a dh’obraicheas e</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Sguir dheth</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">Dearbh</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">Deiseil</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">Ceart ma-thà</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">Ceart ma-thà</string>
     <string name="lock_screen_intro_skip_title">An leum thu thairis air glas na sgrìn?</string>
@@ -255,6 +263,17 @@
     <string name="security_header">Tèarainteachd</string>
     <string name="privacy_header">Prìobhaideachd</string>
     <string name="work_profile_category_header">Pròifil na h-obrach</string>
+    <string name="private_space_biometric_summary">Thoir gnogag gus a shuidheachadh</string>
+    <string name="private_space_screen_lock_summary">Mar glas sgrìn an uidheim</string>
+    <string name="privatespace_hide_off_summary">Dheth</string>
+    <string name="privatespace_hide_on_summary">Air</string>
+    <string name="private_space_category_system">An siostam</string>
+    <string name="no_device_lock_action_label">Suidhich glas na sgrìn</string>
+    <string name="no_device_lock_cancel">Sguir dheth</string>
+    <string name="private_space_cancel_label">Sguir dheth</string>
+    <string name="private_space_setup_button_label">Suidhich</string>
+    <string name="private_space_how_title">Mar a dh’obraicheas e</string>
+    <string name="private_space_done_label">Deiseil</string>
     <string name="fingerprint_add_max">’S urrainn dhut suas ri <xliff:g id="count" example="5">%d</xliff:g> lorg(an)-meòir a chur ris</string>
     <string name="fingerprint_intro_error_max">Chuir thu na tha ceadaichte de lorgan-meòir ris</string>
     <string name="fingerprint_intro_error_unknown">Chan urrainn dhut barrachd lorgan-meòir a chur ris</string>
@@ -333,7 +352,6 @@
     <string name="bluetooth_device_context_connect">Ceangail</string>
     <string name="bluetooth_device_context_disconnect">Bris an ceangal</string>
     <string name="bluetooth_device_context_pair_connect">Paidhrich ⁊ ceangail</string>
-    <string name="bluetooth_empty_list_bluetooth_off">Nuair a bhios Bluetooth air, nì an t-uidheam agad conaltradh le uidheaman Bluetooth eile am fagas.</string>
     <string name="bluetooth_scan_change">Atharraich</string>
     <string name="device_details_title">Mion-fhiosrachadh mun uidheam</string>
     <string name="bluetooth_device_mac_address">Seo seòladh Bluetooth an uidheim: <xliff:g id="address">%1$s</xliff:g></string>
@@ -497,14 +515,12 @@
     <string name="lost_internet_access_cancel">Fuirich air WiFi</string>
     <string name="lost_internet_access_persist">Na seall seo a-rithist</string>
     <string name="wifi_connect">Ceangail</string>
-    <string name="wifi_turned_on_message">Tha WiFi air</string>
     <string name="wifi_connected_to_message">Ceangailte ri <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
     <string name="wifi_connecting">’Ga cheangal\u2026</string>
     <string name="wifi_failed_connect_message">Cha b’ urrainn dhuinn ceangal ris an lìonra</string>
     <string name="wifi_not_in_range_message">Tha an lìonra ro fhad air falbh</string>
     <string name="wifi_forget">Dìochuimhnich</string>
     <string name="wifi_modify">Atharraich</string>
-    <string name="wifi_failed_forget_message">Cha b’ urrainn dhuinn an lìonra a dhìochuimhneachadh</string>
     <string name="wifi_save">Sàbhail</string>
     <string name="wifi_failed_save_message">Dh’fhàillig le sàbhaladh an lìonraidh</string>
     <string name="wifi_cancel">Sguir dheth</string>
@@ -547,7 +563,6 @@
     <string name="wifi_hotspot_no_password_subtext">Cha deach facal-faire a shuidheachadh</string>
     <string name="wifi_hotspot_name_title">Ainm a’ hotspot</string>
     <string name="wifi_hotspot_password_title">Facal-faire a’ hotspot</string>
-    <string name="wifi_hotspot_ap_band_title">Bann AP</string>
     <string name="wifi_hotspot_auto_off_title">Cuir an hotspot dheth gu fèin-obrachail</string>
     <string name="wifi_hotspot_auto_off_summary">Mur eil uidheam ceangailte ris</string>
     <string name="wifi_hotspot_speed_2g">2.4 GHz</string>
@@ -896,16 +911,6 @@
     <string name="tether_settings_summary_all">Hotspot, USB, Bluetooth, Ethernet</string>
     <string name="tether_settings_summary_off">Chan eil an t-eadar-lìon ’ga cho-roinneadh le uidheaman eile</string>
     <string name="tether_preference_summary_off">Dheth</string>
-    <string name="tethering_interface_options">Teadhrachadh</string>
-    <string name="disable_wifi_hotspot_title">Na cleachd hotspot WiFi</string>
-    <string name="disable_wifi_hotspot_when_usb_on">Na co-roinn an t-eadar-lìon ach thar USB</string>
-    <string name="disable_wifi_hotspot_when_bluetooth_on">Na co-roinn an t-eadar-lìon ach thar Bluetooth</string>
-    <string name="disable_wifi_hotspot_when_ethernet_on">Na co-roinn an t-eadar-lìon ach thar Ethernet</string>
-    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on">Na co-roinn an t-eadar-lìon ach thar USB ’s Bluetooth</string>
-    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on">Na co-roinn an t-eadar-lìon ach thar USB ’s Ethernet</string>
-    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on">Na co-roinn an t-eadar-lìon ach thar Bluetooth ’s Ethernet</string>
-    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on">Na co-roinn an t-eadar-lìon ach thar USB, Bluetooth ’s Ethernet</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">Teadhrachadh USB</string>
     <string name="bluetooth_tether_checkbox_text">Teadhrachadh Bluetooth</string>
     <string name="ethernet_tether_checkbox_text">Teadhrachadh Ethernet</string>
@@ -913,7 +918,6 @@
     <string name="tethering_footer_info_sta_ap_concurrency">Cleachd hotspot is teadhrachadh airson an t-eadar-lìon a sholar do dh’uidheaman eile tron cheangal dàta WiFi no mobile agad. ’S urrainn do dh’aplacaidean hotspot a chruthachadh cuideachd airson susbaint a cho-roinneadh le uidheaman faisg orra.</string>
     <string name="tethering_help_button_text">Cobhair</string>
     <string name="network_settings_title">Lìonra mobile</string>
-    <string name="manage_mobile_plan_title" translatable="true">Plana mobile</string>
     <string name="sms_application_title" translatable="true">Aplacaid SMS</string>
     <string name="sms_change_default_dialog_title" translatable="true">An atharraich thu aplacaid nan SMS?</string>
     <string name="sms_change_default_dialog_text" translatable="true">An cleachd thu <xliff:g id="new_app">%1$s</xliff:g> an àite <xliff:g id="current_app">%2$s</xliff:g> ’nad aplacaid SMS?</string>
@@ -921,10 +925,6 @@
     <string name="network_scorer_change_active_dialog_title">An atharraich dhut cuidiche a’ WiFi?</string>
     <string name="network_scorer_change_active_dialog_text">An cleachd thu <xliff:g id="new_app">%1$s</xliff:g> an àite <xliff:g id="current_app">%2$s</xliff:g> airson na ceanglaichean lìonraidh agad a stiùireadh?</string>
     <string name="network_scorer_change_active_no_previous_dialog_text">An cleachd thu <xliff:g id="new_app">%s</xliff:g> airson na ceanglaichean lìonraidh agad a stiùireadh?</string>
-    <string name="mobile_unknown_sim_operator" translatable="true">Gnìomharaiche SIM nach aithne dhuinn</string>
-    <string name="mobile_no_provisioning_url">Chan aithne dhuinn làrach-lìn solair aig <xliff:g id="operator">%1$s</xliff:g></string>
-    <string name="mobile_insert_sim_card" translatable="true">Cuir a-steach cairt SIM is ath-thòisich</string>
-    <string name="mobile_connect_to_internet" translatable="true">Ceangail ris an eadar-lìon</string>
     <string name="location_category_recent_location_requests">Iarrtasan ionaid o chionn goirid</string>
     <string name="managed_profile_location_switch_title">Ionad pròifil na h-obrach</string>
     <string name="location_app_permission_summary_location_off">Tha gleus an ionaid dheth</string>
@@ -1278,7 +1278,6 @@
     <string name="accessibility_magnification_mode_dialog_option_window">Meudaich pàirt dhen sgrìn</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button">Sguir dheth</string>
     <string name="accessibility_magnification_service_settings_title">Roghainnean a’ mheudachaidh</string>
-    <string name="accessibility_screen_magnification_gestures_title">Meudaich le trì gnogagan</string>
     <string name="accessibility_screen_magnification_navbar_title">Meudaich le ath-ghoirid</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture">Meudaich le ath-ghoirid ⁊ trì gnogagan</string>
     <string name="accessibility_introduction_title">Mu dhèidhinn <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
@@ -1451,11 +1450,7 @@
     </string>
     <string name="accessibility_dialog_button_allow">Ceadaich</string>
     <string name="accessibility_dialog_button_deny">Diùlt</string>
-    <string name="accessibility_dialog_button_stop">Cuir stad air</string>
-    <string name="accessibility_dialog_button_cancel">Sguir dheth</string>
-    <string name="disable_service_title">An cuir thu stad air <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
-    <string name="disable_service_message">Cuiridh gnogag air <xliff:g id="stop" example="Stop">%1$s</xliff:g> stad
-        air <xliff:g id="service" example="TalkBack">%2$s</xliff:g>.</string>
+    <string name="accessibility_dialog_button_stop">Cuir dheth</string>
     <string name="accessibility_no_services_installed">Chaidh seirbheis a stàladh</string>
     <string name="accessibility_no_service_selected">Cha deach seirbheis a thaghadh</string>
     <string name="accessibility_service_default_description">Cha deach tuairisgeul a sholar.</string>
@@ -1493,10 +1488,12 @@
             – <xliff:g id="status">%2$s</xliff:g></string>
     <string name="power_discharge_remaining"><xliff:g id="remain">%1$s</xliff:g> air fhàgail</string>
     <string name="power_charge_remaining"><xliff:g id="until_charged">%1$s</xliff:g> ri theàirrdseadh</string>
+    <string name="power_usage_detail_screen_time">Sgrìn-ùine</string>
     <string name="background_activity_summary">Leig leis an aplacaid ruith sa chùlaibh</string>
     <string name="background_activity_warning_dialog_title">A bheil thu airson an gnìomhachd sa chùlaibh a chuingeachadh?</string>
     <string name="background_activity_warning_dialog_text">Ma chuingicheas tu gnìomhachd aplacaid sa chùlaibh, dh’fhaoidte gun dèan i rudan neònach</string>
     <string name="background_activity_disabled_dialog_text">O chionn ’s nach deach an aplacaid seo a shuidheachadh ach an caomhnadh i bataraidh, chan urrainn dhut a cuingeachadh.\n\nAirson an aplacaid a chuingeachadh, cuir piseachadh a’ bhataraidh air an toiseach.</string>
+    <string name="manager_battery_usage_category_title">Stiùirich caitheamh a’ bhataraidh</string>
     <string name="manager_battery_usage_restricted_title">Cuingichte</string>
     <string name="device_screen_usage">Caitheamh leis an sgrìn o àm na làn-teàirrds</string>
     <string name="advanced_battery_title">Caitheamh a’ bhataraidh</string>
@@ -1661,8 +1658,6 @@
     <string name="emergency_tone_title">Siognail daithealaidh-èiginn</string>
     <string name="emergency_tone_summary">Suidhich an giùlan nuair a thèid gairm-èiginn a chur</string>
     <string name="privacy_settings_title">Lethbhreac-glèidhidh</string>
-    <string name="backup_summary_state_on">Air</string>
-    <string name="backup_summary_state_off">Dheth</string>
     <string name="backup_section_title">Lethbhreac-glèidhidh ⁊ aiseag</string>
     <string name="personal_data_section_title">Dàta pearsanta</string>
     <string name="backup_data_title">Dèan lethbhreac-glèidhidh dhen dàta agam</string>
@@ -1803,31 +1798,18 @@
     <string name="vpn_name">Ainm</string>
     <string name="vpn_type">Seòrsa</string>
     <string name="vpn_server">Seòladh an fhrithealaiche</string>
-    <string name="vpn_mppe">Crioptachadh PPP (MPPE)</string>
-    <string name="vpn_l2tp_secret">Rùn-dìomhair L2TP</string>
     <string name="vpn_ipsec_identifier">Aithnichear IPSec</string>
     <string name="vpn_ipsec_secret">Iuchair IPsec cho-roinnte ro làimh</string>
     <string name="vpn_ipsec_user_cert">Teisteanas IPSec cleachdaiche</string>
     <string name="vpn_ipsec_ca_cert">Teisteanas IPSec ùghdarrais </string>
     <string name="vpn_ipsec_server_cert">Teisteanas IPSec frithealaiche</string>
     <string name="vpn_show_options">Seall na roghainnean adhartach</string>
-    <string name="vpn_search_domains">Àrainnean luirg DNS</string>
-    <string name="vpn_dns_servers">Frithealaichean DNS (m.e. 8.8.8.8)</string>
-    <string name="vpn_routes">Slighean sìnidh air adhart (m.e. 10.0.0.0/8)</string>
     <string name="vpn_username">Ainm-cleachdaiche</string>
     <string name="vpn_password">Facal-faire</string>
     <string name="vpn_save_login">Sàbhail fiosrachadh a’ chunntais</string>
     <string name="vpn_not_used">(gun chleachdadh)</string>
     <string name="vpn_no_ca_cert">(na dearbh am frithealaiche)</string>
     <string name="vpn_no_server_cert">(air fhaighinn on fhrithealaiche)</string>
-    <string name="vpn_always_on_invalid_reason_type">Chan urrainn dhut an seòrsa seo dhe VPN a chumail ceangailte
-        fad na h-ùine</string>
-    <string name="vpn_always_on_invalid_reason_server">Cha chuir VPN a bhios air an-còmhnaidh taic ach ri seòlaidhean
-        frithealaiche àireamhach</string>
-    <string name="vpn_always_on_invalid_reason_no_dns">Feumaidh tu frithealaiche DNS a shònrachadh dha VPN
-        a bhios air an-còmhnaidh</string>
-    <string name="vpn_always_on_invalid_reason_dns">Feumaidh seòlaidhean àireamhach a bhith aig frithealaichean DNS
-        dha VPN a bhios air an-còmhnaidh</string>
     <string name="vpn_always_on_invalid_reason_other">Cha chuir am fiosrachadh a chuir thu a-steach taic ri
         VPN a bhios air an-còmhnaidh</string>
     <string name="vpn_cancel">Sguir dheth</string>
@@ -1964,10 +1946,6 @@
     <string name="amber_alerts_title">Rabhaidhean AMBER</string>
     <string name="amber_alerts_summary">Faigh sanasan mu chlann fo bhruid</string>
     <string name="repeat_title">Dèanamh a-rithist</string>
-    <string name="call_manager_enable_title">Cuir manaidsear nan gairm an comas</string>
-    <string name="call_manager_enable_summary">Leig leis an t-seirbheis seo an dòigh a stiùireadh air an dèid gairmean a dhèanamh.</string>
-    <string name="call_manager_title">Manaidsear nan gairm</string>
-    <string name="call_manager_summary"><xliff:g id="app">%1$s</xliff:g></string>
     <string name="cell_broadcast_settings">Rabhaidhean èiginn uèirleas</string>
     <string name="network_operators_settings">Solaraichean lìonraidh</string>
     <string name="access_point_names">Ainmean puing-inntrigidh</string>
@@ -2078,7 +2056,6 @@
     <string name="keywords_gesture">gestures, gluasadan</string>
     <string name="keywords_payment_settings">pay, tap, payments, pàigh, gnogag, pàigheadh</string>
     <string name="keywords_backup">backup, back up, lethbhreac-glèidhidh, lethbhreacan-glèidhidh</string>
-    <string name="keywords_assist_gesture_launch">gluasad</string>
     <string name="keywords_face_unlock">face, unlock, auth, sign in, aodann, glas, glais, neo-ghlas, dearbhadh, clàradh a-steach, clàraich a-steach</string>
     <string name="keywords_imei_info">imei, meid, min, prl version, imei sv, tionndadh, còd</string>
     <string name="keywords_sim_status_iccid_esim">network, mobile network state, service state, signal strength, mobile network type, roaming, iccid, eid, lìonra, staid, lìonra, seirbheis, neart, siognail, seòrsa, fàrsan, air fàrsan, lìonra inneil-làimhe</string>
@@ -2289,7 +2266,6 @@
     <string name="lock_screen_notifications_summary_show">Seall susbaint air fad nam brathan</string>
     <string name="lock_screen_notifications_summary_hide">Na seall susbaint dhìomhair nuair a bhios e glaiste</string>
     <string name="lock_screen_notifications_summary_disable">Na seall brathan idir</string>
-    <string name="lock_screen_notifications_interstitial_message">Ciamar a sheallas sinn an sgrìn-ghlasaidh dhut?</string>
     <string name="lock_screen_notifications_interstitial_title">An sgrìn-ghlasaidh</string>
     <string name="lock_screen_notifications_summary_show_profile">Seall susbaint air fad nam brathan obrach</string>
     <string name="lock_screen_notifications_summary_hide_profile">Falaich susbaint dhìomhair na h-obrach</string>
@@ -2773,7 +2749,6 @@
     <string name="cell_data_warning">Rabhadh dàta air <xliff:g name="amount" example="1 GB">^1</xliff:g></string>
     <string name="cell_data_limit">Crìoch dàta dhe <xliff:g name="amount" example="1 GB">^1</xliff:g></string>
     <string name="cell_data_warning_and_limit">Rabhadh dàta air <xliff:g name="amount" example="1 GB">^1</xliff:g>  / Crìoch dàta dhe <xliff:g name="amount" example="2 GB">^2</xliff:g></string>
-    <string name="operator_warning">Dh’fhaoidte gum bi cunntasachd a’ ghiùlanair air an dàta eadar-dhealaichte o chunntasachd an uidheim</string>
     <string name="data_used_template"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> air a chaitheamh</string>
     <string name="set_data_warning">Suidhich rabhadh dàta</string>
     <string name="data_warning">Rabhadh dàta</string>
@@ -2796,7 +2771,6 @@
     <string name="no_carrier_update_text">Chaidh ùrachadh <xliff:g name="time" example="3m">^2</xliff:g> air ais</string>
     <string name="carrier_and_update_now_text">Dìreach air ùrachadh le <xliff:g name="carrier" example="T-mobile">^1</xliff:g></string>
     <string name="no_carrier_update_now_text">Dìreach air ùrachadh</string>
-    <string name="launch_mdp_app_text">Seall am plana</string>
     <string name="launch_wifi_text">Seall am mion-fhiosrachadh</string>
     <string name="data_saver_title">Caomhnaiche an dàta</string>
     <string name="unrestricted_data_saver">Dàta gun chuingeachadh</string>
@@ -2868,7 +2842,6 @@
     <string name="quick_settings_developer_tiles">Leacagan grad-roghainnean an luchd-leasachaidh</string>
     <string name="adb_authorization_timeout_title">Cuir à comas a’ chrìoch-ùine air ùghdarrachadh adb</string>
     <string name="adb_authorization_timeout_summary">Cuir à comas cùl-ghairm ùghdarrachaidhean adb do shiostaman nach deach ath-cheangal am broinn na h-ùine bunaitich (7 làithean) no a chaidh a rèiteachadh leis a’ chleachdaiche (1 latha air a char as giorra).</string>
-    <string name="winscope_trace_quick_settings_title">Tracadh WinScope</string>
     <string name="sensors_off_quick_settings_title">Mothaichearan dheth</string>
     <string name="managed_profile_settings_title">Roghainnean pròifil na h-obrach</string>
     <string name="cross_profile_calendar_title">Mìosachan thar phròifilean</string>
@@ -3056,7 +3029,6 @@
     <string name="prevent_ringing_option_vibrate_summary">Dèan crith</string>
     <string name="prevent_ringing_option_mute_summary">Mùchte</string>
     <string name="pref_title_network_details">Mun lìonra</string>
-    <string name="about_phone_device_name_warning">Chì aplacaidean air an fhòn agad ainm an uidheim. Dh’fhaoidte gum faic daoine eile e cuideachd nuair a nì thu ceangal ri uidheaman Bluetooth eile no nuair a nì thu ceangal ri lìonra WiFi no nuair a shuidhicheas tu hotspot WiFi.</string>
     <string name="devices_title">Uidheaman</string>
     <string name="choose_network_title">Tagh lìonraidh</string>
     <string name="network_disconnected">Gun cheangal</string>
@@ -3166,6 +3138,7 @@
     <string name="sim_action_reboot">Ath-thòisich</string>
     <string name="sim_action_no_thanks">Chan iarr mi seo</string>
     <string name="sim_action_cancel">Sguir dheth</string>
+    <string name="sim_action_turn_off">Cuir dheth</string>
     <string name="sim_card_label">SIM</string>
     <string name="erase_sim_confirm_button">Suath bàn</string>
     <string name="network_connection_request_dialog_title">Ceangail ri uidheam</string>
@@ -3306,4 +3279,17 @@
     <string name="color_selector_dialog_cancel">Sguir dheth</string>
     <string name="contrast_medium">Meadhanach</string>
     <string name="contrast_high">Àrd</string>
+    <string name="generic_accessibility_service_on">Air</string>
+    <string name="generic_accessibility_service_off">Dheth</string>
+    <string name="generic_accessibility_feature_shortcut_off">Dheth</string>
+    <string name="accessibility_shortcut_state_off">Dheth</string>
+    <string name="daltonizer_state_on">Air</string>
+    <string name="daltonizer_state_off">Dheth</string>
+    <string name="color_inversion_state_on">Air</string>
+    <string name="color_inversion_state_off">Dheth</string>
+    <string name="autoclick_disabled">Dheth</string>
+    <string name="show_captions_disabled">Dheth</string>
+    <string name="show_captions_enabled">Air</string>
+    <string name="live_caption_disabled">Dheth</string>
+    <string name="live_caption_enabled">Air</string>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-kab-rDZ/strings.xml b/overlay/packages/apps/Settings/res/values-kab-rDZ/strings.xml
index 561ef5d..5894a3d 100644
--- a/overlay/packages/apps/Settings/res/values-kab-rDZ/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-kab-rDZ/strings.xml
@@ -39,6 +39,7 @@
     <string name="bluetooth_disable_hw_offload_dialog_confirm">Ales tanekra</string>
     <string name="bluetooth_disable_hw_offload_dialog_cancel">Sefsex</string>
     <string name="previous_connected_see_all">Wali akk</string>
+    <string name="connected_device_fast_pair_device_see_all">Wali akk</string>
     <string name="date_and_time">Azemz d wakud</string>
     <string name="proxy_settings_title">Apṛuksi</string>
     <string name="proxy_clear_text">Sfeḍ</string>
@@ -96,6 +97,12 @@
     <string name="security_settings_fingerprint_enroll_introduction_cancel">Sefsex</string>
     <string name="security_settings_fingerprint_enroll_introduction_no_thanks">Uhu tannemmit</string>
     <string name="security_settings_activeunlock_biometric_setup">Sebded</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">Mačči tura</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">Kemmel</string>
+    <string name="security_settings_remoteauth_enroll_introduction_more">Ugar</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Sefsex</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">Sentem</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">Immed</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">IH</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">IH</string>
     <string name="go_back_button_label">Uγal γer deffir</string>
@@ -110,6 +117,12 @@
     <string name="fingerprint_enroll_button_next">Γer zdat</string>
     <string name="security_header">Taγellist</string>
     <string name="privacy_header">Tabaḍnit</string>
+    <string name="privatespace_hide_off_summary">Insa</string>
+    <string name="private_space_category_system">Anagraw</string>
+    <string name="no_device_lock_cancel">Sefsex</string>
+    <string name="private_space_cancel_label">Sefsex</string>
+    <string name="private_space_setup_button_label">Sebded</string>
+    <string name="private_space_done_label">Immed</string>
     <string name="encryption_settings_title">Awgelhen</string>
     <string name="encrypted_summary">Yettwawgelhen</string>
     <string name="unlock_set_unlock_launch_picker_title">Aseḍru n wegdil</string>
@@ -251,7 +264,6 @@
     <string name="call_settings_title">Iγewwaṛen n usiwel</string>
     <string name="tether_settings_title_usb">Beṭṭu n tuqqna USB</string>
     <string name="tether_preference_summary_off">Insa</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">Beṭṭu n tuqqna USB</string>
     <string name="tethering_help_button_text">Tallelt</string>
     <string name="location_recent_location_access_see_all">Wali akk</string>
@@ -419,8 +431,7 @@
     <string name="color_magenta">_Magenta:</string>
     <string name="accessibility_dialog_button_allow">Sireg</string>
     <string name="accessibility_dialog_button_deny">Aggi</string>
-    <string name="accessibility_dialog_button_stop">Seḥbes</string>
-    <string name="accessibility_dialog_button_cancel">Sefsex</string>
+    <string name="accessibility_dialog_button_stop">Sens</string>
     <string name="settings_button">Iɣewwaṛen</string>
     <string name="print_settings_summary_no_service">Insa</string>
     <string name="print_menu_item_settings">Iɣewwaṛen</string>
@@ -463,7 +474,6 @@
     <string name="request_manage_credentials_allow">Sireg</string>
     <string name="no_certificate_management_app">Ula yiwen</string>
     <string name="privacy_settings_title">Sekles</string>
-    <string name="backup_summary_state_off">Insa</string>
     <string name="backup_data_title">Ḥrez isefka-iw</string>
     <string name="admin_more_details">Issin ugar</string>
     <string name="account_sync_settings_title">Amtawi</string>
@@ -733,6 +743,7 @@
     <string name="sim_action_reboot">Ales tanekra</string>
     <string name="sim_action_no_thanks">Uhu tannemmit</string>
     <string name="sim_action_cancel">Sefsex</string>
+    <string name="sim_action_turn_off">Sens</string>
     <string name="erase_sim_confirm_button">Effacer</string>
     <string name="network_connection_timeout_dialog_ok">Ɛreḍ tikkelt nniḍen</string>
     <string name="network_connection_connect_failure">Tuqqna tecceḍ</string>
@@ -793,4 +804,12 @@
     <string name="color_selector_dialog_cancel">Sefsex</string>
     <string name="contrast_medium">Alemmas</string>
     <string name="contrast_high">Haut</string>
+    <string name="generic_accessibility_service_off">Insa</string>
+    <string name="generic_accessibility_feature_shortcut_off">Insa</string>
+    <string name="accessibility_shortcut_state_off">Insa</string>
+    <string name="daltonizer_state_off">Insa</string>
+    <string name="color_inversion_state_off">Insa</string>
+    <string name="autoclick_disabled">Insa</string>
+    <string name="show_captions_disabled">Insa</string>
+    <string name="live_caption_disabled">Insa</string>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-ku/strings.xml b/overlay/packages/apps/Settings/res/values-ku/strings.xml
index 283205f..3eaf626 100644
--- a/overlay/packages/apps/Settings/res/values-ku/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-ku/strings.xml
@@ -94,6 +94,11 @@
     <string name="security_settings_face_enroll_dialog_ok">OK</string>
     <string name="security_settings_face_enroll_done">ئه‌نجام درا</string>
     <string name="security_settings_fingerprint_enroll_introduction_cancel">لابردن</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">ئێستا نا</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">بەردەوامبون</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">لابردن</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">دلنیاکردنەوە</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">ئه‌نجام درا</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">OK</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">OK</string>
     <string name="skip_anyway_button_label">تێپەڕە بەهەرجۆرێک بێ</string>
@@ -104,6 +109,11 @@
     <string name="security_settings_fingerprint_enroll_done">ئه‌نجام درا</string>
     <string name="fingerprint_enroll_button_next">دواتر</string>
     <string name="security_header">پاراستن</string>
+    <string name="privatespace_hide_off_summary">کوژاندنەوە</string>
+    <string name="privatespace_hide_on_summary">چالاککردن</string>
+    <string name="no_device_lock_cancel">لابردن</string>
+    <string name="private_space_cancel_label">لابردن</string>
+    <string name="private_space_done_label">ئه‌نجام درا</string>
     <string name="encryption_settings_title">نهێنیکاری</string>
     <string name="encrypted_summary">نهێنیکراوه‌</string>
     <string name="lock_settings_picker_title">ده‌ستنیشانکردنی قوفڵی ڕوونما</string>
@@ -133,7 +143,6 @@
     <string name="bluetooth_device_context_connect">گرێدان</string>
     <string name="bluetooth_device_context_disconnect">پچڕاندنی پەیوەندی</string>
     <string name="bluetooth_device_context_pair_connect">جووت بوون وamp; بەستنەوە</string>
-    <string name="bluetooth_empty_list_bluetooth_off">کاتێک بلوتوسەکەت هەڵکراوە, ئامێرەکەت ئەتوانێت پەیوەندی بکات بە ئامێرەکانی بلوتوسی نزیک.</string>
     <string name="nfc_reboot_dialog_confirm">ده‌ستپێكردنه‌وه‌</string>
     <string name="wifi_display_enable_menu_item">کارپێکردنی نیشاندانی وایه‌رلێس</string>
     <string name="wifi_display_no_devices_found">هیچ ئامێرێکی نزیک نه‌دۆزرایه‌وه‌.</string>
@@ -184,7 +193,6 @@
     <string name="wifi_connecting">بەستنەوە\u2026</string>
     <string name="wifi_failed_connect_message">بەستنەوە بە تۆڕ سەرکەوتو نەبو</string>
     <string name="wifi_forget">لەیادکردن</string>
-    <string name="wifi_failed_forget_message">لە بیر کردنەوەی تۆڕ سەرکەوتو نەبو</string>
     <string name="wifi_save">پاشەکەوتکردن</string>
     <string name="wifi_failed_save_message">پاشەکەوتکردنی تۆڕ سەرکەوتو نەبو</string>
     <string name="wifi_cancel">پاشگەزبونەوە</string>
@@ -327,17 +335,12 @@
     <string name="tether_settings_title_usb_bluetooth">پەیوەندی ئینتەرنێت بە</string>
     <string name="tether_settings_summary_hotspot_off_tether_on">پەیوەندی ئینتەرنێت بە</string>
     <string name="tether_preference_summary_off">کوژاندنەوە</string>
-    <string name="tethering_interface_options">پەیوەندی ئینتەرنێت بە</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">USB ئەشكيل</string>
     <string name="bluetooth_tether_checkbox_text">بلوتوس پەیوەستکردن</string>
     <string name="tethering_help_button_text">یارمەتی</string>
-    <string name="manage_mobile_plan_title" translatable="true">نەخشەی مۆبایل</string>
     <string name="sms_change_default_dialog_title" translatable="true">گۆڕینی بەرنامەیSMS?</string>
     <string name="sms_change_default_dialog_text" translatable="true">بەکارهێنان<xliff:g id="new_app">%1$s</xliff:g> instead of <xliff:g id="current_app">%2$s</xliff:g> وەکوSMS app?</string>
     <string name="sms_change_default_no_previous_dialog_text" translatable="true">بەکارهێنان<xliff:g id="new_app">%s</xliff:g> وەکو بەرنامەیSMS?</string>
-    <string name="mobile_insert_sim_card" translatable="true">تکایە سیمکارتی تیا بکە و دوبارە بیکوژێنەوە هەڵیکرسێنەوە</string>
-    <string name="mobile_connect_to_internet" translatable="true">تکایە پەیوەستی بکە بە ئەنتەرێتەوە</string>
     <string name="location_category_recent_location_requests">شوێنی تازە داواکراوە</string>
     <string name="location_no_recent_apps">هیچ بەرنامەیەک داوا نەکراوە بۆ ناوچەی</string>
     <string name="location_high_battery_use">بەکارهێنانی باتری بەرز</string>
@@ -582,9 +585,6 @@
         پێویستە بۆ:</string>
     <string name="accessibility_dialog_button_allow">ڕێگەدان</string>
     <string name="accessibility_dialog_button_deny">نکوڵیکردن</string>
-    <string name="accessibility_dialog_button_stop">وه‌ستاندن</string>
-    <string name="accessibility_dialog_button_cancel">لابردن</string>
-    <string name="disable_service_title">وەستان <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
     <string name="accessibility_no_services_installed">خزمەتگوزاری دانەمەزراوە</string>
     <string name="accessibility_service_default_description">هیچ زانیاریەک دابین نەکراوە.</string>
     <string name="settings_button">ڕێکخستنه‌کان</string>
@@ -671,8 +671,6 @@
     <string name="request_manage_credentials_allow">ڕێگەدان</string>
     <string name="no_certificate_management_app">هیچ</string>
     <string name="emergency_tone_summary">دانانی کرداری كۆمەڵە كاتێك تەلەفۆن كردنێكى بارى ناكاو دا دەنێرێت</string>
-    <string name="backup_summary_state_on">چالاککردن</string>
-    <string name="backup_summary_state_off">کوژاندنەوە</string>
     <string name="backup_section_title">پاڵپشتamp; ڕێکخستنەوە</string>
     <string name="personal_data_section_title">داتای کەسی</string>
     <string name="backup_data_title">پشتگیری کردنی داتاکانم</string>
@@ -753,17 +751,12 @@
     <string name="vpn_name">ناو</string>
     <string name="vpn_type">جۆر</string>
     <string name="vpn_server">ناونیشانی تۆڕ</string>
-    <string name="vpn_mppe">PPP encryption (MPPE)</string>
-    <string name="vpn_l2tp_secret">L2TP نهێنی</string>
     <string name="vpn_ipsec_identifier">IPSec ناسێنەر</string>
     <string name="vpn_ipsec_secret">IPSec کلیلی بەشدار</string>
     <string name="vpn_ipsec_user_cert">IPSec بڕوانامەی بەکارهێنەر</string>
     <string name="vpn_ipsec_ca_cert">IPSec CA بڕوانامە</string>
     <string name="vpn_ipsec_server_cert">IPSec بڕوانامەی خزمەتگوزاری</string>
     <string name="vpn_show_options">پیشاندانی بەربژاردەکانی پەرەسەندوو</string>
-    <string name="vpn_search_domains">DNS گەڕان domains</string>
-    <string name="vpn_dns_servers">DNS servers (e.g. 8.8.8.8)</string>
-    <string name="vpn_routes">سوڕانەوەی پێشەوە  (e.g. 10.0.0.0/8)</string>
     <string name="vpn_username">تێپەڕە وشە</string>
     <string name="vpn_password">تێپەڕەوشە</string>
     <string name="vpn_save_login">پاشەکەوتکردنی زانیاری هەژمار</string>
@@ -970,4 +963,17 @@
     <string name="color_selector_dialog_done">ئه‌نجام درا</string>
     <string name="color_selector_dialog_cancel">لابردن</string>
     <string name="contrast_medium">ناوه‌ندی</string>
+    <string name="generic_accessibility_service_on">چالاککردن</string>
+    <string name="generic_accessibility_service_off">کوژاندنەوە</string>
+    <string name="generic_accessibility_feature_shortcut_off">کوژاندنەوە</string>
+    <string name="accessibility_shortcut_state_off">کوژاندنەوە</string>
+    <string name="daltonizer_state_on">چالاککردن</string>
+    <string name="daltonizer_state_off">کوژاندنەوە</string>
+    <string name="color_inversion_state_on">چالاککردن</string>
+    <string name="color_inversion_state_off">کوژاندنەوە</string>
+    <string name="autoclick_disabled">کوژاندنەوە</string>
+    <string name="show_captions_disabled">کوژاندنەوە</string>
+    <string name="show_captions_enabled">چالاککردن</string>
+    <string name="live_caption_disabled">کوژاندنەوە</string>
+    <string name="live_caption_enabled">چالاککردن</string>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-lb/strings.xml b/overlay/packages/apps/Settings/res/values-lb/strings.xml
index 5ac7191..d73c021 100644
--- a/overlay/packages/apps/Settings/res/values-lb/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-lb/strings.xml
@@ -108,6 +108,12 @@
     <string name="security_settings_face_enroll_done">Fäerdeg</string>
     <string name="security_settings_fingerprint_enroll_introduction_cancel">Ofbriechen</string>
     <string name="security_settings_fingerprint_enroll_introduction_no_thanks">Nee Merci</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">Net elo</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">Weider</string>
+    <string name="security_settings_remoteauth_enroll_introduction_more">Méi</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Ofbriechen</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">Bestätegen</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">Fäerdeg</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">OK</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">OK</string>
     <string name="skip_anyway_button_label">Trotzdeem iwwersprangen</string>
@@ -120,6 +126,12 @@
     <string name="fingerprint_enroll_button_next">Weider</string>
     <string name="security_header">Sécherheet</string>
     <string name="work_profile_category_header">Aarbechtsprofil</string>
+    <string name="privatespace_hide_off_summary">Aus</string>
+    <string name="privatespace_hide_on_summary">Un</string>
+    <string name="private_space_category_system">System</string>
+    <string name="no_device_lock_cancel">Ofbriechen</string>
+    <string name="private_space_cancel_label">Ofbriechen</string>
+    <string name="private_space_done_label">Fäerdeg</string>
     <string name="encryption_settings_title">Verschlësselung</string>
     <string name="encrypted_summary">Verschlësselt</string>
     <string name="lock_settings_picker_title">Schiermspär auswielen</string>
@@ -154,7 +166,6 @@
     <string name="bluetooth_device_context_connect">Connectéieren</string>
     <string name="bluetooth_device_context_disconnect">Deconnectéieren</string>
     <string name="bluetooth_device_context_pair_connect">Koppelen a connectéieren</string>
-    <string name="bluetooth_empty_list_bluetooth_off">Wa Bluetooth un ass, kann däin Apparat mat Bluetooth-Apparater an der Géigend kommunikéieren.</string>
     <string name="nfc_reboot_dialog_confirm">Nei starten</string>
     <string name="wifi_display_enable_menu_item">Kabellose Schierm aktivéieren</string>
     <string name="wifi_display_no_devices_found">Keng Apparater an der Géigend fonnt.</string>
@@ -209,7 +220,6 @@
     <string name="wifi_connecting">Connectioun gëtt hiergestallt\u2026</string>
     <string name="wifi_failed_connect_message">Connectioun mam Netzwierk feelgeschloen</string>
     <string name="wifi_forget">Vergiessen</string>
-    <string name="wifi_failed_forget_message">Konnt d\'Netzwierk net vergiessen</string>
     <string name="wifi_save">Späicheren</string>
     <string name="wifi_failed_save_message">Konnt d\'Netzwierk net späicheren</string>
     <string name="wifi_cancel">Ofbriechen</string>
@@ -364,21 +374,15 @@
     <string name="tether_settings_title_usb_bluetooth">Tethering</string>
     <string name="tether_settings_summary_hotspot_off_tether_on">Tethering</string>
     <string name="tether_preference_summary_off">Aus</string>
-    <string name="tethering_interface_options">Tethering</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">USB-Tethering</string>
     <string name="bluetooth_tether_checkbox_text">Bluetooth-Tethering</string>
     <string name="tethering_help_button_text">Hëllef</string>
-    <string name="manage_mobile_plan_title" translatable="true">Mobillen Tariff</string>
     <string name="sms_change_default_dialog_title" translatable="true">SMS-App änneren?</string>
     <string name="sms_change_default_dialog_text" translatable="true"><xliff:g id="new_app">%1$s</xliff:g> amplaz vu(n) <xliff:g id="current_app">%2$s</xliff:g> als deng SMS-App benotzen?</string>
     <string name="sms_change_default_no_previous_dialog_text" translatable="true"><xliff:g id="new_app">%s</xliff:g> als deng SMS-App benotzen?</string>
     <string name="network_scorer_change_active_dialog_title">WLAN-Assistent änneren?</string>
     <string name="network_scorer_change_active_dialog_text"><xliff:g id="new_app">%1$s</xliff:g> duerch <xliff:g id="current_app">%2$s</xliff:g> ersetze fir d\'Netzwierkconnectiounen ze geréieren?</string>
     <string name="network_scorer_change_active_no_previous_dialog_text"><xliff:g id="new_app">%s</xliff:g> benotze fir d\'Netzwierkconnectiounen ze geréieren?</string>
-    <string name="mobile_unknown_sim_operator" translatable="true">Onbekannte SIM-Provider</string>
-    <string name="mobile_insert_sim_card" translatable="true">Setz w.e.g. eng SIM-Kaart an a start nei</string>
-    <string name="mobile_connect_to_internet" translatable="true">Verbann dech w.e.g. mam Internet</string>
     <string name="location_category_recent_location_requests">Rezent Standuertufroen</string>
     <string name="managed_profile_location_switch_title">Standuert fir Aarbechtsprofil</string>
     <string name="location_no_recent_apps">Kierzlech hu keng Appen Zougrëff op de Standuert ugefrot</string>
@@ -642,9 +646,6 @@
     <string name="capabilities_list_title"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> wëll:</string>
     <string name="accessibility_dialog_button_allow">Erlaben</string>
     <string name="accessibility_dialog_button_deny">Verweigeren</string>
-    <string name="accessibility_dialog_button_stop">Stopp</string>
-    <string name="accessibility_dialog_button_cancel">Ofbriechen</string>
-    <string name="disable_service_title"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> stoppen?</string>
     <string name="accessibility_no_services_installed">Keng Servicer installéiert</string>
     <string name="accessibility_service_default_description">Keng Beschreiwung aginn.</string>
     <string name="settings_button">Astellungen</string>
@@ -751,8 +752,6 @@
     <string name="request_manage_credentials_allow">Erlaben</string>
     <string name="no_certificate_management_app">Ouni</string>
     <string name="emergency_tone_summary">Definéier d\'Behuele wann en Noutruff ofgesat gëtt</string>
-    <string name="backup_summary_state_on">Un</string>
-    <string name="backup_summary_state_off">Aus</string>
     <string name="backup_section_title">Sécheren an erëmhierstellen</string>
     <string name="personal_data_section_title">Perséinlech Daten</string>
     <string name="backup_data_title">Meng Date sécheren</string>
@@ -843,17 +842,12 @@
     <string name="vpn_name">Numm</string>
     <string name="vpn_type">Typ</string>
     <string name="vpn_server">Serveradress</string>
-    <string name="vpn_mppe">PPP-Verschlësselung (MPPE)</string>
-    <string name="vpn_l2tp_secret">L2TP-Geheimnis</string>
     <string name="vpn_ipsec_identifier">IPSec-ID</string>
     <string name="vpn_ipsec_secret">Virinstalléierten IPSec-Schlëssel</string>
     <string name="vpn_ipsec_user_cert">IPSec-Benotzerzertifikat</string>
     <string name="vpn_ipsec_ca_cert">IPSec-CA-Zertifikat</string>
     <string name="vpn_ipsec_server_cert">IPSec-Serverzertifikat</string>
     <string name="vpn_show_options">Erweidert Optiounen uweisen</string>
-    <string name="vpn_search_domains">DNS-Sichdomains</string>
-    <string name="vpn_dns_servers">DNS-Serveren (z. B. 8.8.8.8)</string>
-    <string name="vpn_routes">Weiderleedungs-Routen (z. B. 10.0.0.0/8)</string>
     <string name="vpn_username">Benotzernumm</string>
     <string name="vpn_password">Passwuert</string>
     <string name="vpn_save_login">Konteninformatioun späicheren</string>
@@ -936,10 +930,6 @@
     <string name="amber_alerts_title">AMBER-Warnungen</string>
     <string name="amber_alerts_summary">Berichter iwwer Entféierunge vu Kanner emfänken</string>
     <string name="repeat_title">Widderhuelen</string>
-    <string name="call_manager_enable_title">Uruffverwalter aktivéieren</string>
-    <string name="call_manager_enable_summary">Dësem Service erlaaben, ze geréiere wéi d\'Uriff gemaach ginn.</string>
-    <string name="call_manager_title">Uruffverwalter</string>
-    <string name="call_manager_summary"><xliff:g id="app">%1$s</xliff:g></string>
     <string name="network_operators_settings">Netzwierkprovideren</string>
     <string name="access_point_names">Nimm vun den Zougrëffspunkten</string>
     <string name="preferred_network_type_title">Preferéierten Netzwierktyp</string>
@@ -1167,4 +1157,17 @@
     <string name="color_selector_dialog_done">Fäerdeg</string>
     <string name="color_selector_dialog_cancel">Ofbriechen</string>
     <string name="contrast_medium">Mëttel</string>
+    <string name="generic_accessibility_service_on">Un</string>
+    <string name="generic_accessibility_service_off">Aus</string>
+    <string name="generic_accessibility_feature_shortcut_off">Aus</string>
+    <string name="accessibility_shortcut_state_off">Aus</string>
+    <string name="daltonizer_state_on">Un</string>
+    <string name="daltonizer_state_off">Aus</string>
+    <string name="color_inversion_state_on">Un</string>
+    <string name="color_inversion_state_off">Aus</string>
+    <string name="autoclick_disabled">Aus</string>
+    <string name="show_captions_disabled">Aus</string>
+    <string name="show_captions_enabled">Un</string>
+    <string name="live_caption_disabled">Aus</string>
+    <string name="live_caption_enabled">Un</string>
 </resources>
diff --git a/overlay/packages/apps/Settings/res/values-sc-rIT/strings.xml b/overlay/packages/apps/Settings/res/values-sc-rIT/strings.xml
index cb96b8c..a877460 100644
--- a/overlay/packages/apps/Settings/res/values-sc-rIT/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-sc-rIT/strings.xml
@@ -89,6 +89,9 @@
     <string name="security_settings_fingerprint_enroll_introduction_cancel">Annulla</string>
     <string name="setup_fingerprint_enroll_skip_title">Boles brincare s\'imprenta digitale?</string>
     <string name="setup_fingerprint_enroll_skip_after_adding_lock_text">Pro sa configuratzione de s\'imprenta de pòddighes nce bolet isceti unu minutu o duos. Si dda brincas, podes agiùnghere s\'imprenta tua prus a tardu in sa cunfiguratzione.</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">Sighi</string>
+    <string name="security_settings_remoteauth_enroll_introduction_more">Àteru</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Annulla</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">AB</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">AB</string>
     <string name="skip_anyway_button_label">Brinca su matessi</string>
@@ -102,6 +105,9 @@
     <string name="security_settings_fingerprint_enroll_touch_dialog_title">Oops, cussu no est su sensore</string>
     <string name="security_header">Seguresa</string>
     <string name="work_profile_category_header">Profilu de traballu</string>
+    <string name="private_space_category_system">Sistema</string>
+    <string name="no_device_lock_cancel">Annulla</string>
+    <string name="private_space_cancel_label">Annulla</string>
     <string name="fingerprint_intro_error_max">As agiuntu su nùmeru màssimu de imprentas</string>
     <string name="fingerprint_intro_error_unknown">Non podes agiùnghere àteras imprentas</string>
     <string name="lock_settings_picker_title">Sèbera blocu de ischermu</string>
@@ -133,7 +139,6 @@
     <string name="bluetooth_device_context_connect">Connete</string>
     <string name="bluetooth_device_context_disconnect">Disconnete</string>
     <string name="bluetooth_device_context_pair_connect">Assòtzia e connete</string>
-    <string name="bluetooth_empty_list_bluetooth_off">Cando su Bluetooth est ativu, su dispositivu tuo at a pòdere comunicare cun àteros dispositivos Bluetooth acanta.</string>
     <string name="wifi_display_settings_title">Trasmissione</string>
     <string name="wifi_display_enable_menu_item">Ativa s\'ischermu chene filos</string>
     <string name="wifi_display_no_devices_found">Perunu dispositivu acanta agatadu.</string>
@@ -177,7 +182,6 @@
     <string name="wifi_scan_always_confirm_deny">Nega</string>
     <string name="no_internet_access_remember">Non mi ddu torres a pregontare pro custa rete</string>
     <string name="wifi_forget">Iscaresse·ti</string>
-    <string name="wifi_failed_forget_message">No at fatu a iscarèssere sa rete</string>
     <string name="wifi_save">Sarva</string>
     <string name="wifi_failed_save_message">No at fatu a sarvare sa rete</string>
     <string name="wifi_cancel">Annulla</string>
@@ -290,15 +294,12 @@
     <string name="tether_settings_title_all">Puntu de atzessu Wi-Fi &amp; àncora</string>
     <string name="tether_settings_summary_hotspot_on_tether_on">Puntu de atzessu Wi-Fi ativu e àncora</string>
     <string name="tether_settings_summary_hotspot_off_tether_on">Ancoràgiu web</string>
-    <string name="tethering_interface_options">Ancoràgiu web</string>
-    <string name="usb_title">USB</string>
     <string name="usb_tethering_button_text">Ancoràgiu web USB</string>
     <string name="bluetooth_tether_checkbox_text">Ancoràgiu web Bluetooth</string>
     <string name="ethernet_tether_checkbox_text">Ancoràgiu web de s\'ethernet</string>
     <string name="tethering_footer_info">Imprea su puntu de atzessu Wi-Fi e s\'ancoràgiu web pro frunire ìnternet a àteros dispositivos tràmite sa connessione de datos. Is aplicatziones podent creare puru unu puntu de atzessu Wi-Fi pro cumpartzire cuntenutos cun dispositivos a curtzu.</string>
     <string name="tethering_footer_info_sta_ap_concurrency">Imprea su puntu de atzessu Wi-Fi e s\'ancoràgiu web pro frunire ìnternet a àteros dispositivos tràmite Wi\u2011Fi o sa connessione de datos. Is aplicatziones podent creare puru unu puntu de atzessu Wi-Fi pro cumpartzire cuntenutos cun dispositivos a curtzu.</string>
     <string name="tethering_help_button_text">Agiudu</string>
-    <string name="manage_mobile_plan_title" translatable="true">Pranu mòbile</string>
     <string name="sms_application_title" translatable="true">Aplicatzione de SMS</string>
     <string name="sms_change_default_dialog_text" translatable="true">Boles impreare <xliff:g id="new_app">%1$s</xliff:g> imbetzes de <xliff:g id="current_app">%2$s</xliff:g> comente aplicatzione de SMS?</string>
     <string name="sms_change_default_no_previous_dialog_text" translatable="true">Boles impreare <xliff:g id="new_app">%s</xliff:g> comente aplicatzione de SMS?</string>
@@ -357,7 +358,6 @@
     <string name="accessibility_hearingaid_instruction_continue_button">Sighi</string>
     <string name="accessibility_dialog_button_allow">Permite</string>
     <string name="accessibility_dialog_button_deny">Nega</string>
-    <string name="accessibility_dialog_button_cancel">Annulla</string>
     <string name="background_activity_disabled_dialog_text">Dae chi custa aplicatzione no est impostada pro fàghere rèndere a su màssimu sa bateria, dda podes limitare.\n\nPro limitare s\'aplicatzione, in antis ativa su rendimentu màssimu de sa bateria.</string>
     <string name="battery_tip_unrestrict_app_dialog_cancel">Annulla</string>
     <string name="smart_battery_footer">Cando su gestore de bateria rilevat chi is aplicatziones si sunt iscarrighende sa bateria, as a tènnere sa possibilidade de limitare custas aplicatziones. Is aplicatziones cun limitatziones diant pòdere non funtzionare in manera curreta e is notìficas diant pòdere subire ritardos.</string>
diff --git a/overlay/packages/apps/Settings/res/values-ug/strings.xml b/overlay/packages/apps/Settings/res/values-ug/strings.xml
index f4f9bc8..d065213 100644
--- a/overlay/packages/apps/Settings/res/values-ug/strings.xml
+++ b/overlay/packages/apps/Settings/res/values-ug/strings.xml
@@ -94,6 +94,11 @@
     <string name="security_settings_face_enroll_dialog_ok">جەزملە</string>
     <string name="security_settings_face_enroll_done">تامام</string>
     <string name="security_settings_fingerprint_enroll_introduction_cancel">ۋاز كەچ</string>
+    <string name="security_settings_remoteauth_enroll_introduction_disagree">ھازىرچە ياق</string>
+    <string name="security_settings_remoteauth_enroll_introduction_agree">داۋاملاشتۇر</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_disagree">ۋاز كەچ</string>
+    <string name="security_settings_remoteauth_enroll_enrolling_agree">جەزملە</string>
+    <string name="security_settings_remoteauth_enroll_finish_btn_next">تامام</string>
     <string name="biometric_settings_hand_back_to_guardian_ok">جەزملە</string>
     <string name="biometric_settings_add_biometrics_in_split_mode_ok">جەزملە</string>
     <string name="skip_anyway_button_label">ئاتلاۋەر</string>
@@ -104,6 +109,11 @@
     <string name="security_settings_fingerprint_enroll_done">تامام</string>
     <string name="fingerprint_enroll_button_next">كېيىنكى</string>
     <string name="security_header">بىخەتەرلىك</string>
+    <string name="privatespace_hide_off_summary">تاقاق</string>
+    <string name="privatespace_hide_on_summary">ئوچۇق</string>
+    <string name="no_device_lock_cancel">ۋاز كەچ</string>
+    <string name="private_space_cancel_label">ۋاز كەچ</string>
+    <string name="private_space_done_label">تامام</string>
     <string name="encryption_settings_title">شىفىرلاش</string>
     <string name="encrypted_summary">شىفىرلانغان</string>
     <string name="lock_settings_picker_title">ئېكران قۇلۇپىنى تاللاڭ</string>
@@ -132,7 +142,6 @@
     <string name="bluetooth_device_context_connect">باغلان</string>
     <string name="bluetooth_device_context_disconnect">ئۈز</string>
     <string name="bluetooth_device_context_pair_connect">جۈپلەپ باغلا</string>
-    <string name="bluetooth_empty_list_bluetooth_off">كۆكچىش ئېچىلسا، ئۈسكۈنىڭىز يېقىن ئەتراپتىكى باشقا كۆكچىش ئۈسكۈنىلىرى بىلەن ئالاقە قىلالايدۇ.</string>
     <string name="nfc_reboot_dialog_confirm">قايتا قوزغات</string>
     <string name="wifi_display_enable_menu_item">سىمسىز ئېكراننى قوزغات</string>
     <string name="wifi_display_no_devices_found">ئەتراپتا سىمسىز كۆرسىتىش ئۈسكۈنىسى تېپىلمىدى.\"</string>
@@ -183,7 +192,6 @@
     <string name="wifi_connecting">باغلىنىۋاتىدۇ…</string>
     <string name="wifi_failed_connect_message">تورغا باغلىنالمىدى</string>
     <string name="wifi_forget">ئەستە تۇتما</string>
-    <string name="wifi_failed_forget_message">تورنى ئۇنتالمىدى</string>
     <string name="wifi_save">ساقلا</string>
     <string name="wifi_failed_save_message">تورنى ساقلىيالمىدى</string>
     <string name="wifi_cancel">ۋاز كەچ</string>
@@ -324,16 +332,12 @@
     <string name="tether_settings_title_usb_bluetooth">ھەمبەھىر</string>
     <string name="tether_settings_summary_hotspot_off_tether_on">ھەمبەھىر</string>
     <string name="tether_preference_summary_off">تاقاق</string>
-    <string name="tethering_interface_options">ھەمبەھىر</string>
     <string name="usb_tethering_button_text">USB ھەمبەھىر</string>
     <string name="bluetooth_tether_checkbox_text">كۆكچىش ھەمبەھىر</string>
     <string name="tethering_help_button_text">ياردەم</string>
-    <string name="manage_mobile_plan_title" translatable="true">كۆچمە تور پىلانى</string>
     <string name="sms_change_default_dialog_title" translatable="true">كۆڭۈلدىكى قىسقا ئۇچۇر ئەپىنى ئۆزگەرتەمدۇ؟</string>
     <string name="sms_change_default_dialog_text" translatable="true"><xliff:g id="new_app">%1$s</xliff:g> نى <xliff:g id="current_app">%2$s</xliff:g> نىڭ ئورنىغا قىسقا ئۇچۇر ئەپى قىلىپ ئىشلىتەمسىز؟?</string>
     <string name="sms_change_default_no_previous_dialog_text" translatable="true"><xliff:g id="NEW_APP">%s</xliff:g> نى قىسقا ئۇچۇر ئەپى قىلىپ ئىشلىتەمسىز؟</string>
-    <string name="mobile_insert_sim_card" translatable="true">SIM كارتا قىستۇرۇپ قايتا قوزغىتىڭ</string>
-    <string name="mobile_connect_to_internet" translatable="true">ئىنتېرنېتقا باغلاڭ</string>
     <string name="location_category_recent_location_requests">يېقىنقى ئورۇن ئۇچۇر ئىلتىماسى</string>
     <string name="location_no_recent_apps">يېقىندا ھېچقانداق ئەپ ئورۇن ئۇچۇرىنى ئىلتىماس قىلمىدى</string>
     <string name="location_high_battery_use">توك سەرپىياتى يۇقىرى</string>
@@ -568,9 +572,6 @@
     <string name="capabilities_list_title"><xliff:g id="SERVICE">%1$s</xliff:g> ئېھتىياجى:</string>
     <string name="accessibility_dialog_button_allow">يول قوي</string>
     <string name="accessibility_dialog_button_deny">رەت قىل</string>
-    <string name="accessibility_dialog_button_stop">توختا</string>
-    <string name="accessibility_dialog_button_cancel">ۋاز كەچ</string>
-    <string name="disable_service_title"><xliff:g id="SERVICE">%1$s</xliff:g> نى توختىتامدۇ؟</string>
     <string name="accessibility_no_services_installed">ھېچقانداق مۇلازىمەت ئورنىتىلمىغان</string>
     <string name="accessibility_service_default_description">چۈشەندۈرۈش تەمىنلەنمىگەن.</string>
     <string name="settings_button">تەڭشەكلەر</string>
@@ -656,8 +657,6 @@
     <string name="request_manage_credentials_allow">يول قوي</string>
     <string name="no_certificate_management_app">يوق</string>
     <string name="emergency_tone_summary">جىددىي چاقىرغاندىكى ھەرىكەت تەڭشىكى</string>
-    <string name="backup_summary_state_on">ئوچۇق</string>
-    <string name="backup_summary_state_off">تاقاق</string>
     <string name="backup_section_title">زاپاسلا ۋە ئەسلىگە كەلتۈر</string>
     <string name="personal_data_section_title">شەخسىي سانلىق مەلۇمات</string>
     <string name="backup_data_title">سانلىق مەلۇماتلىرىمنى زاپاسلا</string>
@@ -737,17 +736,12 @@
     <string name="vpn_name">ئاتى</string>
     <string name="vpn_type">تۈرى</string>
     <string name="vpn_server">مۇلازىمېتىر ئادرىسى</string>
-    <string name="vpn_mppe">PPP شىفىرلاش (MPPE)</string>
-    <string name="vpn_l2tp_secret">L2TP شىفىرلىق ئاچقۇچ</string>
     <string name="vpn_ipsec_identifier">IPSec بەلگىسى</string>
     <string name="vpn_ipsec_secret">IPSec ئالدىن ھەمبەھىر شىفىرلىق ئاچقۇچى</string>
     <string name="vpn_ipsec_user_cert">IPSec ئىشلەتكۈچى گۇۋاھنامىسى</string>
     <string name="vpn_ipsec_ca_cert">IPSec CA گۇۋاھنامىسى</string>
     <string name="vpn_ipsec_server_cert">IPSec مۇلازىمىتىر گۇۋاھنامىسى</string>
     <string name="vpn_show_options">ئالىي تاللانما كۆرسەت</string>
-    <string name="vpn_search_domains">DNS ئىزدەش دائىرىسى</string>
-    <string name="vpn_dns_servers">DNS مۇلازىمېتىر (مەسىلەن 8.8.8.8)</string>
-    <string name="vpn_routes">ئۇلاپ يېتەكلىگۈچ (مەسىلەن 10.0.0.0/8)</string>
     <string name="vpn_username">ئىشلەتكۈچى ئاتى</string>
     <string name="vpn_password">ئىم</string>
     <string name="vpn_save_login">ھېسابات ئۇچۇرىنى ساقلا</string>
@@ -953,4 +947,17 @@
     <string name="color_selector_dialog_done">تامام</string>
     <string name="color_selector_dialog_cancel">ۋاز كەچ</string>
     <string name="contrast_medium">ئوتتۇرا</string>
+    <string name="generic_accessibility_service_on">ئوچۇق</string>
+    <string name="generic_accessibility_service_off">تاقاق</string>
+    <string name="generic_accessibility_feature_shortcut_off">تاقاق</string>
+    <string name="accessibility_shortcut_state_off">تاقاق</string>
+    <string name="daltonizer_state_on">ئوچۇق</string>
+    <string name="daltonizer_state_off">تاقاق</string>
+    <string name="color_inversion_state_on">ئوچۇق</string>
+    <string name="color_inversion_state_off">تاقاق</string>
+    <string name="autoclick_disabled">تاقاق</string>
+    <string name="show_captions_disabled">تاقاق</string>
+    <string name="show_captions_enabled">ئوچۇق</string>
+    <string name="live_caption_disabled">تاقاق</string>
+    <string name="live_caption_enabled">ئوچۇق</string>
 </resources>
diff --git a/overlay/packages/apps/Stk/res/values-ast-rES/strings.xml b/overlay/packages/apps/Stk/res/values-ast-rES/strings.xml
deleted file mode 100644
index dbc472c..0000000
--- a/overlay/packages/apps/Stk/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2007 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="app_name">Ferramientes de la SIM</string>
-    <string name="menu_end_session">Finar la sesión</string>
-    <string name="help">Ayuda</string>
-    <string name="menu_back">Atrás</string>
-    <string name="service_name">Nome del serviciu</string>
-    <string name="stk_no_service">Nun hai nengún serviciu disponible</string>
-    <string name="button_ok">D\'acuerdu</string>
-    <string name="button_cancel">Encaboxar</string>
-    <string name="button_yes">Sí</string>
-    <string name="button_no">Non</string>
-    <string name="alphabet">Caráuteres alfabéticos</string>
-    <string name="digits">Díxitos (0-9, *, #, +)</string>
-    <string name="default_call_setup_msg">Llamada en cursu\u2026</string>
-    <string name="default_setup_call_msg">La llamada ta configurándose</string>
-    <string name="stk_app_state">Estáu de l\'aplicación</string>
-    <string name="enable_app">Activóse</string>
-    <string name="disable_app">Desactivóse</string>
-    <string name="stk_dialog_title">Ferramientes de la SIM</string>
-    <string name="default_tone_dialog_msg">Tonu en reproducción</string>
-    <string name="default_open_channel_msg">¿Quies abrir la canal?</string>
-    <string name="default_send_data_msg">Unviando datos</string>
-    <string name="default_receive_data_msg">Recibiendo datos</string>
-    <string name="default_close_channel_msg">Zarróse la canal</string>
-    <string name="stk_dialog_accept">SÍ</string>
-    <string name="stk_dialog_reject">NON</string>
-    <string name="no_sim_card_inserted">Inxerta una SIM pa llanzar «Ferramientes de la SIM».</string>
-    <string name="stk_channel_name">Mensaxes del serviciu móvil</string>
-</resources>
diff --git a/overlay/packages/apps/StorageManager/res/values-ast-rES/arrays.xml b/overlay/packages/apps/StorageManager/res/values-ast-rES/arrays.xml
deleted file mode 100644
index 01331a7..0000000
--- a/overlay/packages/apps/StorageManager/res/values-ast-rES/arrays.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string-array name="automatic_storage_management_days">
-        <item>Más de 30 díes d\'antigüedá</item>
-        <item>Más de 60 díes d\'antigüedá</item>
-        <item>Más de 90 díes d\'antigüedá</item>
-    </string-array>
-</resources>
diff --git a/overlay/packages/apps/StorageManager/res/values-ast-rES/strings.xml b/overlay/packages/apps/StorageManager/res/values-ast-rES/strings.xml
deleted file mode 100644
index 96a8837..0000000
--- a/overlay/packages/apps/StorageManager/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_name">Xestor del almacenamientu</string>
-    <string name="cancel">Encaboxar</string>
-    <string name="storage_menu_free">Lliberar espaciu</string>
-    <string name="deletion_helper_title">Desaniciu d\'elementos</string>
-    <string name="deletion_helper_app_summary">Hai <xliff:g id="days" example="67">%1$d</xliff:g> díes</string>
-    <string name="deletion_helper_app_summary_item_size"><xliff:g id="used" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_app_summary_never_used">Nun s\'usó nel últimu añu</string>
-    <string name="deletion_helper_app_summary_unknown_used">Desconozse cuándo s\'usó per última vegada</string>
-    <string name="deletion_helper_free_button">Lliberar <xliff:g id="freeable" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_photos_title">Copies de seguranza de semeyes y vídeos</string>
-    <string name="deletion_helper_photos_age_summary">Más de 30 díes d\'antigüedá</string>
-    <string name="deletion_helper_photos_summary"><xliff:g id="used" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_downloads_title">Descargues</string>
-    <string name="deletion_helper_downloads_category_summary"><xliff:g id="used" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_downloads_summary_empty"><xliff:g id="used" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_clear_dialog_title">Lliberación d\'espaciu</string>
-    <string name="deletion_helper_clear_dialog_message">Tamañu del conteníu que se va desaniciar del preséu: <xliff:g id="clearable_bytes" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_clear_dialog_remove">Lliberar espaciu</string>
-    <string name="deletion_helper_upsell_title">¿Quies xestionar automáticamente l\'almacenamientu?</string>
-    <string name="deletion_helper_upsell_summary">Espaciu d\'almacenamientu llibre: <xliff:g id="used" example="1.2GB">%1$s</xliff:g>. ¿Quies dexar que\'l xestor del almacenamientu llibere espaciu automáticamente col desaniciu del conteníu con copia de seguranza del preséu?</string>
-    <string name="deletion_helper_upsell_cancel">Non, gracies</string>
-    <string name="deletion_helper_upsell_activate">Activar</string>
-    <string name="deletion_helper_apps_group_title">Aplicaciones que s\'usen poco</string>
-    <string name="deletion_helper_apps_group_summary"><xliff:g id="used" example="1.2GB">%1$s</xliff:g></string>
-    <string name="deletion_helper_manual_title">Manual</string>
-    <string name="deletion_helper_preference_title">Lliberar espaciu agora</string>
-    <string name="automatic_storage_manager_service_label">Serv. xestión almacenamientu automáticu</string>
-    <string name="automatic_storage_manager_notification_title" product="default">Al teléfonu quéda-y pocu espaciu</string>
-    <string name="automatic_storage_manager_notification_title" product="tablet">A la tableta quéda-y pocu espaciu</string>
-    <string name="automatic_storage_manager_notification_summary">Dexa que\'l xestor del almacenamientu llibere espaciu col desaniciu automáticu de semeyes y vídeos cuando\'l preséu comience a enllenase de nueves.</string>
-    <string name="automatic_storage_manager_cancel_button">Non, gracies</string>
-    <string name="automatic_storage_manager_activate_button">Activar</string>
-    <string name="deletion_helper_photos_loading_title">Copies de seguranza de semeyes y vídeos</string>
-    <string name="deletion_helper_photos_loading_summary">Atopando elementos…</string>
-    <string name="deletion_helper_no_threshold">Amosar tolos elementos</string>
-    <string name="deletion_helper_default_threshold">Anubrir los ficheros de recién</string>
-    <string name="deletion_helper_clear_dialog_message_first_time">Tamañu del conteníu que va quitase del preséu: <xliff:g id="clearable_bytes" example="1.2GB">%1$s</xliff:g></string>
-    <string name="automatic_storage_manager_activation_warning">Agora l\'almacenamientu xestiónalu\'l xestor del almacenamientu</string>
-    <string name="empty_state_title">Nun hai nada pa quitar</string>
-    <string name="empty_state_review_items_link">Revisar los elementos de recién</string>
-    <string name="empty_state_summary">Nun hai nengún ficheru antiguu pa quitar. Pa lliberar espaciu, quita les semeyes, los vídeos y les aplicaciones de recién.</string>
-    <string name="app_requesting_space">«<xliff:g id="app" example="Dialer">%1$s</xliff:g>» precisa <xliff:g id="clearable_bytes" example="1.2GB">%2$s</xliff:g> d\'espaciu</string>
-</resources>
diff --git a/overlay/packages/apps/TV/res/values-ast-rES/arrays.xml b/overlay/packages/apps/TV/res/values-ast-rES/arrays.xml
index 837c221..5536b2d 100644
--- a/overlay/packages/apps/TV/res/values-ast-rES/arrays.xml
+++ b/overlay/packages/apps/TV/res/values-ast-rES/arrays.xml
@@ -15,29 +15,24 @@
   ~ limitations under the License.
   -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string-array name="display_mode_labels" translatable="true">
-        <item>Normal</item>
-        <item>Completu</item>
-        <item>Zoom</item>
-    </string-array>
     <string-array name="genre_labels" translatable="true">
-        <item>Toles canales</item>
-        <item>Familia/Reciella</item>
-        <item>Deportes</item>
-        <item>Compres</item>
-        <item>Filmes</item>
-        <item>Comedia</item>
-        <item>Viaxes</item>
+        <item>All channels</item>
+        <item>Family/Kids</item>
+        <item>Sports</item>
+        <item>Shopping</item>
+        <item>Movies</item>
+        <item>Comedy</item>
+        <item>Travel</item>
         <item>Drama</item>
-        <item>Educación</item>
-        <item>Natura</item>
-        <item>Noticies</item>
-        <item>Xuegos</item>
-        <item>Arte</item>
-        <item>Entretenimientu</item>
-        <item>Estilu de vida</item>
-        <item>Música</item>
-        <item>Premier</item>
-        <item>Teunoloxía/Ciencia</item>
+        <item>Education</item>
+        <item>Animal/Wildlife</item>
+        <item>News</item>
+        <item>Gaming</item>
+        <item>Arts</item>
+        <item>Entertainment</item>
+        <item>Lifestyle</item>
+        <item>Music</item>
+        <item>D\'estrena</item>
+        <item>Tech/Science</item>
     </string-array>
 </resources>
diff --git a/overlay/packages/apps/TV/res/values-ast-rES/strings.xml b/overlay/packages/apps/TV/res/values-ast-rES/strings.xml
deleted file mode 100644
index 4f926f8..0000000
--- a/overlay/packages/apps/TV/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2015 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License.
-  -->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="menu_title_channels">Canales</string>
-    <string name="menu_title_options">Opciones de la TV</string>
-    <string name="play_controls_description_fast_forward">Avance rápidu</string>
-    <string name="play_controls_description_skip_next">Siguiente</string>
-    <string name="play_controls_description_skip_previous">Anterior</string>
-    <string name="options_item_settings">Axustes</string>
-    <string name="msg_no_setup_activity">La entrada nun ye compatible cola busca automática</string>
-    <string name="option_country_rating_systems">Sistemes de valoración</string>
-    <string name="other_countries">Otros países</string>
-    <string name="side_panel_title_settings">Axustes</string>
-    <string name="settings_menu_version">Versión</string>
-    <string name="new_sources_action_skip">D\'acuerdu</string>
-    <string name="intro_title">@string/app_name</string>
-    <string name="msg_no_specific_input">Nun se pue atopar la entrada de TV</string>
-    <string name="msg_missing_app">Nun s\'atopó nenguna aplicación pa remanar esta aición.</string>
-    <string name="recording_start_dialog_10_min_duration">10 minutos</string>
-    <string name="recording_start_dialog_30_min_duration">30 minutos</string>
-    <string name="recording_start_dialog_1_hour_duration">1 hora</string>
-    <string name="recording_start_dialog_3_hours_duration">3 hores</string>
-    <plurals name="dvr_program_duration">
-        <item quantity="one">%1$d minutu</item>
-        <item quantity="other">%1$d minutos</item>
-    </plurals>
-    <string name="dvr_detail_delete">Desaniciar</string>
-    <string name="dvr_detail_series_resume">Siguir</string>
-    <string name="dvr_detail_read_more">Lleer más</string>
-    <string name="dvr_series_settings_channels">Canales</string>
-    <string name="dvr_priority_button_action_save">Guardar</string>
-    <string name="dvr_toast_recording_deleted">Nun s\'atopó la grabación</string>
-    <string name="dvr_stop_recording_dialog_title">¿Quies dexar de grabar?</string>
-    <string name="dvr_schedule_dialog_title">¿Qué quies grabar?</string>
-    <string name="dvr_channel_record_duration_dialog_title">¿Cuántu tiempu quies grabar?</string>
-    <plurals name="dvr_schedules_section_subtitle">
-        <item quantity="one">%1$d grabación</item>
-        <item quantity="other">%1$d grabaciones</item>
-    </plurals>
-    <string name="dvr_schedules_information_separator"> / </string>
-    <string name="dvr_recording_failed_not_started_short">Hebo un fallu al aniciar la grabación.</string>
-    <string name="dvr_recording_failed_resource_busy_short">Hebo un fallu al sintonizar la canal.</string>
-    <string name="dvr_recording_failed_input_unavailable_short"><xliff:g id="inputId" example="com.example.partnersupportsampletvinput/.SampleTvInputService">%1$s</xliff:g> nun ta disponible.</string>
-    <string name="dvr_recording_failed_input_dvr_unsupported_short">La grabación nun ye compatible.</string>
-    <string name="dvr_date_today">Güei</string>
-    <string name="dvr_date_tomorrow">Mañana</string>
-    <string name="dvr_date_yesterday">Ayeri</string>
-    <string name="program_guide_critic_score">Puntuación</string>
-    <string name="recorded_programs_preview_channel">Programes grabaos</string>
-</resources>
diff --git a/overlay/packages/apps/TV/res/values-fur-rIT/strings.xml b/overlay/packages/apps/TV/res/values-fur-rIT/strings.xml
index 9c103cc..6069bf7 100644
--- a/overlay/packages/apps/TV/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/TV/res/values-fur-rIT/strings.xml
@@ -390,6 +390,8 @@
         Selezionant \"Permet\", al consint a <xliff:g id="app_name">Live TV</xliff:g> di
         liberâ daurman spazi di archiviazion cuant che si elimine i programs TV regjistrâts.
         Chest al cree plui spazi disponibil pes gnovis regjistrazions.</string>
+    <string name="tv_app_dialog_title">E je stade cjatade une aplicazion interative. Desideristu ativâ lis aplicazions interativis?</string>
+    <string name="interactive_app_settings">Impostazions aplicazions interativis</string>
     <string name="tv_iapp_on">On</string>
     <string name="tv_iapp_off">Off</string>
 </resources>
diff --git a/overlay/packages/apps/ThemePicker/res/values-ast-rES/strings.xml b/overlay/packages/apps/ThemePicker/res/values-ast-rES/strings.xml
index 13dc7e8..fc95062 100644
--- a/overlay/packages/apps/ThemePicker/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/ThemePicker/res/values-ast-rES/strings.xml
@@ -16,19 +16,28 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="app_name">Fondu de pantalla y estilu</string>
+    <string name="select_clock_action_description">Opción d\'esfera de reló: <xliff:g name="clock_face_description">%1$s</xliff:g></string>
+    <string name="clock_size_small_description">Un reló pequeñu qu\'apaez na esquina de la pantalla</string>
     <string name="grid_title">Rexáu d\'aplicaciones</string>
-    <string name="theme_preview_card_content_description">Previsualización del estilu</string>
-    <string name="grid_preview_card_content_description">Previsualización del rexáu</string>
-    <string name="font_preview_content_description">Previsualización de la fonte</string>
-    <string name="icon_preview_content_description">Previsualización de los iconos</string>
-    <string name="color_preview_content_description">Previsualización del color</string>
-    <string name="shape_preview_content_description">Previsualización de la forma</string>
-    <string name="theme_preview_icons_section_title">Color / Iconos</string>
+    <string name="apply_grid_btn_note">Al camudar el tamañu del rexáu va volver cargase la estaya de trabayu y pue tardar unos segundos.</string>
+    <string name="toast_of_changing_grid">Volviendo cargar la estaya de trabayu col rexáu «%1$s»</string>
+    <string name="toast_of_failure_to_change_grid">Hebo un fallu al volver cargar la estaya de trabayu col rexáu «%1$s»</string>
     <string name="accessibility_custom_font_title">Fonte personalizada</string>
     <string name="accessibility_custom_icon_title">Iconu personalizáu</string>
     <string name="accessibility_custom_color_title">Color personalizáu</string>
     <string name="accessibility_custom_shape_title">Forma personalizada</string>
     <string name="accessibility_custom_name_title">Nome d\'estilu personalizáu</string>
+    <string name="accessibility_clock_slider_description">Intensidá cromática</string>
     <string name="mode_title" msgid="1000319159005403986">Estilu escuru</string>
     <string name="beta_title">Beta</string>
+    <string name="keyguard_affordance_enablement_dialog_headline">Nun se pue amestar l\'atayu</string>
+    <string name="more_settings_section_title">Más opciones de la pant. bloq.</string>
+    <string name="more_settings_section_description">Privacidá, «En reproducción» y más</string>
+    <string name="content_description_dynamic_color_option">Estilu dinámicu primariu</string>
+    <string name="content_description_neutral_color_option">Estilu neutral primariu</string>
+    <string name="content_description_vibrant_color_option">Estilu intensu primariu</string>
+    <string name="content_description_expressive_color_option">Estilu espresivu primariu</string>
+    <string name="scroll_forward_and_select">Esliza a la esquierda pa escoyer otra esfera</string>
+    <string name="scroll_backward_and_select">Esliza a la derecha pa escoyer otra esfera</string>
+    <string name="custom_clocks_label">Relós personalizaos</string>
 </resources>
diff --git a/overlay/packages/apps/ThemePicker/res/values-cy/strings.xml b/overlay/packages/apps/ThemePicker/res/values-cy/strings.xml
index 142f1e1..79c1a43 100644
--- a/overlay/packages/apps/ThemePicker/res/values-cy/strings.xml
+++ b/overlay/packages/apps/ThemePicker/res/values-cy/strings.xml
@@ -119,7 +119,6 @@
     <string name="keyguard_quick_affordance_two_selected_template"><xliff:g id="first">%1$s</xliff:g>, <xliff:g id="second">%2$s</xliff:g></string>
     <string name="keyguard_quick_affordance_none_selected">Dim</string>
     <string name="show_notifications_on_lock_screen">Dangos hysbysiadau ar y sgrin cloi</string>
-    <string name="hide_notifications_on_lock_screen">Cuddio hysbysiadau ar y sgrin cloi</string>
     <string name="more_colors">Rhagor o Liwiau</string>
     <string name="content_description_default_color_option">Dewisiad lliw rhagosodedig</string>
     <string name="content_description_color_option">Dewisiad lliw <xliff:g name="color_number" example="1">%1$d</xliff:g></string>
diff --git a/overlay/packages/apps/ThemePicker/res/values-fur-rIT/strings.xml b/overlay/packages/apps/ThemePicker/res/values-fur-rIT/strings.xml
index 4dd914e..cb04229 100644
--- a/overlay/packages/apps/ThemePicker/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/ThemePicker/res/values-fur-rIT/strings.xml
@@ -20,6 +20,7 @@
     <string name="clock_title">Orloi personalizât</string>
     <string name="clock_description">Sielç un orloi personalizât</string>
     <string name="clock_picker_entry_content_description">Cambie un orloi personalizât</string>
+    <string name="select_clock_action_description">Opzion de muse dal orloi: <xliff:g name="clock_face_description">%1$s</xliff:g></string>
     <string name="clock_settings_title">Colôr e dimension dal orloi</string>
     <string name="clock_color_and_size_title">Colôr e dimension dal orloi</string>
     <string name="clock_color_and_size_description"><xliff:g name="color">%1$s</xliff:g>, <xliff:g name="size">%2$s</xliff:g></string>
@@ -38,6 +39,7 @@
     <string name="clock_size_dynamic_description">La dimension dal orloi e cambie in base al contignût de schermade di bloc</string>
     <string name="clock_size_large">Grande</string>
     <string name="clock_size_small">Piçule</string>
+    <string name="clock_size_small_description">Un piçul orloi mostrât tal cjanton dal to schermi</string>
     <string name="grid_title">Gridele aplic.</string>
     <string name="apply_theme_btn">Apliche</string>
     <string name="edit_custom_theme_lbl">Tocje par modificâ</string>
@@ -63,6 +65,9 @@
     <string name="font_card_body">Zonte i tiei caratars preferîts a ogni schermade</string>
     <string name="grid_options_title">Sielç une dimension de gridele</string>
     <string name="grid_title_pattern"><xliff:g name="num_cols" example="1">%1$d</xliff:g>x<xliff:g name="num_rows" example="1">%2$d</xliff:g></string>
+    <string name="apply_grid_btn_note">Cambiant la dimension de gridele tu tornarâs a cjariâ il spazi di lavôr, chest al puartarà vie cualchi secont.</string>
+    <string name="toast_of_changing_grid">Daûr a tornâ a cjariâ il spazi di lavôr cu la gridele %1$s</string>
+    <string name="toast_of_failure_to_change_grid">Impussibil tornâ a cjariâ il spazi di lavôr cu la gridele %1$s</string>
     <string name="applied_theme_msg">Stîl stabilît cun sucès</string>
     <string name="applied_clock_msg">Ore configurade cun sucès</string>
     <string name="applied_grid_msg">Gridele stabilide cun sucès</string>
@@ -114,6 +119,7 @@
     <string name="keyguard_slot_name_bottom_start">Scurte di çampe</string>
     <string name="keyguard_slot_name_bottom_end">Scurte di diestre</string>
     <string name="keyguard_affordance_none">Nissun</string>
+    <string name="keyguard_affordance_enablement_dialog_headline">Impussibil zontâ la scurte</string>
     <string name="keyguard_affordance_enablement_dialog_action_template">Vierç <xliff:g id="appName" example="Wallet">%1$s</xliff:g></string>
     <string name="keyguard_affordance_enablement_dialog_message">Par zontâ come scurte la aplicazion <xliff:g id="appName" example="Wallet">%1$s</xliff:g>, controle che:</string>
     <string name="keyguard_affordance_enablement_dialog_dismiss_button">Fat</string>
@@ -122,8 +128,16 @@
     <string name="keyguard_quick_affordance_two_selected_template"><xliff:g id="first">%1$s</xliff:g>, <xliff:g id="second">%2$s</xliff:g></string>
     <string name="keyguard_quick_affordance_none_selected">Nissun element</string>
     <string name="show_notifications_on_lock_screen">Mostre lis notifichis su la schermade di bloc</string>
-    <string name="hide_notifications_on_lock_screen">Plate lis notifichis su la schermade di bloc</string>
+    <string name="more_settings_section_title">Altris opzions</string>
+    <string name="more_settings_section_description">Riservatece, Cumò in riproduzion e altri</string>
     <string name="more_colors">Altris colôrs</string>
+    <string name="content_description_dynamic_color_option">Teme dinamic primari</string>
+    <string name="content_description_neutral_color_option">Teme neutrâl primari</string>
+    <string name="content_description_vibrant_color_option">Teme vivarôs primari</string>
+    <string name="content_description_expressive_color_option">Teme espressîf primari</string>
     <string name="content_description_default_color_option">Opzion predefinide pal colôr</string>
     <string name="content_description_color_option">Opzion colôr <xliff:g name="color_number" example="1">%1$d</xliff:g></string>
+    <string name="scroll_forward_and_select">Scor a çampe par sielzi une muse dal orloi divierse</string>
+    <string name="scroll_backward_and_select">Scor a diestre par sielzi une muse dal orloi divierse</string>
+    <string name="custom_clocks_label">Orlois personalizâts</string>
 </resources>
diff --git a/overlay/packages/apps/Trebuchet/res/values-ast-rES/strings.xml b/overlay/packages/apps/Trebuchet/res/values-ast-rES/strings.xml
index fac9864..e58ebd2 100644
--- a/overlay/packages/apps/Trebuchet/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/Trebuchet/res/values-ast-rES/strings.xml
@@ -30,19 +30,15 @@
     <string name="widget_category_conversations">Conversaciones</string>
     <string name="widget_education_header">Información útil al algame</string>
     <string name="reconfigurable_widget_education_tip">Toca pa camudar los axustes del widget</string>
-    <string name="widget_education_close_button">Entendílo</string>
     <string name="all_apps_label">Toles aplicaciones</string>
-    <string name="notifications_header">Avisos</string>
     <string name="all_apps_search_results">Resultaos de la busca</string>
     <string name="gadget_error_text">Nun se pue cargar el widget</string>
-    <string name="folder_name_format_exact">Carpeta: <xliff:g id="name" example="Games">%1$s</xliff:g>, <xliff:g id="size" example="2">%2$d</xliff:g> elementos</string>
-    <string name="folder_name_format_overflow">Carpeta: <xliff:g id="name" example="Games">%1$s</xliff:g>, <xliff:g id="size" example="2">%2$d</xliff:g> ó más elementos</string>
     <string name="styles_wallpaper_button_text">Fondu de pantalla y estilu</string>
     <string name="app_installing_title">Instalando «<xliff:g id="name" example="Messenger">%1$s</xliff:g>», completóse\'l <xliff:g id="progress" example="30%">%2$s</xliff:g></string>
     <string name="work_profile_edu_work_apps">Les aplicaciones llaborables tienen una insignia y l\'alministrador de TI pue veles</string>
-    <string name="work_profile_edu_accept">Entendílo</string>
-    <string name="work_apps_paused_title">Les aplicaciones llaborales tan en posa</string>
+    <string name="work_apps_paused_title">Les aplicaciones llaborales tán en posa</string>
     <string name="work_apps_paused_body">Les aplicaciones llaborales nun puen unviate avisos, consumir la batería nin acceder a la llocalización</string>
     <string name="work_apps_paused_edu_banner">Les aplicaciones llaborales tienen una insignia y l\'alministrador de TI pue veles</string>
-    <string name="work_apps_paused_edu_accept">Entendílo</string>
+    <string name="private_space_label">Espaciu priváu</string>
+    <string name="ps_container_settings">Configuración del espaciu priváu</string>
 </resources>
diff --git a/overlay/packages/apps/Trebuchet/res/values-cy/strings.xml b/overlay/packages/apps/Trebuchet/res/values-cy/strings.xml
index 7914114..d68226a 100644
--- a/overlay/packages/apps/Trebuchet/res/values-cy/strings.xml
+++ b/overlay/packages/apps/Trebuchet/res/values-cy/strings.xml
@@ -169,7 +169,5 @@
     <string name="work_apps_paused_edu_accept">Deall yn iawn</string>
     <string name="work_apps_pause_btn_text">Rhoi apiau gwaith ar saib</string>
     <string name="developer_options_filter_hint">Hidlydd</string>
-    <string name="search_pref_screen_title">Chwilio dy ffôn</string>
-    <string name="search_pref_screen_title_tablet">Chwilio dy lechen</string>
     <string name="remote_action_failed">Methiant: <xliff:g id="what" example="Pause">%1$s</xliff:g></string>
 </resources>
diff --git a/overlay/packages/apps/Trebuchet/res/values-fur-rIT/strings.xml b/overlay/packages/apps/Trebuchet/res/values-fur-rIT/strings.xml
index 8d1ae7d..7e2e2be 100644
--- a/overlay/packages/apps/Trebuchet/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/Trebuchet/res/values-fur-rIT/strings.xml
@@ -27,6 +27,7 @@
     <string name="home_screen">Inizi</string>
     <string name="recent_task_option_split_screen">Schermi dividût</string>
     <string name="split_app_info_accessibility">Informazions aplicazion par %1$s</string>
+    <string name="save_app_pair">Salve cubie di aplicazions</string>
     <string name="long_press_widget_to_add">Tocje e ten fracât par spostâ un widget.</string>
     <string name="long_accessible_way_to_add">Tocje dôs volti e ten fracât par spostâ un widget o par doprâ azions personalizadis.</string>
     <string name="widget_dims_format">%1$d \u00d7 %2$d</string>
@@ -49,6 +50,7 @@
     <string name="widgets_full_sheet_personal_tab">Personâls</string>
     <string name="widgets_full_sheet_work_tab">Lavôr</string>
     <string name="widget_category_conversations">Conversazions</string>
+    <string name="widget_category_note_taking">Cjape notis</string>
     <string name="widget_education_header">Informazions utilis a puartade di man</string>
     <string name="widget_education_content">Par otignî informazions cence vierzi lis aplicazions, tu puedis zontâ i widgets te schermade iniziâl</string>
     <string name="reconfigurable_widget_education_tip">Tocje par modificâ lis impostazions dal widget</string>
@@ -105,6 +107,7 @@
     <string name="folder_name_format_exact">Cartele: <xliff:g id="name" example="Games">%1$s</xliff:g>, <xliff:g id="size" example="2">%2$d</xliff:g> elements</string>
     <string name="folder_name_format_overflow">Cartele: <xliff:g id="name" example="Games">%1$s</xliff:g>, <xliff:g id="size" example="2">%2$d</xliff:g> o plui elements</string>
     <string name="styles_wallpaper_button_text">Fonts e stîl</string>
+    <string name="edit_home_screen">Modifiche schermade di Inizi</string>
     <string name="settings_button_text">Impostazions Inizi</string>
     <string name="msg_disabled_by_admin">Disativât dal to aministradôr</string>
     <string name="allow_rotation_title">Permet la rotazion de schermade di Inizi</string>
@@ -169,12 +172,13 @@
     <string name="work_profile_edu_work_apps">Lis aplicazions di lavôr a son segnadis cuntun badge e a son visibilis al to aministradôr di IT</string>
     <string name="work_profile_edu_accept">Capît</string>
     <string name="work_apps_paused_title">Lis aplicazions di lavôr a son in pause</string>
+    <string name="work_apps_paused_info_body">No tu ricevarâs notifichis des tôs aplicazions di lavôr</string>
     <string name="work_apps_paused_body">Lis tôs aplicazions di lavôr no puedin mandâti notifichis, doprâ batarie o acedi ae tô posizion</string>
+    <string name="work_apps_paused_telephony_unavailable_body">No tu ricevarâs clamadis telefonichis, messaçs di test o notifichis des tôs aplicazions di lavôr</string>
     <string name="work_apps_paused_edu_banner">Lis aplicazions di lavôr a son segnadis cuntun badge e a son visibilis al to aministradôr di IT</string>
     <string name="work_apps_paused_edu_accept">Capît</string>
     <string name="work_apps_pause_btn_text">Met in pause aplic. di lavôr</string>
+    <string name="work_apps_enable_btn_text">Termine pause</string>
     <string name="developer_options_filter_hint">Filtre</string>
-    <string name="search_pref_screen_title">Ricercjis sul telefon</string>
-    <string name="search_pref_screen_title_tablet">Ricercjis sul tablet</string>
     <string name="remote_action_failed">Azion falide: <xliff:g id="what" example="Pause">%1$s</xliff:g></string>
 </resources>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/arrays.xml b/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/arrays.xml
deleted file mode 100644
index 5576494..0000000
--- a/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/arrays.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2014 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string-array name="device_energy_saver_sleep_timeout_entries">
-        <item>15 minutes</item>
-        <item>20 minutes</item>
-        <item>30 minutes</item>
-        <item>1 hour</item>
-        <item>4 hores</item>
-        <item>8 hores</item>
-        <item>12 hours</item>
-        <item>24 hores</item>
-        <item>Never</item>
-    </string-array>
-    <string-array name="device_energy_saver_attentive_timeout_entries">
-        <item>4 hores</item>
-        <item>6 hours</item>
-        <item>8 hores</item>
-        <item>Never</item>
-    </string-array>
-</resources>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/strings.xml b/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/strings.xml
index 8397601..860276f 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/strings.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-ast-rES/strings.xml
@@ -14,9 +14,6 @@
      limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="connectivity_network_category_title">Redes ya internet</string>
-    <string name="applications_category_title">Aplicaciones</string>
-    <string name="privacy_category_title">Privacidá</string>
     <string name="surround_sound_format_dolby_mat">Dolby Atmos con Dolby TrueHD</string>
     <string name="surround_sound_format_dolby_truehd">Dolby TrueHD</string>
     <string name="surround_sound_format_e_ac3_joc">Dolby Atmos con Dolby Digital Plus</string>
@@ -30,12 +27,9 @@
     <string name="hdr_format_hlg">HLG</string>
     <string name="hdr_format_hdr10plus">HDR10+</string>
     <string name="hdr_format_dolby_vision">Dolby Vision</string>
-    <string name="resolution_selection_dialog_ok">D\'acuerdu</string>
     <string name="bluetooth_toggle_title">Bluetooth</string>
     <string name="bluetooth_known_devices_category">Accesorios</string>
     <string name="bluetooth_official_remote_category">Mandu</string>
-    <string name="launch_help">Centru d\'ayuda</string>
-    <string name="system_developer_options">Opciones pa desendolcadores</string>
     <string name="number_of_device_admins_none">Nun hai nenguna aplicación activa</string>
     <string name="enterprise_privacy_input_method">Tecláu predetermináu</string>
     <string name="do_disclosure_generic">La to organización xestiona esti preséu.</string>
@@ -44,22 +38,12 @@
     <string name="about_build">Compilación del SO d\'Android TV</string>
     <string name="ssl_ca_cert_warning">La rede pue tar supervisada</string>
     <string name="done_button">Fecho</string>
-    <string name="consumer_information_button_ok">D\'acuerdu</string>
-    <string name="title_mac_address">Direición MAC del preséu</string>
-    <string name="title_random_mac_settings">Privacidá</string>
     <string name="wifi_setting_other_options_add_network_via_easyconnect">Conexón rápida</string>
     <string name="wifi_setting_other_options_add_network_via_easyconnect_info_summary">        La conexón rápida ayúdate a conectate aína a redes Wi-Fi pente l\'escanéu d\'un códigu QR nel teléfonu.
     </string>
-    <string name="wifi_action_ok">D\'acuerdu</string>
-    <string name="wifi_action_advanced_yes">D\'acuerdu</string>
-    <string name="title_ok">D\'acuerdu</string>
     <string name="storage_dcim_usage">Semeyes y vídeos</string>
     <string name="microphone">Micrófonu</string>
     <string name="camera">Cámara</string>
-    <string name="device_apps_app_management_notifications">Avisos</string>
-    <string name="settings_ok">D\'acuerdu</string>
-    <string name="title_data_saver">Aforrador de datos</string>
-    <string name="disabled_by_policy_title_suspend_packages">Nun se pue abrir esta aplicación</string>
     <string name="admin_support_more_info">Más detalles</string>
     <string name="remove_and_uninstall_device_admin">Desactivar y desinstalar</string>
     <string name="channels_and_inputs_title">Canales y entraes</string>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-cy/strings.xml b/overlay/packages/apps/TvSettings/Settings/res/values-cy/strings.xml
index 0b67fde..4c84c0f 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-cy/strings.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-cy/strings.xml
@@ -133,16 +133,6 @@
     <string name="font_scale_settings_title">Graddio testun</string>
     <string name="font_scale_sample_text_title">Testun enghreifftiol</string>
     <string name="font_scale_preview_text_subtitle">        Ail Gainc y Mabinogi</string>
-    <string name="font_scale_preview_text_body">        Bendigeiduran a doeth ẏ r tir a llẏnghes ẏ gẏt ac ef parth a glann ẏr auon.
-        \"arglỽẏd\" heb ẏ ỽẏrda \"ti a ỽdost kẏnnedẏf ẏr auon. nẏ eill neb uẏnet drỽẏdi. nẏt oes bont arnei hitheu. Mae dẏ gẏnghor am bont\" heb ỽẏ.
-        \"Nit oes\" heb ẏnteu \"namẏn a uo penn bit pont. Mi a uẏdaf pont\" heb ef. 
-        ac ẏna gẏntaf ẏ dẏỽetpỽẏt ẏ geir hỽnnỽ ac ẏ diharebir etỽa ohonaỽ.
-        ac ẏna guedẏ gorỽed ohonaỽ ef ar traỽs ẏr auon ẏ bẏrỽẏt clỽẏdeu arnaỽ ef. ac ẏd aeth ẏ luoed ef ar ẏ draỽs ef drỽod. ar hẏnnẏ gẏt ac ẏ kẏuodes ef. llẏma gennadeu matholỽch ẏn dẏuot attaỽ ef ac ẏn kẏuarch guell idaỽ. ac ẏn ẏ annerch ẏ gan uatholỽch ẏ gẏua thrachỽr ac ẏn menegi o e uod ef na haedei arnaỽ ef namẏn da.
-        \"ac ẏ mae matholỽch ẏn rodi brenhinaeth iỽerdon ẏ ỽern uab matholỽch dẏ nei ditheu uab dẏ chỽaer ac ẏn ẏ ẏstẏnnu ẏ th ỽẏd di ẏn lle ẏ cam a r codẏant a ỽnaethpỽẏt ẏ uranỽen. ac ẏn ẏ lle ẏ mẏnnẏch ditheu aẏ ẏma aẏ ẏn ẏnẏs ẏ kedẏrn gossẏmdeitha uatholỽch.\"
-        \"Je\" heb ẏnteu uendigeiduran \"onẏ allaf i ue hun cael ẏ urenhinaeth. ac aduẏd ẏs kẏmeraf gẏnghor am ẏch kennadỽri chỽi. O hẏn hẏt ban del amgen nẏ cheffỽch ẏ genhẏf i attep.\"
-        \"Je\" heb ỽẏnteu \"ẏr atteb goreu a gaffom ninheu attat ti ẏ doỽn ac ef ac aro ditheu ẏn kennadỽri ninheu.\"
-        \"arhoaf\" heb ef \"o doỽch ẏn ehegẏr\"
-        ...</string>
     <string name="hdr_format_selection_auto_title">Awtomatig</string>
     <string name="hdr_format_selection_manual_title">Â llaw</string>
     <string name="hdr_format_hdr10">HDR10</string>
@@ -302,7 +292,6 @@
     <string name="about_preference">Ynghylch</string>
     <string name="device_name">Enw\'r ddyfais</string>
     <string name="restart_button_label">Ailgychwyn</string>
-    <string name="shutdown_button_label">Cau lawr</string>
     <string name="about_legal_info">Gwybodaeth gyfreithiol</string>
     <string name="about_terms_of_service">Cyfreithiol Google</string>
     <string name="about_license_activity_unavailable">Dyw data trwydded ddim ar gael</string>
@@ -625,7 +614,6 @@
     <string name="system_accessibility_status">Galluogi</string>
     <string name="system_accessibility_config">Ffurfweddiad</string>
     <string name="system_accessibility_service_on_confirm_title">Defnyddio <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
-    <string name="system_accessibility_service_on_confirm_desc">Gall <xliff:g id="service" example="TalkBack">%1$s</xliff:g> casglu\'r holl destun wyt ti\'n ei deipio, ond dim cyfrineiriau. Mae hyn yn cynnwys data personol fel rhifau cardiau credyd.</string>
     <string name="system_accessibility_service_off_confirm_title">Stopio <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
     <string name="system_accessibility_service_off_confirm_desc">Bydd dewis Iawn yn stopio <xliff:g id="service" example="TalkBack">%1$s</xliff:g>.</string>
     <string name="system_accessibility_tts_output">Testun i lafar</string>
@@ -646,7 +634,6 @@
     <string name="system_hdmi_optimization">Optimeiddiad HDMI</string>
     <string name="system_reboot_confirm">Ailgychwyn nawr?</string>
     <string name="system_desc_reboot_confirm">I ddiweddaru\'r gosodiad hwn, rhaid ailgychwyn y system</string>
-    <string name="system_shutdown_confirm">Cau lawr nawr?</string>
     <string name="system_never_check">Gwirio byth</string>
     <string name="system_check_for_drm_content_only">Gwirio am gynnwys DRM yn unig</string>
     <string name="system_always_check">Gwirio bob tro</string>
@@ -803,6 +790,7 @@
     <string name="restricted_profile_customize_restrictions">Ffurfweddu cyfyngiadau</string>
     <string name="restricted_profile_configure_apps_description_loading">Un foment\u2026</string>
     <string name="restricted_profile_change_password_title">Newid PIN</string>
+    <string name="restricted_profile_skip_action">Neidio</string>
     <string name="restriction_description"><xliff:g id="description">%1$s</xliff:g>\n<xliff:g id="value">%2$s</xliff:g></string>
     <string name="app_sees_restricted_accounts_and_controlled_by">Gall yr ap hwn gael at dy gyfrifon. Rheolwyd gan <xliff:g id="app">%1$s</xliff:g></string>
     <string name="pin_enter_unlock_channel">Rho PIN i wylio\'r sianel hon</string>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/arrays.xml b/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/arrays.xml
index cc0e0c1..82eb360 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/arrays.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/arrays.xml
@@ -23,7 +23,7 @@
     </string-array>
     <string-array name="device_energy_saver_sleep_timeout_entries">
         <item>15 minûts</item>
-        <item>20 minutes</item>
+        <item>20 minûts</item>
         <item>30 minûts</item>
         <item>1 ore</item>
         <item>4 oris</item>
@@ -34,7 +34,7 @@
     </string-array>
     <string-array name="device_energy_saver_attentive_timeout_entries">
         <item>4 oris</item>
-        <item>6 hours</item>
+        <item>6 oris</item>
         <item>8 oris</item>
         <item>Mai</item>
     </string-array>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/strings.xml b/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/strings.xml
index ed745a1..636955a 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-fur-rIT/strings.xml
@@ -29,6 +29,8 @@
     <string name="enabled">Atîf</string>
     <string name="disabled">Disativade</string>
     <string name="unavailable">No disponibil</string>
+    <string name="allow">Permet</string>
+    <string name="deny">Dinee</string>
     <string name="header_category_suggestions">Sugjeriments</string>
     <string name="header_category_quick_settings">Impostazions rapidis</string>
     <string name="header_category_general_settings">Impostazions gjenerâls</string>
@@ -112,6 +114,8 @@
     <string name="device_backup_restore">Backup e ripristinament</string>
     <string name="device_factory_reset">Ripristinament dai dâts di fabriche</string>
     <string name="device_calibration">Calibradure</string>
+    <string name="device_energy_saver">Temporizadôr di distudament</string>
+    <string name="device_energy_saver_summary">Stabilìs i temporizadôrs par distudâ la TV e sparagnâ energjie</string>
     <string name="device_fastpair">Dispositîfs</string>
     <string name="surround_sound_select_formats">Selezione i formâts</string>
     <string name="surround_sound_category_title">Sun surround</string>
@@ -119,6 +123,7 @@
     <string name="surround_sound_format_e_ac3">Dolby Digital Plus</string>
     <string name="surround_sound_format_dts">DTS</string>
     <string name="surround_sound_format_dts_hd">DTS-HD</string>
+    <string name="surround_sound_format_dts_uhd">DTS:X</string>
     <string name="surround_sound_format_dolby_mat">Dolby Atmos cun Dolby TrueHD</string>
     <string name="surround_sound_format_dolby_truehd">Dolby TrueHD</string>
     <string name="surround_sound_format_e_ac3_joc">Dolby Atmos cun Dolby Digital Plus</string>
@@ -161,10 +166,77 @@
     <string name="hdmi_cec_settings_title">HDMI-CEC</string>
     <string name="advanced_sound_settings_title">Impostazions avanzadis dal sun</string>
     <string name="game_mode_title">Permet modalitât zûc</string>
+    <string name="match_content_dynamic_range_title">Adate al interval dinamic dai contignûts</string>
+    <string name="match_content_dynamic_range_summary">Se tu ativis cheste opzion, il sisteme al passarà
+        di un formât a intervai dinamics a chel altri par adatâsi ai contignûts. Cheste operazion e podarès
+        puartâ a schermadis neris dilunc il passaç di un formât a chel altri.\n\nFâs clic su 
+        Impostazions avanzadis schermi par vê plui opzions sul interval dinamic.
+    </string>
+    <string name="preferred_dynamic_range_title">Interval dinamic preferît</string>
+    <string name="preferred_dynamic_range_selection_system_title">Conversion preferide dal sisteme</string>
+    <string name="preferred_dynamic_range_selection_system_desc">Lasse che il sisteme al gjestissi la conversion
+        dai formâts
+    </string>
+    <string name="preferred_dynamic_range_selection_system_summary">Se cheste opzion e je selezionade,
+        il sisteme al determinarà un interval dinamic adat di inviâ al to schermi e al convertirà
+        i contignûts a chest interval dinamic, daûr di ce che al covente.</string>
+    <string name="preferred_dynamic_range_selection_passthrough_desc">Si adate simpri al formât
+        dai contignûts</string>
+    <string name="preferred_dynamic_range_selection_force_title">Sfuarce conversion</string>
+    <string name="preferred_dynamic_range_selection_force_desc">Al sfuarce la conversion al formât
+        preferît</string>
+    <string name="preferred_dynamic_range_selection_force_summary">Sfuarce la conversion a
+        un formât preferît. La conversion sfuarçade e podarès lâ a tocjâ altris impostazions te
+        Modalitât di visualizazion o tal formât HDR.
+    </string>
+    <string name="preferred_dynamic_range_selection_force_sdr_title">Simpri a SDR</string>
+    <string name="preferred_dynamic_range_selection_force_hdr_title">Simpri a
+        <xliff:g id="hdr_type" example="Dolby Vision">%s</xliff:g></string>
+    <string name="preferred_dynamic_range_force_dialog_title">Desideristu sfuarçâ la jessude
+        HDR?</string>
+    <string name="preferred_dynamic_range_force_dialog_desc">Come impostazion predefinide la conversion e
+        vignarà sfuarçade a <xliff:g id="hdr_type" example="Dolby Vision">%s</xliff:g>.</string>
+    <string name="preferred_dynamic_range_force_dialog_desc_4k30_issue">Il to schermi al funzionarà ae
+        risoluzion 1080p a 60Hz. Cheste opzion no je compatibile cul to schermi cuant che al funzione
+         ae risoluzion 4k a 60Hz.</string>
+    <string name="selection_dolby_vision_not_supported_sidebar">Dolby Vision nol è supuartât in cheste
+        risoluzion. Se tu ativis a man il Dolby Vision, la risoluzion dal to schermi e vignarà
+        cambiade a 1080p a 60Hz</string>
+    <string name="manual_dolby_vision_format_on_4k60_title">Cambiâ la risoluzion a 1080p a 60Hz?</string>
+    <string name="dynamic_range_selection_force_dv_title">Sfuarce simpri la conversion a Dolby Vision
+    </string>
+    <string name="dynamic_range_selection_force_dv_summary">Se Dolby Vision al è disativât tai Formâts
+        HDR tes Impostazions avanzadis dal schermi, il sfuarçament de conversion a Dolby Vision
+        al tornarà a ativâlu.
+    </string>
+    <string name="dynamic_range_selection_force_hdr10_title">Sfuarce simpri la conversion a HDR10
+    </string>
+    <string name="dynamic_range_selection_force_hdr10_summary">Se HDR10 al è disativât tai Formâts
+        HDR tes Impostazions avanzadis dal schermi, il sfuarçament de conversion a HDR10 al tornarà a ativâlu.
+    </string>
+    <string name="dynamic_range_selection_force_hlg_title">Sfuarce simpri la conversion a HLG
+    </string>
+    <string name="dynamic_range_selection_force_hlg_summary">Se HLG al è disativât tai Formâts
+        HDR tes Impostazions avanzadis dal schermi, il sfuarçament de conversion a HLG al tornarà a ativâlu.
+    </string>
+    <string name="dynamic_range_selection_force_hdr10plus_title">Sfuarce simpri la conversion a HDR10+
+    </string>
+    <string name="dynamic_range_selection_force_hdr10plus_summary">Se HDR10+ al è disativât tai Formâts
+        HDR tes Impostazions avanzadis dal schermi, il sfuarçament de conversion a HDR10+ al tornarà a ativâlu.
+    </string>
+    <string name="dynamic_range_selection_force_sdr_title">Sfuarce simpri la conversion a SDR
+    </string>
+    <string name="dynamic_range_selection_force_sdr_summary">Il sfuarçament de conversion a SDR al disativarà ducj
+        i formâts intai Formâts HDR tes Impostazions avanzadis dal schermi.
+    </string>
     <string name="match_content_frame_rate_title">Adate ae frecuence di fotograms dai contignûts</string>
+    <string name="match_content_frame_rate_seamless">Dome cence soluzion di continuitât</string>
     <string name="match_content_frame_rate_seamless_summary">Se la aplicazion lu domande, la jessude
         dal dispositîf e corispuindarà ae frecuence di fotograms origjinâl dai contignûts
         che tu stâs cjalant DOME se al tô TV e pues fâ une transizion fluide.  </string>
+    <string name="match_content_frame_rate_seamless_not_supported_summary">Il schermi colegât
+        nol supuarte lis transizions cence soluzion di continuitât des frecuencis di inzornament. 
+        Cheste opzion no varà efiets gjavant che no tu ledis a doprâ un schermi che lis supaurte.</string>
     <string name="match_content_frame_rate_non_seamless">Simpri</string>
     <string name="match_content_frame_rate_non_seamless_summary">Se la aplicazion lu domande, il to
         dispositîf al cumbinarà la jessude ae frecuence di fotograms origjinâl dal contignût
@@ -180,18 +252,6 @@
     <string name="font_scale_preview_text_title" translation_description="Translate manually. No not adopt any copyrighted material for translation.">        Il maraveôs mâc di Oz
     </string>
     <string name="font_scale_preview_text_subtitle">        Cjapitul 11: La maraveose citât di smeralt di Oz</string>
-    <string name="font_scale_preview_text_body">        Aben che i lôr voi a jerin protets des lints verdis, Dorothy e i siei amîs a restarin subite incantesemâts dal sflandôr de maraveose Citât.
-        Su lis stradis si davin lis bielis cjasis fatis di marmul vert e tampiestadis dapardut di smeralts slusints.
-        A cjaminarin dilunc un marcjepît fat dal stes marmul vert e là che i blocs a jerin metûts dongje a stavin riis di smeralts incassâts e slusints ae clare lûs sflandorose dal soreli.
-        I veris dai barcons a jerin verts; ancje il cîl parsore de Citât al veve une sfumadure verde e i rais dal soreli a jerin verts.
-        \n\nE jere tante int, oms, feminis e fruts che a cjaminavin, ducj a jerin vistûts cun vistîts verts e a vevin la piel sul verdulin.
-        A cjalavin Dorothy e la sô strambe compagnie cun voi maraveâts e ducj i fruts a scjampavin e si platavin daûr des lôr maris cuant che a viodevin il Leon; ma nissun ur cjacarà.
-        A jerin tantis buteghis vie pe strade e Dorothy e viodè che dut ce che al stave dentri al jere vert.
-        A vignivin vendudis caramelis verdis e pop-corn verts e cussì ancje scarpis verdis, cjapiei verts e vistîts verts di ogni sorte.
-        Intun puest un om al vendeve limonade verde e cuant che i fruts le compravin Dorothy e podè viodi che le paiavin cun minûts verts.
-        \n\nAl someave che no fossin ni cjavai ni bestiis di cualsisei gjenar; i oms a puartavis ator la robe in piçui cjaruçs verts che a sburtavin denant di lôr.
-        Ducj a someavin contents, sodisfats e florits.
-    </string>
     <string name="hdr_format_selection_title">Selezion formât</string>
     <string name="hdr_format_selection_auto_title">Automatiche</string>
     <string name="hdr_format_selection_manual_title">Manuâl</string>
@@ -199,6 +259,7 @@
     <string name="hdr_format_selection_manual_desc">Sielç a man i formâts tra chei disponibii</string>
     <string name="hdr_format_supported_title">FORMÂTS SUPUARTÂTS</string>
     <string name="hdr_format_unsupported_title">FORMÂTS NO SUPUARTÂTS</string>
+    <string name="hdr_format_sdr">SDR</string>
     <string name="hdr_format_hdr10">HDR10</string>
     <string name="hdr_format_hlg">HLG</string>
     <string name="hdr_format_hdr10plus">HDR10+</string>
@@ -220,10 +281,19 @@
     <string name="resolution_selection_title">Risoluzion</string>
     <string name="resolution_selection_auto_title">Automatiche</string>
     <string name="resolution_selection_dialog_title">La risoluzion e je stade cambiade</string>
+    <string name="resolution_selection_with_mode_dialog_title">Passâ ae risoluzion %1$s?</string>
     <string name="resolution_selection_dialog_desc">Selezione Va ben par doprâ %1$s di cumò indevant.</string>
+    <string name="resolution_selection_disabled_dolby_vision_dialog_desc">Dolby Vision nol è 
+        supuartât te modalitât %1$s e al vignarà disativât tes \"Impostazions avanzadis dal schermi\"
+        </string>
+    <string name="resolution_hdr_description_info">Cheste modalitât e supuarte: %1$s\nSu cualchi TV tu varâs
+        di ativâ l\'HDMI miorât par abilitâ plui formats HDR. Controle lis impostazions de tô TV par viodi se
+        cheste funzion e je supuartade.</string>
     <string name="resolution_selection_dialog_cancel">Anule</string>
     <string name="resolution_selection_dialog_ok">Va ben</string>
     <string name="resolution_selection_hz">Hz</string>
+    <string name="resolution_display_mode">        <xliff:g id="resolution" example="1080p, 4k etc">%1$s</xliff:g>
+        (<xliff:g id="refresh-rate" example="60, 59.94 etc">%2$s</xliff:g> Hz)</string>
     <string name="device_storage_clear_cache_title">Netâ i dâts te cache?</string>
     <string name="device_storage_clear_cache_message">Si netarà ducj i dâts te cache des aplicazions.</string>
     <string name="accessories_add">Zonte acessori</string>
@@ -360,6 +430,7 @@
     </string>
     <string name="do_disclosure_generic">Chest dispositîf al è gjestît de tô organizazion.</string>
     <string name="do_disclosure_with_name">Chest dispositîf al è gjestît di <xliff:g id="organization_name" example="Foo, Inc.">%s</xliff:g>.</string>
+    <string name="hdr_capability">- %1$s</string>
     <string name="learn_more">Plui informazions</string>
     <string name="default_camera_app_title"> {count, plural,
         one {}=1    {Aplicazion fotocjamare}
@@ -392,7 +463,6 @@
     <string name="about_preference">Informazions</string>
     <string name="device_name">Non dal dispositîf</string>
     <string name="restart_button_label">Torne invie</string>
-    <string name="shutdown_button_label">Distude</string>
     <string name="about_legal_info">Informazions legâls</string>
     <string name="about_legal_license">Licencis open source di tiercis parts</string>
     <string name="about_terms_of_service">Notis legâls di Google</string>
@@ -672,6 +742,7 @@
     <string name="recently_accessed_show_all">Viôt dutis</string>
     <string name="microphone">Microfon</string>
     <string name="mic_toggle_title">Acès al microfon</string>
+    <string name="mic_remote_toggle_title">Acès al microfon sul telecomant</string>
     <string name="open_mic_permissions">Acès des aplicazions al microfon</string>
     <string name="microphone_physical_privacy_enabled_title">Acès al microfon blocât</string>
     <string name="microphone_physical_privacy_enabled_text">Par sblocâ e concedi l\'acès al microfon,
@@ -684,6 +755,22 @@
         sposte l\'interutôr pe riservatece dal dispositîf su la posizion di fotocjamare ative.</string>
     <string name="mic_toggle_info_title">Acès al microfon:
         <xliff:g id="sensor_state" example="On">%s</xliff:g></string>
+    <string name="mic_toggle_info_content">Se ativât, dutis lis aplicazions e i servizis cul permès par
+        acedi al microfon a rivaran a doprâlu.\n\nSe disativât, nissune aplicazion o servizi al rivarà
+        a acedi al microfon. Ma tu tu rivarâs distès a fevelâ cun Google Assistant
+        fracant il boton dal assistent sul telecomant.\n\nI dispositîfs audio che a doprin protocoi personalizâts pe
+        comunicazion cu la TV no son tocjâts di cheste impostazion.
+    </string>
+    <string name="mic_remote_toggle_on_info_title">Microfon ativât sul telecomant</string>
+    <string name="mic_remote_toggle_on_info_content">Google Assistant al rive a acedi al
+        microfon sul telecomant. Tu rivarâs a fevelâ cul assistent fracant il boton di Google
+        Assistant sul telecomant.
+    </string>
+    <string name="mic_remote_toggle_off_info_title">Microfon disativât sul telecomant</string>
+    <string name="mic_remote_toggle_off_info_content">No tu rivarâs a fevelâ cun Google Assistant
+        doprant il telecomant. Par rivâ a doprâ il boton di Google Assistant, ative l\'acès al
+        microfon.
+    </string>
     <string name="camera_toggle_info_title">Acès ae fotocjamare:
         <xliff:g id="sensor_state" example="On">%s</xliff:g></string>
     <string name="camera_toggle_info_content">Se cheste opzion e ven ativade, dutis lis aplicazions e i servizis autorizâts
@@ -713,15 +800,34 @@
     <string name="location_history_desc">Se la Cronologjie des posizions e je ative par chest account, Google al pues archiviâ i dâts de posizion dal to dispositîf par podêle doprâ tes tôs aplicazions.\n\nPar esempli, Google Maps al pues dâti indicazions e Google Now al pues informâti sul trafic.\n\nTu puedis disativâ la Cronologjie des posizions cuant che tu vûs, ma se tu lu fasis tu le eliminarâs. Par viodi e gjestî la Cronologjie des posizions, visite maps.google.com/locationhistory.</string>
     <string name="delete_location_history_title">Elimine cronologjie des posizions</string>
     <string name="delete_location_history_desc">Cheste operazion e eliminarà dute la Cronologjie des posizions archiviade di chest dispositîf par chest account Google. Nol è pussibil tornâ indaûr di cheste eliminazion. Cualchi aplicazion, includude Google Now, no funzionarà plui.</string>
+    <string name="accessibility_screen_readers_category_title">Letôrs di schermi</string>
     <string name="accessibility_display_category_title">Schermi</string>
+    <string name="accessibility_interaction_controls_category_title">Controi di interazion</string>
+    <string name="accessibility_audio_and_onscreen_text_category_title">Audio e test su schermi</string>
+    <string name="accessibility_experimental_category_title">Sperimentâls</string>
     <string name="accessibility_services_category_title">Servizis</string>
     <string name="accessibility_service_settings">Impostazions servizi</string>
+    <string name="accessibility_screen_reader_flattened_component_name">com.google.android.marvin.talkback/com.google.android.marvin.talkback.TalkBackService</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title">Test a contrast elevât</string>
+    <string name="accessibility_toggle_bold_text_preference_title">Test in neret</string>
+    <string name="accessibility_color_correction">Corezion dai colôrs</string>
+    <string name="color_correction_usage">Dopre corezion dai colôrs</string>
+    <string name="color_correction_color_mode">Modalitât colôr</string>
+    <string name="color_correction_mode_deuteranomaly">Deuteranomalie</string>
+    <string name="color_correction_mode_deuteranomaly_summary">Ros-vert</string>
+    <string name="color_correction_mode_protanomaly">Protanomalie</string>
+    <string name="color_correction_mode_protanomaly_summary">Ros-vert</string>
+    <string name="color_correction_mode_tritanomaly">Tritanomalie</string>
+    <string name="color_correction_mode_tritanomaly_summary">Blu-zâl</string>
+    <string name="color_correction_mode_grayscale">Scjale di grîs</string>
     <string name="palette_color_red">Ros</string>
+    <string name="palette_color_orange">Naranç</string>
     <string name="palette_color_yellow">Zâl</string>
     <string name="palette_color_green">Vert</string>
     <string name="palette_color_cyan">Ciano</string>
     <string name="palette_color_blue">Blu</string>
+    <string name="palette_color_purple">Viole</string>
+    <string name="palette_color_gray">Grîs</string>
     <string name="accessibility_shortcut">Scurte di acès facilitât</string>
     <string name="accessibility_shortcut_enable">Abilite scurte di acès facilitât</string>
     <string name="accessibility_shortcut_service">Servizi de scurte</string>
@@ -768,7 +874,6 @@
     <string name="system_accessibility_status">Ative</string>
     <string name="system_accessibility_config">Configurazion</string>
     <string name="system_accessibility_service_on_confirm_title">Doprâ <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
-    <string name="system_accessibility_service_on_confirm_desc"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> al pues tirâ dongje ducj i tescj che tu scrivis, gjavadis lis passwords. Chest al inclût informazions personâls come i numars di cjarte di credit.</string>
     <string name="system_accessibility_service_off_confirm_title">Fermâ <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
     <string name="system_accessibility_service_off_confirm_desc">Selezionant Va ben tu interomparâs <xliff:g id="service" example="TalkBack">%1$s</xliff:g>.</string>
     <string name="system_accessibility_tts_output">Sintesi vocâl</string>
@@ -790,7 +895,6 @@
     <string name="system_hdmi_optimization">Otimizazion HDMI</string>
     <string name="system_reboot_confirm">Tornâ a inviâ daurman?</string>
     <string name="system_desc_reboot_confirm">Par inzornâ cheste impostazion, al è necessari tornâ a inviâ il dispositîf</string>
-    <string name="system_shutdown_confirm">Distudâ daurman?</string>
     <string name="system_never_check">No sta controlâ mai</string>
     <string name="system_check_for_drm_content_only">Controle dome pai contignûts DRM</string>
     <string name="system_always_check">Controle simpri</string>
@@ -949,6 +1053,7 @@
     <string name="restricted_profile_customize_restrictions">Personalize limitazions</string>
     <string name="restricted_profile_configure_apps_description_loading">Un moment\u2026</string>
     <string name="restricted_profile_change_password_title">Cambie pin</string>
+    <string name="restricted_profile_skip_action">Salte</string>
     <string name="restriction_description"><xliff:g id="description">%1$s</xliff:g>\n<xliff:g id="value">%2$s</xliff:g></string>
     <string name="app_sees_restricted_accounts_and_controlled_by">Cheste aplicazion e pues acedi ai tiei accounts. Controlade di <xliff:g id="app">%1$s</xliff:g></string>
     <string name="pin_enter_unlock_channel">Inserìs il PIN par cjalâ chest canâl</string>
@@ -1001,6 +1106,23 @@
     <string name="device_daydreams_sleep_description">Il salve-schermi al partirà dopo chest periodi di inativitât. Se nol è selezionât nissun salve-schermi, il schermi si distudarà.</string>
     <string name="device_daydreams_sleep_summary">Dopo <xliff:g id="sleep_description" example="3 minutes">%1$s</xliff:g> di inativitât</string>
     <string name="device_energy_saver_screen_off">Distude il schermi</string>
+    <string name="device_energy_saver_timeout_description"><xliff:g id="sleep_description" example="4 hours">%1$s</xliff:g></string>
+    <string name="device_energy_saver_confirmation_title">Conferme impostazion di alimentazion e energjie</string>
+    <string name="device_energy_saver_confirmation_message">Lassant impiade la TV par tant timp al podarès aumentâ il consum di energjie</string>
+    <string name="device_energy_saver_disable_allow_turning_screen_off_title">Disative la impostazion di sparagn energjetic</string>
+    <string name="device_energy_saver_disable_allow_turning_screen_off_text">Conferme che il schermi nol à di distudâsi intant che tu cjalis contignûts. Ten iniments che in chest câs tu podaressis aumentâ il consum energjetic.</string>
+    <string name="device_energy_saver_sleep_timeout">Se inatîf</string>
+    <string name="device_energy_saver_attentive_timeout">Se atîf</string>
+    <string name="device_energy_saver_category_title">Disative in automatic</string>
+    <string name="device_energy_saver_sleep_timeout_dialog_title">Disative in automatic se inatîf</string>
+    <string name="device_energy_saver_attentive_timeout_dialog_title">Disative in automatic dilunc la riproduzion di contignûts</string>
+    <string name="device_energy_saver_validation_sleep">Il temporizadôr \"Se înatîf\" al à di sei plui curt dal temporizadôr \"Se atîf\"</string>
+    <string name="device_energy_saver_validation_attentive">Il temporizadôr \"Se atîf\" al à di sei plui lunc dal temporizadôr \"Se inatîf\"</string>
+    <string name="limit_network_in_standby_toggle_title">Limite la conession di rêt se in pause</string>
+    <string name="limit_network_in_standby_toggle_summary">Al dopre mancul energjie in modalitât in pause (standby)</string>
+    <string name="limit_network_in_standby_toggle_info">La TV e vignarà disconetude de rêt se in modalitât in pause (standby), gjavant il câs de ricezion di inzornaments automatics. Chest al podarès diminuî il consum energjetic de TV, dut câs al significhe che no tu rivarâs a doprâ funzions come Cast e Google Assistant intant che e je in pause.</string>
+    <string name="limit_network_in_standby_confirm_title">Permet la conession di rêt se in pause</string>
+    <string name="limit_network_in_standby_confirm_message">Consintint la conession di rêt se in pause, tu aumentarâs il consum di energjie in modalitât pause (standby).</string>
     <string name="backup_configure_account_default_summary">In chest moment nisun account al sta memorizant i dâts dai backups</string>
     <string name="backup_erase_dialog_message">Smeti di fâ il backup des tôs passwords Wi-Fi, dai segnelibris, des altris impostazions e dai dâts di aplicazion e scancelâ dutis lis copiis sui servidôrs di Google?</string>
     <string name="privacy_backup_data">Backup dai miei dâts</string>
@@ -1099,12 +1221,17 @@
     <string name="time_to_start_read_title">Timp prime di scomençâ a lei</string>
     <string name="time_to_valid_audio_title">Timp par convalidâ i dâts audio</string>
     <string name="empty_audio_duration_title">Durade dal audio vueit</string>
+    <string name="record_audio_source_title">Sorzint audio regjistrade</string>
+    <string name="record_audio_source_dialog_title">Selezione la sorzint audio regjistrade pe prossime regjistrazion</string>
+    <string name="recorded_microphones_title">Microfons regjistrâts</string>
     <string name="show_audio_recording_start_failed">Nol è stât pussibil scomençâ la regjistrazion audio.</string>
     <string name="show_audio_recording_failed">Regjistrazion audio falide.</string>
     <string name="title_data_saver">Sparagn dâts</string>
     <string name="summary_data_saver">Regole in automatic la cualitât video par doprâ mancul dâts mobii</string>
     <string name="title_data_alert">Utilizazion dâts e avîs</string>
     <string name="data_saver_header_info">Tu puedis conetiti a internet midiant il Wi-Fi, un cabli Ethernet o il pont di acès dal telefon.</string>
+    <string name="bluetooth_ask_discovery_title">Rint visibil a altris dispositîfs Bluetooth?</string>
+    <string name="bluetooth_ask_discovery_message">Une aplicazion e vûl rindi visibile la tô TV a altris dispositîfs Bluetooth par <xliff:g id="timeout">%1$d</xliff:g> seconts.</string>
     <string name="disabled_by_policy_title">Azion no consintude</string>
     <string name="disabled_by_policy_title_adjust_volume">Impussibil cambiâ il volum</string>
     <string name="disabled_by_policy_title_outgoing_calls">Clamadis no consintudis</string>
@@ -1169,4 +1296,9 @@
     <string name="power_on_behavior">Compuartament al impiament</string>
     <string name="reset_options_title">Ripristinament</string>
     <string name="adb_pairing_device_dialog_ethernet_pairing_code_label">Codiç di associazion ethernet</string>
+    <string name="energy_modes">Modalitâts di energjie</string>
+    <string name="energy_modes_summary">Miore la eficience energjetiche se la TV no ven doprade</string>
+    <string name="energy_mode_enables">E ative:</string>
+    <string name="energy_mode_eco_hint">Viôt che cheste modalitât e podarès aumentâ il consum energjetic dal dispositîf.</string>
+    <string name="energy_modes_confirmation_title">Ative \"<xliff:g id="energyModeName" example="Essential network features">%s</xliff:g>\"</string>
 </resources>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-gd/strings.xml b/overlay/packages/apps/TvSettings/Settings/res/values-gd/strings.xml
index 51860c1..f4285d0 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-gd/strings.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-gd/strings.xml
@@ -168,7 +168,6 @@
     <string name="about_preference">Mu dhèidhinn</string>
     <string name="device_name">Ainm an uidheim</string>
     <string name="restart_button_label">Ath-thòisich</string>
-    <string name="shutdown_button_label">Cuir dheth</string>
     <string name="about_legal_info">Fiosrachadh laghail</string>
     <string name="about_terms_of_service">Fiosrachadh laghail Google</string>
     <string name="about_license_activity_unavailable">Chan eil dàta a’ cheadachais ri fhaighinn</string>
@@ -476,7 +475,6 @@
     <string name="system_accessibility_status">Cuir an comas</string>
     <string name="system_accessibility_config">Rèiteachadh</string>
     <string name="system_accessibility_service_on_confirm_title">An cleachd thu <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
-    <string name="system_accessibility_service_on_confirm_desc">’S urrainn dha <xliff:g id="service" example="TalkBack">%1$s</xliff:g> teachsa sam bith a sgrìobhas tu ach faclan-faire a chruinneachadh. Gabhaidh seo a-staigh dàta pearsanta, can àireamhan cairte-creideis.</string>
     <string name="system_accessibility_service_off_confirm_title">An cuir thu stad air <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
     <string name="system_accessibility_service_off_confirm_desc">Ma thaghas tu “Ceart ma-thà”, thèid stad a chur air <xliff:g id="service" example="TalkBack">%1$s</xliff:g>.</string>
     <string name="system_accessibility_tts_output">Teacsa ’na chainnt</string>
@@ -497,7 +495,6 @@
     <string name="system_hdmi_optimization">Piseachadh HDMI</string>
     <string name="system_reboot_confirm">An dèan thu ath-thòiseachadh an-dràsta?</string>
     <string name="system_desc_reboot_confirm">Airson an roghainn seo ùrachadh, feumaidh an t-uidheam agad ath-thòiseachadh</string>
-    <string name="system_shutdown_confirm">An dùin thu sìos e an-dràsta?</string>
     <string name="system_never_check">Na doir sùil idir</string>
     <string name="system_check_for_drm_content_only">Thoir sùil airson susbaint fo DRM a-mhàin</string>
     <string name="system_always_check">Thoir sùil an-còmhnaidh</string>
@@ -641,6 +638,7 @@
     <string name="restricted_profile_customize_restrictions">Gnàthaich na cuingeachaidhean</string>
     <string name="restricted_profile_configure_apps_description_loading">Bheir seo diog no dhà\u2026</string>
     <string name="restricted_profile_change_password_title">Atharraich am PIN</string>
+    <string name="restricted_profile_skip_action">Leum thairis air</string>
     <string name="restriction_description"><xliff:g id="description">%1$s</xliff:g>\n<xliff:g id="value">%2$s</xliff:g></string>
     <string name="app_sees_restricted_accounts_and_controlled_by">’S urrainn dhan aplacaid seo na cunntasan agad inntrigeadh. Fo stiùireadh <xliff:g id="app">%1$s</xliff:g></string>
     <string name="pin_enter_unlock_channel">Cuir a-steach am PIN airson coimhead air an t-seanail seo</string>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-kab-rDZ/strings.xml b/overlay/packages/apps/TvSettings/Settings/res/values-kab-rDZ/strings.xml
index 99857ca..9beb4f9 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-kab-rDZ/strings.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-kab-rDZ/strings.xml
@@ -74,7 +74,6 @@
     <string name="about_preference">Talɣut ɣef...</string>
     <string name="device_name">Isem ibenk</string>
     <string name="restart_button_label">Ales tanekra</string>
-    <string name="shutdown_button_label">Sexsi</string>
     <string name="about_legal_info">Talɣut tusḍift</string>
     <string name="about_model">ModÃ¨le</string>
     <string name="about_ads">Idellilen</string>
@@ -205,6 +204,7 @@
     <string name="restricted_profile_configure_title">Iɣewwaṛen</string>
     <string name="restricted_profile_allowed">Ittwasireg</string>
     <string name="restricted_profile_not_allowed">Ur ittwasireg ara</string>
+    <string name="restricted_profile_skip_action">Zgel</string>
     <string name="pin_enter_pin">Sekcem PIN</string>
     <string name="wifi_setup_save_success">Ttwaskelsen akken iwata</string>
     <string name="device_apps_app_management_open">Ldi</string>
diff --git a/overlay/packages/apps/TvSettings/Settings/res/values-lb/strings.xml b/overlay/packages/apps/TvSettings/Settings/res/values-lb/strings.xml
index c1901c0..cc8c2ba 100644
--- a/overlay/packages/apps/TvSettings/Settings/res/values-lb/strings.xml
+++ b/overlay/packages/apps/TvSettings/Settings/res/values-lb/strings.xml
@@ -266,7 +266,6 @@
     <string name="color_magenta">Magenta</string>
     <string name="system_accessibility_config">Konfiguratioun</string>
     <string name="system_accessibility_service_on_confirm_title"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> benotzen?</string>
-    <string name="system_accessibility_service_on_confirm_desc"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> kann all d\'Texter déi s du agëss, perséinlech Daten a Kreditkaartennummere sammelen, awer keng Passwierder.</string>
     <string name="system_accessibility_service_off_confirm_title"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> stoppen?</string>
     <string name="system_accessibility_service_off_confirm_desc">Duerch d\'Auswiele vun \"OK\" gëtt <xliff:g id="service" example="TalkBack">%1$s</xliff:g> gestoppt.</string>
     <string name="system_accessibility_tts_output">Text-a-Sprooch</string>
@@ -412,6 +411,7 @@
     <string name="restricted_profile_customize_restrictions">Personaliséiert Beschränkungen</string>
     <string name="restricted_profile_configure_apps_description_loading">Ee Moment\u2026</string>
     <string name="restricted_profile_change_password_title">PIN änneren</string>
+    <string name="restricted_profile_skip_action">Iwwersprangen</string>
     <string name="restriction_description"><xliff:g id="description">%1$s</xliff:g>\n<xliff:g id="value">%2$s</xliff:g></string>
     <string name="pin_enter_unlock_channel">Gëff de PIN an, fir dëse Kanal ze gesinn</string>
     <string name="pin_enter_unlock_program">Gëff de PIN an, fir dëse Programm ze gesinn</string>
diff --git a/overlay/packages/apps/WallpaperPicker2/res/values-ast-rES/strings.xml b/overlay/packages/apps/WallpaperPicker2/res/values-ast-rES/strings.xml
deleted file mode 100644
index 96f610c..0000000
--- a/overlay/packages/apps/WallpaperPicker2/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-     Copyright (C) 2017 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="edit_live_wallpaper">Editar</string>
-    <string name="bottom_action_bar_back">Atrás</string>
-    <string name="bottom_action_bar_edit">Editar</string>
-    <string name="bottom_action_bar_download">Baxar</string>
-    <string name="bottom_action_bar_apply">Aplicar</string>
-    <string name="accessibility_preview_pager" msgid="3548503287402185430">Páxina <xliff:g name="current_page" example="1">%1$d</xliff:g> de <xliff:g name="num_pages" example="2">%2$d</xliff:g></string>
-    <string name="next_page_content_description" msgid="5290226604542300962">Siguiente</string>
-    <string name="previous_page_content_description" msgid="6025726405430262788">Anterior</string>
-    <string name="collection_not_exist_msg">La coleición nun esiste</string>
-    <string name="apply_btn" msgid="7965877231041987336">Aplicar</string>
-</resources>
diff --git a/overlay/packages/apps/WallpaperPicker2/res/values-cy/strings.xml b/overlay/packages/apps/WallpaperPicker2/res/values-cy/strings.xml
index 955d6bf..6f9a570 100644
--- a/overlay/packages/apps/WallpaperPicker2/res/values-cy/strings.xml
+++ b/overlay/packages/apps/WallpaperPicker2/res/values-cy/strings.xml
@@ -88,7 +88,6 @@
     <string name="delete_live_wallpaper">Dileu</string>
     <string name="edit_live_wallpaper">Golygu</string>
     <string name="delete_wallpaper_confirmation">Dileu\u2019r papur wal hwn o dy ddyfais?</string>
-    <string name="bottom_action_bar_back">Nôl</string>
     <string name="bottom_action_bar_edit">Golygu</string>
     <string name="bottom_action_bar_download">Lawrlwytho</string>
     <string name="bottom_action_bar_slideshow_wallpaper">Papur Wâl Sleidiau</string>
diff --git a/overlay/packages/apps/WallpaperPicker2/res/values-fur-rIT/strings.xml b/overlay/packages/apps/WallpaperPicker2/res/values-fur-rIT/strings.xml
index 9a912c4..b2c6fe4 100644
--- a/overlay/packages/apps/WallpaperPicker2/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/apps/WallpaperPicker2/res/values-fur-rIT/strings.xml
@@ -27,6 +27,8 @@
     <string name="static_wallpaper_presentation_mode_message">Atualmentri stabilît</string>
     <string name="rotating_wallpaper_presentation_mode_message">Fonts zornalîr</string>
     <string name="wallpaper_destination_both">Schermade di inizi e di bloc</string>
+    <string name="choose_a_wallpaper_section_title">Sielç un fonts</string>
+    <string name="creative_wallpaper_title">Cree un fonts</string>
     <string name="home_screen_message">Schermade di inizi</string>
     <string name="lock_screen_message">Schermade di bloc</string>
     <string name="home_and_lock_short_label">Inizi e bloc</string>
@@ -81,6 +83,7 @@
     <string name="explore_lock_screen">Esplore il fonts de schermade di bloc</string>
     <string name="refresh_daily_wallpaper_home_content_description">Inzorne ogni dì il fonts de schermade di inizi</string>
     <string name="refresh_daily_wallpaper_content_description">Inzorne ogni dì il fonts</string>
+    <string name="preview_screen_description">Schermade di anteprime dal fonts</string>
     <string name="refreshing_daily_wallpaper_dialog_message">        Daûr a inzornâ il fonts zornalîr…
     </string>
     <string name="refresh_daily_wallpaper_failed_message">        Nol è stât pussibil inzornâ il fonts zornalîr. Controle la conession di rêt e torne prove.
@@ -106,7 +109,6 @@
     <string name="delete_live_wallpaper">Elimine</string>
     <string name="edit_live_wallpaper">Modifiche</string>
     <string name="delete_wallpaper_confirmation">Eliminâ chest fonts dal to dispositîf?</string>
-    <string name="bottom_action_bar_back">Indaûr</string>
     <string name="bottom_action_bar_edit">Modifiche</string>
     <string name="bottom_action_bar_download">Discjame</string>
     <string name="bottom_action_bar_slideshow_wallpaper">Presentazion fonts</string>
@@ -116,11 +118,19 @@
     <string name="previous_page_content_description" msgid="6025726405430262788">Indaûr</string>
     <string name="wallpaper_title">Fonts</string>
     <string name="wallpaper_preview_card_content_description">Anteprime dal fonts</string>
+    <string name="lock_wallpaper_preview_card_content_description">Anteprime fonts de schermade di bloc</string>
+    <string name="home_wallpaper_preview_card_content_description">Anteprime fonts de schermade di Inizi</string>
     <string name="collection_not_exist_msg">La colezion no esist</string>
+    <string name="wallpaper_exit_split_screen">Jes de modalitât schermi dividût e torne prove</string>
     <string name="cancel">Anule</string>
     <string name="hide_ui_preview_text">Plate anteprime IU</string>
     <string name="hint_hide_ui_preview">IU platade te anteprime. Tocje 2 voltis par mostrâ</string>
     <string name="show_ui_preview_text">Mostre anteprime IU</string>
+    <string name="hide_preview_controls_content_description">I controi di anteprime a son visualizâts. Dople tocjade par platâ</string>
+    <string name="hide_preview_controls_action">Plate controi di anteprime</string>
+    <string name="show_preview_controls_content_description">I controi di anteprime a son platâts. Dople tocjade par mostrâ</string>
+    <string name="show_preview_controls_action">Mostre controi di anteprime</string>
+    <string name="hide_wallpaper_info_action">Plate informazions fonts</string>
     <string name="hint_show_ui_preview">IU mostrade te anteprime. Tocje 2 voltis par platâ</string>
     <string name="wallpaper_picker_entry_title" msgid="7039652539125902659">Cambie fonts</string>
     <string name="lockscreen_wallpaper_preview_card_content_description" msgid="8575577284424318765">Anteprime fonts schermade di bloc</string>
@@ -137,4 +147,5 @@
     <string name="reset">Ripristine</string>
     <string name="reset_confirmation_dialog_title">Anulâ lis modifichis?</string>
     <string name="reset_confirmation_dialog_message">Lis modifichis no vignaran salvadis</string>
+    <string name="more_wallpapers">Altris fonts</string>
 </resources>
diff --git a/overlay/packages/apps/WallpaperPicker2/res/values-gd/strings.xml b/overlay/packages/apps/WallpaperPicker2/res/values-gd/strings.xml
index 06e5f24..8d31990 100644
--- a/overlay/packages/apps/WallpaperPicker2/res/values-gd/strings.xml
+++ b/overlay/packages/apps/WallpaperPicker2/res/values-gd/strings.xml
@@ -100,7 +100,6 @@
     <string name="configure_wallpaper">Roghainnean…</string>
     <string name="delete_live_wallpaper">Sguab às</string>
     <string name="edit_live_wallpaper">Deasaich</string>
-    <string name="bottom_action_bar_back">Air ais</string>
     <string name="bottom_action_bar_edit">Deasaich</string>
     <string name="bottom_action_bar_download">Luchdaich a-nuas</string>
     <string name="bottom_action_bar_slideshow_wallpaper">Pàipear-balla de shleamhnagan</string>
diff --git a/overlay/packages/apps/WallpaperPicker2/res/values-kab-rDZ/strings.xml b/overlay/packages/apps/WallpaperPicker2/res/values-kab-rDZ/strings.xml
index 27ce289..4e4c3ef 100644
--- a/overlay/packages/apps/WallpaperPicker2/res/values-kab-rDZ/strings.xml
+++ b/overlay/packages/apps/WallpaperPicker2/res/values-kab-rDZ/strings.xml
@@ -33,7 +33,6 @@
     <string name="configure_wallpaper">Iɣewwaren...</string>
     <string name="delete_live_wallpaper">Mḥu</string>
     <string name="edit_live_wallpaper">Ẓreg</string>
-    <string name="bottom_action_bar_back">Ar deffir</string>
     <string name="bottom_action_bar_edit">Ẓreg</string>
     <string name="bottom_action_bar_download">Sider</string>
     <string name="bottom_action_bar_apply">Snes</string>
diff --git a/overlay/packages/inputmethods/LatinIME/java/res/values-ast-rES/strings.xml b/overlay/packages/inputmethods/LatinIME/java/res/values-ast-rES/strings.xml
deleted file mode 100644
index cf41dd5..0000000
--- a/overlay/packages/inputmethods/LatinIME/java/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-**
-** Copyright 2008, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="hint_add_to_dictionary">Volvi tocar pa guardar</string>
-    <string name="hint_add_to_dictionary_without_word">Toca equí pa guardar</string>
-    <string name="account_select_ok">D\'acuerdu</string>
-    <string name="user_dict_settings_add_dialog_confirm">D\'acuerdu</string>
-</resources>
diff --git a/overlay/packages/inputmethods/LatinIME/java/res/values-fur-rIT/strings-emoji-descriptions.xml b/overlay/packages/inputmethods/LatinIME/java/res/values-fur-rIT/strings-emoji-descriptions.xml
index 1971b90..ac34b41 100644
--- a/overlay/packages/inputmethods/LatinIME/java/res/values-fur-rIT/strings-emoji-descriptions.xml
+++ b/overlay/packages/inputmethods/LatinIME/java/res/values-fur-rIT/strings-emoji-descriptions.xml
@@ -819,7 +819,7 @@
   <string name="spoken_emoji_1F576">Ocjâi di soreli scûrs</string>
   <string name="spoken_emoji_1F577">Ragn</string>
   <string name="spoken_emoji_1F578">Tele di ragn</string>
-  <string name="spoken_emoji_1F579">Joystick</string>
+  <string name="spoken_emoji_1F579">Jeve di control</string>
   <string name="spoken_emoji_1F587">Grafetis colegadis</string>
   <string name="spoken_emoji_1F58A">Pene biro inclinade viers il bas a çampe</string>
   <string name="spoken_emoji_1F58B">Pene stilografiche inclinade viers il bas a çampe</string>
diff --git a/overlay/packages/inputmethods/LeanbackIME/res/values-ast-rES/strings.xml b/overlay/packages/inputmethods/LeanbackIME/res/values-ast-rES/strings.xml
deleted file mode 100644
index 5591d64..0000000
--- a/overlay/packages/inputmethods/LeanbackIME/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- Copyright 2019 The Android Open Source Project
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="ime_name">Tecláu <xliff:g id="app_name">Leanback</xliff:g></string>
-    <string name="ime_service_name">Tecláu <xliff:g id="app_name">Leanback</xliff:g></string>
-    <string name="word_separators">\u0020.,;:¡!¿?\n()[]*&amp;@{}/&lt;&gt;_+=|"«»</string>
-    <string name="label_go_key">Dir</string>
-    <string name="label_next_key">Siguiente</string>
-    <string name="label_send_key">Unviar</string>
-    <string name="label_search_key">Buscar</string>
-    <string name="label_done_key">Fecho</string>
-    <string name="settings_title">Opciones del tecláu</string>
-    <string name="title_movement_sensitivity">Sensibilidá al movimientu</string>
-    <string name="btn_on">Sí</string>
-    <string name="btn_off">Non</string>
-    <string name="keyboardview_keycode_space">Espaciu</string>
-    <string name="keyboardview_keycode_delete">Desaniciar</string>
-    <string name="keyboardview_keycode_mode_change">Cambéu de mou</string>
-    <string name="keyboardview_keycode_shift">Mayús</string>
-    <string name="keyboardview_keycode_caps">Bloq Mayús</string>
-    <string name="keyboardview_keycode_left">Esquierda</string>
-    <string name="keyboardview_keycode_right">Derecha</string>
-    <string name="keyboard_headset_required_to_hear_password">Conecta unos cascos pa sentir n\'alto les tecles de la contraseña.</string>
-    <string name="keyboard_password_character_no_headset">Puntu.</string>
-</resources>
diff --git a/overlay/packages/modules/Bluetooth/android/app/res/values-cy/strings.xml b/overlay/packages/modules/Bluetooth/android/app/res/values-cy/strings.xml
index 2113c29..f193edf 100644
--- a/overlay/packages/modules/Bluetooth/android/app/res/values-cy/strings.xml
+++ b/overlay/packages/modules/Bluetooth/android/app/res/values-cy/strings.xml
@@ -14,6 +14,7 @@
      limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_name">Bluetooth</string>
     <string name="permlab_bluetoothShareManager">Mynediad at y rheolwr lawrlwytho</string>
     <string name="permdesc_bluetoothShareManager">Mae\'n caniatáu yr ap i gael mynediad at reolwr BluetoothShare a\u2019i ddefnyddio i drosglwyddo ffeiliau.</string>
     <string name="permlab_bluetoothAcceptlist">Ychwanegu dyfais Bluetooth at restr derbyn.</string>
@@ -106,8 +107,8 @@
     <string name="outbound_noti_title">Rhannu Bluetooth: Ffeiliau a anfonwyd</string>
     <string name="inbound_noti_title">Rhannu Bluetooth: Ffeiliau wedi\'u derbyn</string>
     <string name="noti_caption_unsuccessful"> {count, plural,
-        =1    {# yn aflwyddiannus, %1$s}
-        other {# yn aflwyddiannus, %1$s}
+        =1    {# yn aflwyddiannus.}
+        other {# yn aflwyddiannus.}
         }
     </string>
     <string name="noti_caption_success"> {count, plural,
diff --git a/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings.xml b/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings.xml
index 881978b..de1ec9f 100644
--- a/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings.xml
@@ -14,6 +14,7 @@
      limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_name">Bluetooth</string>
     <string name="permlab_bluetoothShareManager">Acès al gjestôr dai discjariaments.</string>
     <string name="permdesc_bluetoothShareManager">Al permet ae aplicazions di acedi al
         gjestôr BluetoothShare e doprâlu par trasferî files. </string>
@@ -24,6 +25,7 @@
     <string name="bt_share_picker_label">Bluetooth</string>
     <string name="unknown_device">Dispositîf no cognossût</string>
     <string name="unknownNumber">No cognossût</string>
+    <string name="not_provided">No furnît</string>
     <string name="airplane_error_title">Modalitât avion</string>
     <string name="airplane_error_msg">No tu puedis doprâ il Bluetooth in modalitât avion.</string>
     <string name="bt_enable_line1">Par doprâ i servizis dal Bluetooth, prime tu âs di ativâ il Bluetooth.</string>
@@ -134,6 +136,9 @@
     <string name="bluetooth_opp_file_limit_exceeded">Nol è pussibil trasferî i files plui grancj di 4GB</string>
     <string name="bluetooth_connect_action">Conet al Bluetooth</string>
     <string name="bluetooth_enabled_apm_title">Bluetooth atîf in modalitât avion</string>
+    <string name="bluetooth_enabled_apm_message">Se tu tegnis impiât il Bluetooth, il dispositîf si impensarà di tignîlu impiât la prossime volte che tu sarâs in modalitât avion</string>
     <string name="bluetooth_stays_on_title">Il Bluetooth al reste atîf</string>
+    <string name="bluetooth_stays_on_message">Il dispositîf si impensarà di tignî il Bluetooth atîf in modalitât avion. Distude il Bluetooth se no tu desideris che al resti atîf.</string>
     <string name="bluetooth_and_wifi_stays_on_title">Il Wi-Fi e il Bluetooth a restin atîfs</string>
+    <string name="bluetooth_and_wifi_stays_on_message">Il dispositîf si impensarà di tignî Wi-Fi e Bluetooth atîfs in modalitât avion. Distude Wi-Fi e Bluetooth se no tu desideris che a restin atîfs.</string>
 </resources>
diff --git a/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings_pbap.xml b/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings_pbap.xml
index c68a550..b5d46ff 100644
--- a/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings_pbap.xml
+++ b/overlay/packages/modules/Bluetooth/android/app/res/values-fur-rIT/strings_pbap.xml
@@ -12,4 +12,6 @@
     <string name="localPhoneName">Gno non</string>
     <string name="defaultnumber">000000</string>
     <string name="pbap_notification_group">Condivision contat Bluetooth</string>
+    <string name="phonebook_advance_feature_support">Funzion avanzade de rubriche telefoniche supuartade</string>
+    <string name="repair_for_adv_phonebook_feature">Torne associe pe funzion di rubriche telefoniche avanzade</string>
 </resources>
diff --git a/overlay/packages/modules/CaptivePortalLogin/res/values-ast-rES/strings.xml b/overlay/packages/modules/CaptivePortalLogin/res/values-ast-rES/strings.xml
deleted file mode 100644
index 338c5db..0000000
--- a/overlay/packages/modules/CaptivePortalLogin/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="action_use_network">Usar esta rede tal cual</string>
-    <string name="action_do_not_use_network">Nun usar esta rede</string>
-    <string name="action_bar_label">Aniciu de sesión na rede</string>
-    <string name="action_bar_title">Anicia la sesión en: %1$s</string>
-    <string name="ssl_error_warning">La rede a la que tentes de xunite tien problemes de seguranza.</string>
-    <string name="ssl_error_example">Por exemplu, ye posible que la páxina d\'aniciu de sesión nun perteneza a la organización amosada.</string>
-    <string name="no_bypass_error_vpnwarning">Amás, nun ye posible evitar esti fallu porque\'l preséu ta usando una VPN.</string>
-    <string name="error_continue_via_browser">Siguir de toes toes pel restolador</string>
-    <string name="ssl_error_untrusted">Esti certificáu nun ye d\'una entidá d\'enfotu.</string>
-    <string name="ssl_error_mismatch">El nome del sitiu nun concasa col qu\'indica\'l certificáu.</string>
-    <string name="ssl_error_expired">Esti certificáu caducó.</string>
-    <string name="ssl_error_not_yet_valid">Esti certificáu entá nun ye válidu.</string>
-    <string name="ssl_error_date_invalid">Esti certificáu tien una data que nun ye válida.</string>
-    <string name="ssl_error_invalid">Esti certificáu nun ye válidu.</string>
-    <string name="ssl_error_unknown">Fallu de certificáu desconocíu.</string>
-    <string name="ssl_security_warning_title">Alvertencia de seguranza</string>
-    <string name="ssl_error_view_certificate">Ver el certificáu</string>
-    <string name="custom_scheme_warning">La rede a la que tentes de xunite solicita abrir otra aplicación.</string>
-    <string name="custom_scheme_example">Por exemplu, la páxina d\'aniciu de sesión pue riquir una aplicación específica pa l\'autenticación</string>
-    <string name="ok">D\'acuerdu</string>
-    <string name="page_info_address">Direición:</string>
-    <string name="page_info">Información de la páxina</string>
-    <string name="downloading_paramfile">Baxando «%1$s»</string>
-    <string name="download_completed">Completóse la descarga</string>
-    <string name="error_downloading_paramfile">Nun se pudo baxar «%1$s»</string>
-    <string name="channel_name_downloads">Descargues</string>
-    <string name="channel_description_downloads">Los avisos qu\'amuesen les descargues completaes o encaboxaes</string>
-    <string name="channel_name_download_progress">Progresu de les descargues</string>
-    <string name="channel_description_download_progress">Los avisos qu\'amuesen el progresu de les descargues de ficheros</string>
-</resources>
diff --git a/overlay/packages/modules/CaptivePortalLogin/res/values-fur-rIT/strings.xml b/overlay/packages/modules/CaptivePortalLogin/res/values-fur-rIT/strings.xml
index db7c6a9..633fa9a 100644
--- a/overlay/packages/modules/CaptivePortalLogin/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/modules/CaptivePortalLogin/res/values-fur-rIT/strings.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
+    <string name="app_name">Acès Portâl Sierât</string>
     <string name="action_use_network">Dopre cheste rêt cussì cemût che e je</string>
     <string name="action_do_not_use_network">No sta doprâ cheste rêt</string>
     <string name="action_bar_label">Jentre te rêt</string>
diff --git a/overlay/packages/modules/CellBroadcastService/res/values-ast-rES/strings.xml b/overlay/packages/modules/CellBroadcastService/res/values-ast-rES/strings.xml
deleted file mode 100644
index 218a846..0000000
--- a/overlay/packages/modules/CellBroadcastService/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2019 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="etws_primary_default_message_earthquake">Mantén la calma y busca refuxu cierca.</string>
-    <string name="etws_primary_default_message_tsunami">Marcha nel intre de les marines y les riberes, y busca llugares más seguros como terrenos elevaos.</string>
-    <string name="etws_primary_default_message_earthquake_and_tsunami">Mantén la calma y busca refuxu cierca.</string>
-    <string name="etws_primary_default_message_test">Prueba de mensaxes d\'emerxencia</string>
-    <string name="etws_primary_default_message_others">El gobiernu llocal emitió l\'alerta. Va dase más información próximamente .</string>
-</resources>
diff --git a/overlay/packages/modules/DeviceLock/DeviceLockController/res/values-fur-rIT/strings.xml b/overlay/packages/modules/DeviceLock/DeviceLockController/res/values-fur-rIT/strings.xml
new file mode 100644
index 0000000..2272b56
--- /dev/null
+++ b/overlay/packages/modules/DeviceLock/DeviceLockController/res/values-fur-rIT/strings.xml
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Copyright (c) 2022, The Android Open Source Project
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_name">ControlôrBlockDispositîf</string>
+    <string name="next_button">Indevant</string>
+    <string name="reset_button">Ristabilìs</string>
+    <string name="setup_more_button">Altri</string>
+    <string name="setup_info_title_text">Cemût che <xliff:g id="creditor_app">%1$s</xliff:g> al pues gjestî chest dispositîf</string>
+    <string name="setup_failed_title_text">Impussibil instalâ la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g></string>
+    <string name="setup_failed_reset_device_text">Daûr a ripristinâ il dispositîf par tornâ a provâ.</string>
+    <string name="setup_failed_reset_device_timer_text">        {count, plural,
+            one {}=1    {Ripristine chest dispositîf, dopo prove a configurâlu di gnûf. Si ripristinarà in automatic ca di 1 secont.}
+            other {Ripristine chest dispositîf, dopo prove a configurâlu di gnûf. Si ripristinarà in automatic ca di # seconts.}
+        }
+    </string>
+    <string name="setup_progress_title_text">Daûr a instalâ la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g><xliff:g id="ellipsis">\u2026</xliff:g></string>
+    <string name="setup_finish_title_text">Daûr a vierzi la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g><xliff:g id="ellipsis">\u2026</xliff:g></string>
+    <string name="setup_error_title_text">Impussibil vierzi la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g></string>
+    <string name="try_again">Torne prove</string>
+    <string name="reset_phone">Ripristine telefon</string>
+    <string name="control_section_title">Ce puedial fâ <xliff:g id="creditor_app">%1$s</xliff:g>\u003F</string>
+    <string name="control_lock_device_text">Limitâ chest dispositîf se no tu fasis un paiament</string>
+    <string name="control_download_text">Discjariâ, instalâ e inzornâ la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g></string>
+    <string name="control_disable_debug_text">Disativâ lis funzions di debug</string>
+    <string name="locked_section_title">Ce funzional se chest dispositîf al ven blocât\u003F</string>
+    <string name="locked_emergency_text">Servizis pes clamadis di emergjence</string>
+    <string name="locked_phone_usage_text">Clamadis in jentrade e cualchi clamade in jessude</string>
+    <string name="locked_settings_usage_text">Impostazions</string>
+    <string name="locked_backup_and_restore_text"><![CDATA[<a href="https://support.google.com/android/answer/2819582">Fâ il backup e a ripristinâ</a>]]> i tiei dâts</string>
+    <string name="exposure_section_title">Ce puedial viodi <xliff:g id="creditor_app">%1$s</xliff:g>\u003F</string>
+    <string name="exposure_install_text">Cuant che la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g> e ven instalade o disinstalade</string>
+    <string name="exposure_lock_unlock_text">Dutis lis richiestis di bloc o sbloc di <xliff:g id="creditor_app">%1$s</xliff:g></string>
+    <string name="exposure_disable_dlc_text">Se la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g> no je disponibile</string>
+    <string name="open_source_licenses">Licencis di codiç viert</string>
+    <string name="footer_notice_content_description">Lis funzionalitâts di gjestion te sezion dal dispositîf finanziât des impostazions di Sigurece no si aplichin a chest dispositîf.</string>
+    <string name="device_provided_by_provider">Chest dispositîf al è furnît di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="download_kiosk_app">La aplicazion Kiosk e vignarà discjariade e instalade in automatic</string>
+    <string name="install_kiosk_app_secondary_user">La aplicazion Kiosk e vignarà instalade par chest utent</string>
+    <string name="restrict_device_if_dont_make_payment"><xliff:g id="provider name">%1$s</xliff:g> al pues limitâ chest dispositîf se no tu fasis i paiaments necessaris. Pai detais, viôt i <xliff:g id="terms_and_conditions_link_start">&lt;a href=\"%2$s\"&gt;</xliff:g>Tiermins e condizions<xliff:g id="terms_and_conditions_link_end">&lt;/a&gt;</xliff:g>.</string>
+    <string name="previous">Indaûr</string>
+    <string name="next">Indevant</string>
+    <string name="start">Scomence</string>
+    <string name="ok">Va ben</string>
+    <string name="done">Fat</string>
+    <string name="do_it_in_one_hour">Fasilu ca di 1 ore</string>
+    <string name="header_icon_content_description">Informazions</string>
+    <string name="provision_info_item_icon_content_description">Informazions di furniment</string>
+    <string name="enroll_your_device_header">Regjistre il to dispositîf</string>
+    <string name="enroll_your_device_subsidy_subheader">Cumò tu puedis regjistrâ il to dispositîf tal program di sussidi di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="subsidy_program_header">Tu stâs partecipant al program di sussidi di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="device_enrollment_header_text">Regjistrazion dispositîf</string>
+    <string name="device_financing_enrollment_body_text">Il to dispositîf al vignarà regjistrât tal program di finanziament di <xliff:g id="provider name">%1$s</xliff:g> dentri di 30 dîs</string>
+    <string name="device_subsidy_enrollment_body_text">Il to dispositîf al vignarà regjistrât tal program di sussidi di <xliff:g id="provider name">%1$s</xliff:g> dentri di 30 dîs</string>
+    <string name="device_enrollment_notification_body_text">La regjistrazion e continuarà aes <xliff:g id="time">%1$s</xliff:g>. Tu puedis continuâ a doprâ il to dispositîf. </string>
+    <string name="continue_using_device">Tu puedis continuâ a doprâ il to dispositîf</string>
+    <string name="device_paid">Il dispositîf al è stât paiât</string>
+    <string name="device_removed_from_subsidy_program">Dispositîf gjavât dal program di sussidi di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="device_removed_from_finance_program">Il to dispositîf al è stât gjavât dal program di finanziament di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="restrictions_lifted">Dutis lis limitazions sul to dispositîf a son stadis gjavadis</string>
+    <string name="uninstall_kiosk_app">Tu puedis disinstalâ la aplicazion Kiosk dal to dispositîf</string>
+    <string name="getting_device_ready">Daûr a prontâ il to dispositîf…</string>
+    <string name="this_may_take_a_few_minutes">Chest al po puartâ vie un pôcs di minûts</string>
+    <string name="installing_kiosk_app">Daûr a instalâ la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g>…</string>
+    <string name="opening_kiosk_app">Daûr a vierzi la aplicazion <xliff:g id="creditor_app">%1$s</xliff:g>…</string>
+    <string name="settings_banner_title">Dispositîf furnît di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="settings_banner_body"><xliff:g id="provider name">%1$s</xliff:g> al pues cambiâ lis impostazions su chest dispositîf</string>
+    <string name="settings_banner_button">Plui informazions</string>
+    <string name="settings_screen_title">Informazions sul dispositîf finanziât</string>
+    <string name="settings_intro_preference_key">settings_intro_preference_key</string>
+    <string name="settings_restrictions_category">Fintant che no tu âs paiât il to dispositîf, no tu puedis:</string>
+    <string name="settings_restrictions_category_preference_key">settings_restrictions_category_preference_key</string>
+    <string name="settings_install_apps">Instalâ aplicazions che a rivin di difûr dal Play Store</string>
+    <string name="settings_install_apps_preference_key">settings_install_apps_preference_key</string>
+    <string name="settings_safe_mode">Tornâ a inviâ il dispositîf in modalitât sigure</string>
+    <string name="settings_safe_mode_preference_key">settings_safe_mode_preference_key</string>
+    <string name="settings_developer_options">Doprâ opzions svilupadôr</string>
+    <string name="settings_developer_options_preference_key">settings_developer_options_preference_key</string>
+    <string name="settings_credit_provider_capabilities_category">Se alc al va strucj cul to dispositîf, <xliff:g id="provider name">%1$s</xliff:g> al pues:</string>
+    <string name="settings_credit_provider_capabilities_category_preference_key">settings_credit_provider_capabilities_category_preference_key</string>
+    <string name="settings_IMEI">Acedi al to numar IMEI</string>
+    <string name="settings_IMEI_preference_key">settings_IMEI_preference_key</string>
+    <string name="settings_factory_reset">Azerâ il dispositîf ai dâts di fabriche</string>
+    <string name="settings_factory_reset_preference_key">settings_factory_reset_preference_key</string>
+    <string name="settings_locked_mode_category">Se il to dispositîf al è limitât, tu puedis doprâlu dome par:</string>
+    <string name="settings_locked_mode_category_preference_key">settings_locked_mode_category_preference_key</string>
+    <string name="settings_emergency_calls">Fâ clamadis a numars di emergjence</string>
+    <string name="settings_emergency_calls_preference_key">settings_emergency_calls_preference_key</string>
+    <string name="settings_system_info">Viodi informazions di sisteme come date, ore, stât de rêt e batarie</string>
+    <string name="settings_system_info_preference_key">settings_system_info_preference_key</string>
+    <string name="settings_turn_on_off_device">Impiâ o distudâ il dispositîf</string>
+    <string name="settings_turn_on_off_device_preference_key">settings_turn_on_off_device_preference_key</string>
+    <string name="settings_notifications">Viodi notifichis e messaçs di test</string>
+    <string name="settings_notifications_preference_key">settings_notifications_preference_key</string>
+    <string name="settings_allowlisted_apps">Acedi a aplicazions consintudis di <xliff:g id="provider name">%1$s</xliff:g></string>
+    <string name="settings_allowlisted_apps_preference_key">settings_allowlisted_apps_preference_key</string>
+    <string name="settings_fully_paid_category">Une volte paiât dut l\'impuart:</string>
+    <string name="settings_fully_paid_category_preference_key">settings_fully_paid_category_preference_key</string>
+    <string name="settings_restrictions_removed"><xliff:g id="provider name">%1$s</xliff:g> nol podarà limitâ il dispositîf o cambiâi lis impostazions</string>
+    <string name="settings_restrictions_removed_preference_key">settings_restrictions_removed_preference_key</string>
+    <string name="settings_uninstall_kiosk_app">Tu puedis disinstalâ la aplicazion <xliff:g id="kiosk_app">%1$s</xliff:g></string>
+    <string name="settings_uninstall_kiosk_app_preference_key">settings_uninstall_kiosk_app_preference_key</string>
+    <string name="provision_notification_channel_name">Furnidure</string>
+    <string name="device_reset_in_days_notification_title">        {count, plural,
+            one {}=1    {Il dispositîf si azerarà ca di 1 dì}
+            other {Il dispositîf si azerarà ca di # dîs}
+        }
+    </string>
+    <string name="device_reset_notification_content">A vignaran eliminâts ducj i dâts dal dispositîf. Par jutori tal regjistrâ il to dispositîf, contate <xliff:g id="provider name">%1$s</xliff:g></string>
+</resources>
diff --git a/overlay/packages/modules/HealthFitness/apk/res/values-fur-rIT/strings.xml b/overlay/packages/modules/HealthFitness/apk/res/values-fur-rIT/strings.xml
new file mode 100644
index 0000000..75db749
--- /dev/null
+++ b/overlay/packages/modules/HealthFitness/apk/res/values-fur-rIT/strings.xml
@@ -0,0 +1,782 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Copyright (C) 2022 The Android Open Source Project
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_label" description="Label shown on the system app launcher. Note: Health Connect is the brand. [CHAR_LIMIT=40]">Conession salût</string>
+    <string name="health_connect_summary" description="Health connect summary, which describes what user can do when they click Health Connect">Gjestìs l\'acès de aplicazion ai dâts su la salût</string>
+    <string name="permissions_and_data_header" description="Header for section listing actions for showing connected apps permissions and data screens [CHAR LIMIT=NONE] ">Permès e dâts</string>
+    <string name="home_subtitle" description="Description on the home screen of the app. [CHAR_LIMIT=NONE]">Gjestìs i dâts de salût e de forme fisiche sul to telefon e controle cualis aplicazions che ju doprin</string>
+    <string name="data_title" description="Label for a button that takes the user to the data management screens. [CHAR_LIMIT=40]">Dâts e acès</string>
+    <string name="all_categories_title" description="Title of a screen that lists all health data categories. [CHAR_LIMIT=40]">Dutis lis categoriis</string>
+    <string name="see_all_categories" description="Label for a button that takes the user to the all categories screens. [CHAR_LIMIT=40]">Viôt dutis lis categoriis</string>
+    <string name="no_data" description="Label that is displayed when the given health data category does not have any data.">Nissun dât</string>
+    <string name="connected_apps_title" description="Label for a button that takes the user to the connected apps' permissions screens. [CHAR_LIMIT=40]">Permès des aplicazions</string>
+    <string name="connected_apps_subtitle" description="Description for a button that takes the user to the connected apps' permissions screens. [CHAR_LIMIT=NONE]">Gjestìs lis aplicazions e i permès</string>
+    <string name="connected_apps_button_subtitle" description="Description for a button that takes the user to the connected apps' permissions screens. [CHAR_LIMIT=NONE]"><xliff:g id="num_apps_connected" example="1">%1$s</xliff:g> di <xliff:g id="num_possible_apps" example="3">%2$s</xliff:g> aplicazions a àn acès</string>
+    <string name="connected_apps_all_apps_connected_subtitle" description="Description for a button that takes the user to the connected apps' permissions screens when all possible apps are connected. [CHAR_LIMIT=NONE]"><xliff:g id="num_apps_connected" example="1">%1$s</xliff:g> aplicazions a àn acès</string>
+    <string name="connected_apps_one_app_connected_subtitle" description="Description for a button that takes the user to the connected apps' permissions screens with one app connected. [CHAR_LIMIT=NONE]"><xliff:g id="num_apps_connected" example="1">%1$s</xliff:g> aplicazion e à acès</string>
+    <string name="connected_apps_button_no_permissions_subtitle" description="Description for a button that takes the user to the connected apps' permissions screens, when no apps are connected. [CHAR_LIMIT=NONE]">Nissun</string>
+    <string name="entry_details_title" description="Label for a screen that list an entry details. [CHAR_LIMIT=40]">Detais de vôs</string>
+    <string name="recent_access_header" description="Header for section showing apps that have recently accessed health data [CHAR_LIMIT=NONE]">Acès resint</string>
+    <string name="no_recent_access" description="Header for section showing apps that have recently accessed health data [CHAR_LIMIT=NONE]">Nissune aplicazion e à doprât Conession salût di resint</string>
+    <string name="show_recent_access_entries_button_title" description="Label on a button leading to another screen showing all the writes and reads performed by connected apps in the last 24 hours. [CHAR LIMIT=50]">Viôt ducj i acès resints</string>
+    <string name="recent_access_screen_description" description="Description of Recent access screen, placed at the top. [CHAR LIMIT=NONE]">Viôt lis aplicazoins che a àn vût acès ai tiei dâts tes ultimis 24 oris</string>
+    <string name="today_header" description="Header in the list of data access entries to differentiate between entries from today and yesterday. [CHAR LIMIT=50]">Vuê</string>
+    <string name="yesterday_header" description="Header in the list of data access entries to differentiate between entries from today and yesterday. [CHAR LIMIT=50]">Îr</string>
+    <string name="read_data_access_label" description="Label used to indicate that app performed read access to specified data types (as opposed to writing the data), as in 'Read: Steps, Heart rate'. [CHAR_LIMIT=NONE]">Leture: %s</string>
+    <string name="write_data_access_label" description="Label used to indicate that app performed write (insertion, deletion or update) access to specified data types (as opposed to reading the data), as in 'Write: Steps, Heart rate'. [CHAR_LIMIT=NONE]">Scriture: %s</string>
+    <string name="data_type_separator" description="Separator (comma and whitespace in English) for a potentially long list of data type names listed in data access entry, as in 'Write: Steps, Distance, Calories'. [CHAR_LIMIT=NONE]">,\u0020</string>
+    <string name="manage_permissions" description="Text for floating action button that takes users from Recent Access apps to the App permissions screen [CHAR LIMIT=40]">Gjestìs i permès</string>
+    <string name="activity_category_uppercase" description="Uppercase name for activity category, displaying user data related to activities (such as active time, calories burned, etc.) [CHAR LIMIT=30]">Ativitâts</string>
+    <string name="activity_category_lowercase" description="Lowercase name for activity category, displaying user data related to activities (such as active time, calories burned, etc.) [CHAR LIMIT=30]">ativitâts</string>
+    <string name="body_measurements_category_uppercase" description="Uppercase name for body measurements category, displaying user data related to body measurements (such as height, weight, etc.) [CHAR LIMIT=30]">Misurazions dal cuarp</string>
+    <string name="body_measurements_category_lowercase" description="Lowercase name for body measurements category, displaying user data related to body measurements (such as height, weight, etc.) [CHAR LIMIT=30]">misurazions dal cuarp</string>
+    <string name="sleep_category_uppercase" description="Uppercase name for sleep category, displaying user data related to sleep (such as sleep duration, bedtime schedule, etc.) [CHAR LIMIT=30]">Polse</string>
+    <string name="sleep_category_lowercase" description="Lowercase name for sleep category, displaying user data related to sleep (such as sleep duration, bedtime schedule, etc.) [CHAR LIMIT=30]">polse</string>
+    <string name="vitals_category_uppercase" description="Uppercase name for vitals category, displaying user data related to vitals (such as heart rate, blood pressure, etc.) [CHAR LIMIT=30]">Orghins vitâi</string>
+    <string name="vitals_category_lowercase" description="Lowercase name for vitals category, displaying user data related to vitals (such as heart rate, blood pressure, etc.) [CHAR LIMIT=30]">orghins vitâi</string>
+    <string name="cycle_tracking_category_uppercase" description="Uppercase name for cycle tracking category, displaying user data related to cycle tracking (such as cervical mucus, menstrual flow, etc.) [CHAR LIMIT=30]">Monitorament ciclic</string>
+    <string name="cycle_tracking_category_lowercase" description="Lowercase name for cycle tracking category, displaying user data related to cycle tracking (such as cervical mucus, menstrual flow, etc.) [CHAR LIMIT=30]">monitorament ciclic</string>
+    <string name="nutrition_category_uppercase" description="Uppercase name for nutrition category, displaying user data related to nutrition (such as calories consumed, hydration, etc.) [CHAR LIMIT=30]">Nutrizion</string>
+    <string name="nutrition_category_lowercase" description="Lowercase name for nutrition category, displaying user data related to nutrition (such as calories consumed, hydration, etc.) [CHAR LIMIT=30]">nutrizion</string>
+    <string name="browse_data_category" description="Uppercase name for a section that contains user data grouped by categories. [CHAR_LIMIT=50]">Esplore dâts</string>
+    <string name="manage_data_section" description="Uppercase name for a section that has different user actions like deleting data. [CHAR_LIMIT=50]">Gjestìs dâts</string>
+    <string name="export_data_button" description="Uppercase name for a button that allows a user to export their data. [CHAR_LIMIT=50]">Espuarte dâts</string>
+    <string name="delete_all_data_button" description="Uppercase name for a button that allows deleting all data points. [CHAR_LIMIT=50]">Elimine ducj i dâts</string>
+    <string name="no_categories" description="Label that shows when health connect does not have data. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]">No tu âs dâts in Conession salût</string>
+    <string name="permission_types_title" description="Title of screen for a user to manage their health and fitness data [CHAR_LIMIT=40]">I tiei dâts</string>
+    <string name="app_priority_button" description="Label for a button that opens the app priority settings screen where users can set which app should have higher priority. [CHAR_LIMIT=50]">Prioritât aplicazion</string>
+    <string name="delete_category_data_button" description="Label for a button that allows deleting all data points from a given health data category. [CHAR_LIMIT=50]">Elimine dâts di <xliff:g id="category" example="activity">%s</xliff:g></string>
+    <string name="select_all_apps_title" description="Title shown for clearing filters. [CHAR_LIMIT=40]">Dutis lis aplicazions</string>
+    <string name="can_read" description="Section title that refers to apps with read permission for given permission type. [CHAR_LIMIT=50]">Al pues lei <xliff:g id="permission_type" example="heart rate">%s</xliff:g></string>
+    <string name="can_write" description="Section title that refers to apps with write permission for given permission type. [CHAR_LIMIT=50]">Al pues scrivi <xliff:g id="permission_type" example="heart rate">%s</xliff:g></string>
+    <string name="inactive_apps" description="Section title that refers to apps that are inactive in Health Connect. [CHAR_LIMIT=50]">Aplicazions inativis</string>
+    <string name="inactive_apps_message" description="Description of the inactive apps section. [CHAR_LIMIT=NONE]">Chestis aplicazions no puedin plui scrivi <xliff:g id="data_type" example="heart rate">%s</xliff:g>, ma a puedin ancjemò vê dâts archiviâts in Conession salût</string>
+    <string name="data_access_empty_message" description="Message shown if there is no app to display on this page [CHAR_LIMIT=NONE]">Lis aplicazions no puedin plui lei o scrivi <xliff:g id="data_type" example="heart rate">%1$s</xliff:g> e no son plui presints dâts di <xliff:g id="data_type_2" example="heart rate">%2$s</xliff:g> archiviâts in Conession salût</string>
+    <string name="data_access_exercise_description" description="Description of data access for the exercise data type [CHAR_LIMIT=NONE]">Chescj dâts a includin informazions come timp in ativitât, gjenar di esercizis, zîrs, ripetizions, sessions o braçadis nadant</string>
+    <string name="data_access_sleep_description" description="Description of data access for the sleep data type [CHAR_LIMIT=NONE]">Chescj dâts a includin informazions come lis fasis di polse e lis sessions di polse</string>
+    <string name="all_entries_button" description="Label for a button that opens the Data entries page. [CHAR_LIMIT=50]">Viôt dutis lis vôs</string>
+    <string name="delete_permission_type_data_button" description="Label for a button that allows deleting all data points from a given health permission type. [CHAR_LIMIT=50]">Elimine chest dât</string>
+    <string name="permgrouplab_health" description="Title of an application permission group, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=30]">Conession salût</string>
+    <string name="permgroupdesc_health" description="Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=100]">acedi ai tiei dâts su la salût</string>
+    <string name="permlab_readCaloriesBurned" description="Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=30]">Lei lis caloriis brusadis</string>
+    <string name="permdesc_readCaloriesBurned" description="Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=100]">Al permet ae aplicazion di lei lis caloriis brusadis</string>
+    <string name="active_calories_burned_uppercase_label" description="Uppercase label used to show the user's active calories burned data [CHAR_LIMIT=50]">Caloriis ativis brusadis</string>
+    <string name="active_calories_burned_lowercase_label" description="Lowercase label used to show the user's active calories burned data [CHAR_LIMIT=50]">caloriis ativis brusadis</string>
+    <string name="active_calories_burned_read_content_description" description="Content description for switch that enables permissions for reading the user's active calories burned data [CHAR_LIMIT=NONE]">Lei lis caloriis ativis brusadis</string>
+    <string name="active_calories_burned_write_content_description" description="Content description for switch that enables permissions for writing the user's active calories burned data [CHAR_LIMIT=NONE]">Scrivi lis caloriis ativis brusadis</string>
+    <string name="exercise_uppercase_label" description="Uppercase label used to show the user's exercise data [CHAR_LIMIT=50]">Esercizi</string>
+    <string name="exercise_lowercase_label" description="Lowercase label used to show the user's exercise data [CHAR_LIMIT=50]">esercizi</string>
+    <string name="exercise_read_content_description" description="Content description for switch that enables permissions for reading the user's exercise data [CHAR_LIMIT=NONE]">Lei esercizi</string>
+    <string name="exercise_write_content_description" description="Content description for switch that enables permissions for writing the user's exercise data [CHAR_LIMIT=NONE]">Scrivi esercizi</string>
+    <string name="exercise_route_uppercase_label" description="Uppercase label used to show the user's exercise route [CHAR_LIMIT=50]">Percors di esercizi</string>
+    <string name="exercise_route_lowercase_label" description="Lowercase label used to show the user's exercise route [CHAR_LIMIT=50]">percors di esercizi</string>
+    <string name="exercise_route_write_content_description" description="Content description for switch that enables permissions for writing the user's exercise route [CHAR_LIMIT=NONE]">Scrivi il percors di esercizi</string>
+    <string name="exercise_route_read_content_description" description="Content description for switch that enables permissions for reading the user's exercise route [CHAR_LIMIT=NONE]">Lei il percors di esercizi</string>
+    <string name="distance_uppercase_label" description="Uppercase label used to show the user's distance data [CHAR_LIMIT=50]">Distance</string>
+    <string name="distance_lowercase_label" description="Lowercase label used to show the user's distance data [CHAR_LIMIT=50]">distance</string>
+    <string name="distance_read_content_description" description="Content description for switch that enables permissions for reading the user's distance data [CHAR_LIMIT=NONE]">Lei la distance</string>
+    <string name="distance_write_content_description" description="Content description for switch that enables permissions for writing the user's distance data [CHAR_LIMIT=NONE]">Scrivi la distance</string>
+    <string name="elevation_gained_uppercase_label" description="Uppercase label used to show the user's elevation gained data [CHAR_LIMIT=50]">Cuote vuadagnade</string>
+    <string name="elevation_gained_lowercase_label" description="Lowercase label used to show the user's elevation gained data [CHAR_LIMIT=50]">cuote vuadagnade</string>
+    <string name="elevation_gained_read_content_description" description="Content description for switch that enables permissions for reading the user's elevation gained data [CHAR_LIMIT=NONE]">Lei la cuote vuadagnade</string>
+    <string name="elevation_gained_write_content_description" description="Content description for switch that enables permissions for writing the user's elevation gained data [CHAR_LIMIT=NONE]">Scrivi la cuote vuadagnade</string>
+    <string name="floors_climbed_uppercase_label" description="Uppercase label used to show the user's floors climbed data [CHAR_LIMIT=50]">Plans lant insù</string>
+    <string name="floors_climbed_lowercase_label" description="Lowercase label used to show the user's floors climbed data [CHAR_LIMIT=50]">plans lant insù</string>
+    <string name="floors_climbed_read_content_description" description="Content description for switch that enables permissions for reading the user's floors climbed data [CHAR_LIMIT=NONE]">Lei i plans fats lant insù</string>
+    <string name="floors_climbed_write_content_description" description="Content description for switch that enables permissions for writing the user's floors climbed data [CHAR_LIMIT=NONE]">Scrivi i plans fats lant insù</string>
+    <string name="power_uppercase_label" description="Uppercase label used to show the user's power data [CHAR_LIMIT=50]">Potence</string>
+    <string name="power_lowercase_label" description="Lowercase label used to show the user's power data [CHAR_LIMIT=50]">potence</string>
+    <string name="power_read_content_description" description="Content description for switch that enables permissions for reading the user's power data [CHAR_LIMIT=NONE]">Lei la potence</string>
+    <string name="power_write_content_description" description="Content description for switch that enables permissions for writing the user's power data [CHAR_LIMIT=NONE]">Scrivi la potence</string>
+    <string name="speed_uppercase_label" description="Uppercase label used to show the user's speed data [CHAR_LIMIT=50]">Velocitât</string>
+    <string name="speed_lowercase_label" description="Lowercase label used to show the user's speed data [CHAR_LIMIT=50]">velocitât</string>
+    <string name="speed_read_content_description" description="Content description for switch that enables permissions for reading the user's speed data [CHAR_LIMIT=NONE]">Lei la velocitât</string>
+    <string name="speed_write_content_description" description="Content description for switch that enables permissions for writing the user's speed data [CHAR_LIMIT=NONE]">Scrivi la velocitât</string>
+    <string name="steps_uppercase_label" description="Uppercase label used to show the user's steps data [CHAR_LIMIT=50]">Pas</string>
+    <string name="steps_lowercase_label" description="Lowercase label used to show the user's steps data [CHAR_LIMIT=50]">pas</string>
+    <string name="steps_read_content_description" description="Content description for switch that enables permissions for reading the user's steps data [CHAR_LIMIT=NONE]">Lei i pas</string>
+    <string name="steps_write_content_description" description="Content description for switch that enables permissions for writing the user's steps data [CHAR_LIMIT=NONE]">Scrivi i pas</string>
+    <string name="total_calories_burned_uppercase_label" description="Uppercase label used to show the user's total calories burned data [CHAR_LIMIT=50]">Caloriis totâls brusadis</string>
+    <string name="total_calories_burned_lowercase_label" description="Lowercase label used to show the user's total calories burned data [CHAR_LIMIT=50]">caloriis totâls brusadis</string>
+    <string name="total_calories_burned_read_content_description" description="Content description for switch that enables permissions for reading the user's total calories burned data [CHAR_LIMIT=NONE]">Lei lis caloriis totâls brusadis</string>
+    <string name="total_calories_burned_write_content_description" description="Content description for switch that enables permissions for writing the user's total calories burned data [CHAR_LIMIT=NONE]">Scrivi lis caloriis totâls brusadis</string>
+    <string name="vo2_max_uppercase_label" description="Uppercase label used to show the user's V02 max data [CHAR_LIMIT=50]">VO2 max</string>
+    <string name="vo2_max_lowercase_label" description="Lowercase label used to show the user's V02 max data [CHAR_LIMIT=50]">VO2 max</string>
+    <string name="vo2_max_read_content_description" description="Content description for switch that enables permissions for reading the user's V02 max data [CHAR_LIMIT=NONE]">Lei il VO2 massim</string>
+    <string name="vo2_max_write_content_description" description="Content description for switch that enables permissions for writing the user's V02 max data [CHAR_LIMIT=NONE]">Scrivi il VO2 massim</string>
+    <string name="wheelchair_pushes_uppercase_label" description="Uppercase label used to show the user's wheelchair pushes data [CHAR_LIMIT=50]">Sburtadis di carocele</string>
+    <string name="wheelchair_pushes_lowercase_label" description="Lowercase label used to show the user's wheelchair pushes data [CHAR_LIMIT=50]">sburtadis di carocele</string>
+    <string name="wheelchair_pushes_read_content_description" description="Content description for switch that enables permissions for reading the user's wheelchair pushes data [CHAR_LIMIT=NONE]">Lei lis sburtadis di carocele</string>
+    <string name="wheelchair_pushes_write_content_description" description="Content description for switch that enables permissions for writing the user's wheelchair pushes data [CHAR_LIMIT=NONE]">Scrivi lis sburtadis di carocele</string>
+    <string name="basal_metabolic_rate_uppercase_label" description="Uppercase label used to show the user's basal metabolic rate data [CHAR_LIMIT=50]">Tas metabolic basâl</string>
+    <string name="basal_metabolic_rate_lowercase_label" description="Lowercase label used to show the user's basal metabolic rate data [CHAR_LIMIT=50]">tas metabolic basâl</string>
+    <string name="basal_metabolic_rate_read_content_description" description="Content description for switch that enables permissions for reading the user's basal metabolic rate data [CHAR_LIMIT=NONE]">Lei il tas metabolic basâl</string>
+    <string name="basal_metabolic_rate_write_content_description" description="Content description for switch that enables permissions for writing the user's basal metabolic rate data [CHAR_LIMIT=NONE]">Scrivi il tas metabolic basâl</string>
+    <string name="body_fat_uppercase_label" description="Uppercase label used to show the user's body fat data [CHAR_LIMIT=50]">Gras corpori</string>
+    <string name="body_fat_lowercase_label" description="Lowercase label used to show the user's body fat data [CHAR_LIMIT=50]">gras corpori</string>
+    <string name="body_fat_read_content_description" description="Content description for switch that enables permissions for reading the user's body fat data [CHAR_LIMIT=NONE]">Lei il gras corpori</string>
+    <string name="body_fat_write_content_description" description="Content description for switch that enables permissions for writing the user's body fat data [CHAR_LIMIT=NONE]">Scrivi il gras corpori</string>
+    <string name="body_water_mass_uppercase_label" description="Uppercase label used to show the user's body water mass data [CHAR_LIMIT=50]">Masse di aghe dal cuarp</string>
+    <string name="body_water_mass_lowercase_label" description="Lowercase label used to show the user's body water mass data [CHAR_LIMIT=50]">masse di aghe dal cuarp</string>
+    <string name="body_water_mass_read_content_description" description="Content description for switch that enables permissions for reading the user's body water mass data [CHAR_LIMIT=NONE]">Lei la masse di aghe dal cuarp</string>
+    <string name="body_water_mass_write_content_description" description="Content description for switch that enables permissions for writing the user's body water mass data [CHAR_LIMIT=NONE]">Scrivi la masse di aghe dal cuarp</string>
+    <string name="bone_mass_uppercase_label" description="Uppercase label used to show the user's bone mass data [CHAR_LIMIT=50]">Masse dai vues</string>
+    <string name="bone_mass_lowercase_label" description="Lowercase label used to show the user's bone mass data [CHAR_LIMIT=50]">masse dai vues</string>
+    <string name="bone_mass_read_content_description" description="Content description for switch that enables permissions for reading the user's bone mass data [CHAR_LIMIT=NONE]">Lei la masse dai vues</string>
+    <string name="bone_mass_write_content_description" description="Content description for switch that enables permissions for writing the user's bone mass data [CHAR_LIMIT=NONE]">Scrivi la masse dai vues</string>
+    <string name="height_uppercase_label" description="Uppercase label used to show the user's height data [CHAR_LIMIT=50]">Altece</string>
+    <string name="height_lowercase_label" description="Lowercase label used to show the user's height data [CHAR_LIMIT=50]">altece</string>
+    <string name="height_read_content_description" description="Content description for switch that enables permissions for reading the user's height data [CHAR_LIMIT=NONE]">Lei la altece</string>
+    <string name="height_write_content_description" description="Content description for switch that enables permissions for writing the user's height data [CHAR_LIMIT=NONE]">Scrivi la altece</string>
+    <string name="hip_circumference_uppercase_label" description="Uppercase label used to show the user's hip circumference data [CHAR_LIMIT=50]">Circonference dal ombul</string>
+    <string name="hip_circumference_lowercase_label" description="Lowercase label used to show the user's hip circumference data [CHAR_LIMIT=50]">circonference dal ombul</string>
+    <string name="hip_circumference_read_content_description" description="Content description for switch that enables permissions for reading the user's hip circumference data [CHAR_LIMIT=NONE]">Lei la circonference dal ombul</string>
+    <string name="hip_circumference_write_content_description" description="Content description for switch that enables permissions for writing the user's hip circumference data [CHAR_LIMIT=NONE]">Scrivi la circonference dal ombul</string>
+    <string name="lean_body_mass_uppercase_label" description="Uppercase label used to show the user's lean body mass data [CHAR_LIMIT=50]">Masse dal cuarp magre</string>
+    <string name="lean_body_mass_lowercase_label" description="Lowercase label used to show the user's lean body mass data [CHAR_LIMIT=50]">masse dal cuarp magre</string>
+    <string name="lean_body_mass_read_content_description" description="Content description for switch that enables permissions for reading the user's lean body mass data [CHAR_LIMIT=NONE]">Lei la masse magre dal cuarp</string>
+    <string name="lean_body_mass_write_content_description" description="Content description for switch that enables permissions for writing the user's lean body mass data [CHAR_LIMIT=NONE]">Scrivi la masse magre dal cuarp</string>
+    <string name="waist_circumference_uppercase_label" description="Uppercase label used to show the user's waist circumference data [CHAR_LIMIT=50]">Circonference de vite</string>
+    <string name="waist_circumference_lowercase_label" description="Lowercase label used to show the user's waist circumference data [CHAR_LIMIT=50]">circonference de vite</string>
+    <string name="waist_circumference_read_content_description" description="Content description for switch that enables permissions for reading the user's waist circumference data [CHAR_LIMIT=NONE]">Lei la circonference de vite</string>
+    <string name="waist_circumference_write_content_description" description="Content description for switch that enables permissions for writing the user's waist circumference data [CHAR_LIMIT=NONE]">Scrivi la circonference de vite</string>
+    <string name="weight_uppercase_label" description="Uppercase label used to show the user's weight data [CHAR_LIMIT=50]">Pês</string>
+    <string name="weight_lowercase_label" description="Lowercase label used to show the user's weight data [CHAR_LIMIT=50]">pês</string>
+    <string name="weight_read_content_description" description="Content description for switch that enables permissions for reading the user's weight data [CHAR_LIMIT=NONE]">Lei il pês</string>
+    <string name="weight_write_content_description" description="Content description for switch that enables permissions for writing the user's weight data [CHAR_LIMIT=NONE]">Scrivi il pês</string>
+    <string name="cervical_mucus_uppercase_label" description="Uppercase label used to show the user's cervical mucus data [CHAR_LIMIT=50]">Muc cervicâl</string>
+    <string name="cervical_mucus_lowercase_label" description="Lowercase label used to show the user's cervical mucus data [CHAR_LIMIT=50]">muc cervicâl</string>
+    <string name="cervical_mucus_read_content_description" description="Content description for switch that enables permissions for reading the user's cervical mucus data [CHAR_LIMIT=NONE]">Lei il muc cervicâl</string>
+    <string name="cervical_mucus_write_content_description" description="Content description for switch that enables permissions for writing the user's cervical mucus data [CHAR_LIMIT=NONE]">Scrivi il muc cervicâl</string>
+    <string name="intermenstrual_bleeding_uppercase_label" description="Uppercase label used to show the user's intermenstrual bleeding data [CHAR_LIMIT=50]">Sanganament intermestruâl</string>
+    <string name="intermenstrual_bleeding_lowercase_label" description="Lowercase label used to show the user's intermenstrual bleeding data [CHAR_LIMIT=50]">sanganament intermestruâl</string>
+    <string name="intermenstrual_bleeding_read_content_description" description="Content description for switch that enables permissions for reading the user's intermenstrual bleeding data [CHAR_LIMIT=NONE]">Lei il sanganament intermestruâl</string>
+    <string name="intermenstrual_bleeding_write_content_description" description="Content description for switch that enables permissions for writing the user's intermenstrual bleeding data [CHAR_LIMIT=NONE]">Scrivi il sanganament intermestruâl</string>
+    <string name="menstruation_uppercase_label" description="Uppercase label used to show the user's menstruation data [CHAR_LIMIT=50]">Mestruazion</string>
+    <string name="menstruation_lowercase_label" description="Lowercase label used to show the user's menstruation data [CHAR_LIMIT=50]">mestruazion</string>
+    <string name="menstruation_read_content_description" description="Content description for switch that enables permissions for reading the user's menstruation data [CHAR_LIMIT=NONE]">Lei la mestruazion</string>
+    <string name="menstruation_write_content_description" description="Content description for switch that enables permissions for writing the user's menstruation data [CHAR_LIMIT=NONE]">Scrivi la mestruazion</string>
+    <string name="ovulation_test_uppercase_label" description="Uppercase label used to show the user's ovulation test data [CHAR_LIMIT=50]">Prove di ovulazion</string>
+    <string name="ovulation_test_lowercase_label" description="Lowercase label used to show the user's ovulation test data [CHAR_LIMIT=50]">prove di ovulazion</string>
+    <string name="ovulation_test_read_content_description" description="Content description for switch that enables permissions for reading the user's ovulation test data [CHAR_LIMIT=NONE]">Lei la prove di ovulazion</string>
+    <string name="ovulation_test_write_content_description" description="Content description for switch that enables permissions for writing the user's ovulation test data [CHAR_LIMIT=NONE]">Scrivi la prove di ovulazion</string>
+    <string name="sexual_activity_uppercase_label" description="Uppercase label used to show the user's sexual activity data [CHAR_LIMIT=50]">Ativitât sessuâl</string>
+    <string name="sexual_activity_lowercase_label" description="Lowercase label used to show the user's sexual activity data [CHAR_LIMIT=50]">ativitât sessuâl</string>
+    <string name="sexual_activity_read_content_description" description="Content description for switch that enables permissions for reading the user's sexual activity data [CHAR_LIMIT=NONE]">Lei la ativitât sessuâl</string>
+    <string name="sexual_activity_write_content_description" description="Content description for switch that enables permissions for writing the user's sexual activity data [CHAR_LIMIT=NONE]">Scrivi la ativitât sessuâl</string>
+    <string name="spotting_uppercase_label" description="Uppercase label used to show the user's spotting data [CHAR_LIMIT=50]">Pierditis vagjinâls di sanc</string>
+    <string name="spotting_lowercase_label" description="Lowercase label used to show the user's spotting data [CHAR_LIMIT=50]">pierditis vagjinâls di sanc</string>
+    <string name="spotting_read_content_description" description="Content description for switch that enables permissions for reading the user's active spotting data [CHAR_LIMIT=NONE]">Lei lis pierditis vagjinâls di sanc</string>
+    <string name="spotting_write_content_description" description="Content description for switch that enables permissions for writing the user's active spotting data [CHAR_LIMIT=NONE]">Scrivi lis pierditis vagjinâls di sanc</string>
+    <string name="hydration_uppercase_label" description="Uppercase label used to show the user's hydration data [CHAR_LIMIT=50]">Idratazion</string>
+    <string name="hydration_lowercase_label" description="Lowercase label used to show the user's hydration data [CHAR_LIMIT=50]">idratazion</string>
+    <string name="hydration_read_content_description" description="Content description for switch that enables permissions for reading the user's hydration data [CHAR_LIMIT=NONE]">Lei la idratazion</string>
+    <string name="hydration_write_content_description" description="Content description for switch that enables permissions for writing the user's hydration data [CHAR_LIMIT=NONE]">Scrivi la idratazion</string>
+    <string name="nutrition_uppercase_label" description="Uppercase label used to show the user's nutrition data [CHAR_LIMIT=50]">Nutrizion</string>
+    <string name="nutrition_lowercase_label" description="Lowercase label used to show the user's nutrition data [CHAR_LIMIT=50]">nutrizion</string>
+    <string name="nutrition_read_content_description" description="Content description for switch that enables permissions for reading the user's nutrition data [CHAR_LIMIT=NONE]">Lei la nutrizion</string>
+    <string name="nutrition_write_content_description" description="Content description for switch that enables permissions for writing the user's nutrition data [CHAR_LIMIT=NONE]">Scrivi la nutrizion</string>
+    <string name="sleep_uppercase_label" description="Uppercase label used to show the user's sleep data [CHAR_LIMIT=50]">Polse</string>
+    <string name="sleep_lowercase_label" description="Lowercase label used to show the user's sleep data [CHAR_LIMIT=50]">polse</string>
+    <string name="sleep_read_content_description" description="Content description for switch that enables permissions for reading the user's sleep data [CHAR_LIMIT=NONE]">Lei la polse</string>
+    <string name="sleep_write_content_description" description="Content description for switch that enables permissions for writing the user's sleep session data [CHAR_LIMIT=NONE]">Scrivi la polse</string>
+    <string name="basal_body_temperature_uppercase_label" description="Uppercase label used to show the user's basal body temperature data [CHAR_LIMIT=50]">Temperadure basâl corporie</string>
+    <string name="basal_body_temperature_lowercase_label" description="Lowercase label used to show the user's basal body temperature data [CHAR_LIMIT=50]">temperadure basâl corporie</string>
+    <string name="basal_body_temperature_read_content_description" description="Content description for switch that enables permissions for reading the user's basal body temperature data [CHAR_LIMIT=NONE]">Lei la temperadure basâl corporie</string>
+    <string name="basal_body_temperature_write_content_description" description="Content description for switch that enables permissions for writing the user's basal body temperature data [CHAR_LIMIT=NONE]">Scrivi la temperadure basâl corporie</string>
+    <string name="blood_glucose_uppercase_label" description="Uppercase label used to show the user's blood glucose data [CHAR_LIMIT=50]">Glucosi dal sanc</string>
+    <string name="blood_glucose_lowercase_label" description="Label used to show the user's blood glucose data [CHAR_LIMIT=50]">glucosi dal sanc</string>
+    <string name="blood_glucose_read_content_description" description="Content description for switch that enables permissions for reading the user's blood glucose data [CHAR_LIMIT=NONE]">Lei il glucosi dal sanc</string>
+    <string name="blood_glucose_write_content_description" description="Content description for switch that enables permissions for writing the user's blood glucose data [CHAR_LIMIT=NONE]">Scrivi il glucosi dal sanc</string>
+    <string name="blood_pressure_uppercase_label" description="Uppercase label used to show the user's blood pressure data [CHAR_LIMIT=50]">Pression sanghine</string>
+    <string name="blood_pressure_lowercase_label" description="Lowercase label used to show the user's blood pressure data [CHAR_LIMIT=50]">pression sanghine</string>
+    <string name="blood_pressure_read_content_description" description="Content description for switch that enables permissions for reading the user's blood pressure data [CHAR_LIMIT=NONE]">Lei la pression dal sanc</string>
+    <string name="blood_pressure_write_content_description" description="Content description for switch that enables permissions for writing the user's blood pressure data [CHAR_LIMIT=NONE]">Scrivi la pression dal sanc</string>
+    <string name="body_temperature_uppercase_label" description="Uppercase label used to show the user's body temperature data [CHAR_LIMIT=50]">Temperadure corporie</string>
+    <string name="body_temperature_lowercase_label" description="Lowercase label used to show the user's body temperature data [CHAR_LIMIT=50]">temperadure corporie</string>
+    <string name="body_temperature_read_content_description" description="Content description for switch that enables permissions for reading the user's body temperature data [CHAR_LIMIT=NONE]">Lei la temperadure corporie</string>
+    <string name="body_temperature_write_content_description" description="Content description for switch that enables permissions for writing the user's body temperature data [CHAR_LIMIT=NONE]">Scrivi la temperadure corporie</string>
+    <string name="heart_rate_uppercase_label" description="Uppercase label used to show the user's heart rate data [CHAR_LIMIT=50]">Frecuence cardiache</string>
+    <string name="heart_rate_lowercase_label" description="Lowercase label used to show the user's heart rate data [CHAR_LIMIT=50]">frecuence cardiache</string>
+    <string name="heart_rate_read_content_description" description="Content description for switch that enables permissions for reading the user's heart rate data [CHAR_LIMIT=NONE]">Lei la frecuence cardiache</string>
+    <string name="heart_rate_write_content_description" description="Content description for switch that enables permissions for writing the user's heart rate data [CHAR_LIMIT=NONE]">Scrivi la frecuence cardiache</string>
+    <string name="heart_rate_variability_uppercase_label" description="Uppercase label used to show the user's heart rate variability data [CHAR_LIMIT=50]">Variabilitât de frecuence cardiache</string>
+    <string name="heart_rate_variability_lowercase_label" description="Lowercase label used to show the user's heart rate variability data [CHAR_LIMIT=50]">variabilitât de frecuence cardiache</string>
+    <string name="heart_rate_variability_read_content_description" description="Content description for switch that enables permissions for reading the user's heart rate variability data [CHAR_LIMIT=NONE]">Lei la variabilitât de frecuence cardiache</string>
+    <string name="heart_rate_variability_write_content_description" description="Content description for switch that enables permissions for writing the user's heart rate variability data [CHAR_LIMIT=NONE]">Scrivi la variabilitât de frecuence cardiache</string>
+    <string name="oxygen_saturation_uppercase_label" description="Uppercase label used to show the user's oxygen saturation data [CHAR_LIMIT=50]">Saturazion di ossigjen</string>
+    <string name="oxygen_saturation_lowercase_label" description="Lowercase label used to show the user's oxygen saturation data [CHAR_LIMIT=50]">saturazion di ossigjen</string>
+    <string name="oxygen_saturation_read_content_description" description="Content description for switch that enables permissions for reading the user's oxygen saturation data [CHAR_LIMIT=NONE]">Lei la saturazion dal ossigjen</string>
+    <string name="oxygen_saturation_write_content_description" description="Content description for switch that enables permissions for writing the user's oxygen saturation data [CHAR_LIMIT=NONE]">Scrivi la saturazion dal ossigjen</string>
+    <string name="respiratory_rate_uppercase_label" description="Uppercase label used to show the user's respiratory rate data [CHAR_LIMIT=50]">Frecuence respiratorie</string>
+    <string name="respiratory_rate_lowercase_label" description="Lowercase label used to show the user's respiratory rate data [CHAR_LIMIT=50]">frecuence respiratorie</string>
+    <string name="respiratory_rate_read_content_description" description="Content description for switch that enables permissions for reading the user's respiratory rate data [CHAR_LIMIT=NONE]">Lei la frecuence respiratorie</string>
+    <string name="respiratory_rate_write_content_description" description="Content description for switch that enables permissions for writing the user's respiratory rate data [CHAR_LIMIT=NONE]">Scrivi la frecuence respiratorie</string>
+    <string name="resting_heart_rate_uppercase_label" description="Uppercase label used to show the user's resting heart rate data [CHAR_LIMIT=50]">Frecuence cardiache in polse</string>
+    <string name="resting_heart_rate_lowercase_label" description="Lowercase label used to show the user's resting heart rate data [CHAR_LIMIT=50]">frecuence cardiache in polse</string>
+    <string name="resting_heart_rate_read_content_description" description="Content description for switch that enables permissions for reading the user's resting heart rate data [CHAR_LIMIT=NONE]">Lei lis batudis dal cûr in polse</string>
+    <string name="resting_heart_rate_write_content_description" description="Content description for switch that enables permissions for writing the user's resting heart rate data [CHAR_LIMIT=NONE]">Scrivi lis batudis dal cûr in polse</string>
+    <string name="read_permission_category" description="Title for read permission category in the app permission screen">Permeti a <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> di lei</string>
+    <string name="write_permission_category" description="Title for write permission category in the app permission screen">Permeti a <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> di scrivi</string>
+    <string name="request_permissions_cancel" description="Label for button to cancel an app's request for permissions [CHAR_LIMIT=20]">Anule</string>
+    <string name="request_permissions_allow" description="Label for button to allow an app to have the selected permissions for the user's data [CHAR_LIMIT=20]">Permet</string>
+    <string name="request_permissions_allow_all" description="Label for button to allow an app to have the selected permissions for the user's data [CHAR_LIMIT=20]">Permet dut</string>
+    <string name="request_permissions_dont_allow" description="Label for button to allow an app to have the selected permissions for the user's data [CHAR_LIMIT=20]">No sta permeti</string>
+    <string name="request_permissions_header_desc" description="Text asking the user to select permissions for an app. [CHAR_LIMIT=NONE]">Sielç i dâts che cheste aplicazion e pues lei o scrivi su Conession salût</string>
+    <string name="request_permissions_header_time_frame_desc" description="Text describing the time frame of data which an app will be able to access. [CHAR_LIMIT=NONE]">Se tu concedis l\'acès ae leture, cheste aplicazion e podarà lei i gnûfs dâts e i dâts dai ultins 30 dîs</string>
+    <string name="request_permissions_header_title" description="Title for screen to give permissions to an app to read or write users data. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]">Permeti a <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> di acedi a Conession salût?</string>
+    <string name="request_permissions_rationale" description="Text informing the user that data they share with an app is covered by that app's data privacy policy. Has a link to the app's privacy policy. [CHAR_LIMIT=NONE]">Tu puedis scuvierzi cemût che <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> al gjestìs i tiei dâts tes <xliff:g example="privacy policy" id="privacy_policy_link">%2$s</xliff:g> dai svilupadôrs</string>
+    <string name="request_permissions_privacy_policy" description="Link text that open's a third party app's data privacy policy [CHAR_LIMIT=NONE]">normis su la riservatece</string>
+    <string name="permissions_disconnect_dialog_title" description="Title for dialog asking the user to confirm they want to remove all permissions for an app [CHAR_LIMIT=40]">Gjavâ ducj i permès?</string>
+    <string name="permissions_disconnect_dialog_disconnect" description="Label for dialog button to confirm removal of all permissions for an app [CHAR_LIMIT=20]">Gjave dut</string>
+    <string name="permissions_disconnect_dialog_message" description="Text informing the user that an app will no longer be able to read or write data after the permissions have been removed. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]"><xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> nol rivarà plui a lei o scrivi dâts di Conession salût.\n\nChest nol larà a tocjâ altris permès che cheste aplicazion e podarès vê, come posizion, fotocjamare o microfon.</string>
+    <string name="permissions_disconnect_dialog_checkbox" description="Text of a checkbox to decide whether to delete or not all data written by the app that is being disconnected by the user. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]">Elimine di Conession salût ancje i dâts di <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g></string>
+    <string name="navigation_next_day" description="Content description for button that changes the current data view to the next day [CHAR_LIMIT=NONE]">Dì sucessîf</string>
+    <string name="navigation_selected_day" description="Content description for button that contains selected day. [CHAR_LIMIT=NONE]">Dì selezionât</string>
+    <string name="navigation_previous_day" description="Content description for button that changes the current data view to the previous day [CHAR_LIMIT=NONE]">Dì precedent</string>
+    <string name="default_error" description="Label shown when a user initiated action fails (e.g. deleting data) [CHAR_LIMIT=NONE]">Alc al è lât strucj. Torne prove.</string>
+    <string name="health_permission_header_description" description="Description text shown on screen for managing which apps have access to health and fitness data. Note: Health Connect is the brand [CHAR_LIMIT=NONE]">Lis aplicazions cun chest permès a puedin lei e scrivi i tiei dâts su salût e forme fisiche.</string>
+    <string name="connected_apps_text" description="Description text shown on screen for managing which apps have access to health and fitness data. Note: Health Connect is the brand [CHAR_LIMIT=NONE]">Controle cualis aplicazions che a puedin acedi ai dâts archiviâts in Conession salût. Tocje une aplicazion par revisionâ i dâts che e pues lei o scrivi.</string>
+    <string name="connected_apps_section_title" description="Title of section containing all the connected apps [CHAR_LIMIT=40]">Acès consintût</string>
+    <string name="not_connected_apps_section_title" description="Title of section containing all the not-connected apps [CHAR_LIMIT=40]">Acès no consintût</string>
+    <string name="settings_and_help_header" description="Title shown for the section of settings and help [CHAR_LIMIT=70]">Impostazions e jutori</string>
+    <string name="disconnect_all_apps" description="Button text for removing access to health and fitness data for all apps [CHAR_LIMIT=40]">Gjave l\'acès a dutis lis aplicazions</string>
+    <string name="manage_permissions_read_header" description="Header for list of permissions an app is allowed read access to [CHAR_LIMIT=40]">Leture concedude</string>
+    <string name="manage_permissions_write_header" description="Header for list of permissions an app is allowed write access to [CHAR_LIMIT=40]">Scriture concedude</string>
+    <string name="no_apps_allowed" description="Label when no apps have ben granted access to Health data.[CHAR_LIMIT=40]">Nissune aplicazion consintude</string>
+    <string name="no_apps_denied" description="Label when no apps have been denied a health permission [CHAR_LIMIT=40]">Nissune aplicazion dineade</string>
+    <string name="permissions_disconnect_all_dialog_title" description="Title for dialog asking the user to confirm they want to remove all permissions for all apps [CHAR_LIMIT=50]">Gjavâ l\'acès a dutis lis aplicazions?</string>
+    <string name="permissions_disconnect_all_dialog_message" description="Text informing the user that all apps will no longer be able to read or write data after the permissions have been removed. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]">Nissune des tôs aplicazions a rivaran a acedi o a zontâ gnûfs dâts a Conession salût. Cheste operazion no elimine i dâts esistents.\n\nCheste operazion no larà a tocjâ altris permès che cheste aplicazion e podarès vê, come posizion, fotocjamare o microfon.</string>
+    <string name="permissions_disconnect_all_dialog_disconnect" description="Label for dialog button to confirm removal of all permissions for all apps [CHAR_LIMIT=20]">Gjave dut</string>
+    <string name="manage_permissions_manage_app_header" description="Title shown for section to manage app [CHAR_LIMIT=40]">Gjestìs aplicazion</string>
+    <string name="delete_app_data" description="Label of a button that deletes data written by given app. [CHAR_LIMIT=40]">Elimine dâts di aplicazion</string>
+    <string name="inactive_apps_section_title" description="Title shown for section of inactive apps [CHAR_LIMIT=40]">Aplicazions inativis</string>
+    <string name="inactive_apps_section_message" description="Description text shown in the inactive apps section that explains what inactive apps are [CHAR_LIMIT=NONE]">Chestis aplicazions no àn plui l\'acès, ma a àn ancjemò dâts archiviâts in Conession salût</string>
+    <string name="manage_permissions_time_frame" description="Text describing the time frame of data which an app will be able to access [CHAR_LIMIT=NONE]"><xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> al pues lei dâts zontâts dopo dal/dai <xliff:g example="22 January 2022" id="data_access_date">%2$s</xliff:g></string>
+    <string name="other_android_permissions" description="Text that describes how users can change other android permissions through the system settings [CHAR_LIMIT=NONE]">Par gjestî altris permès di Android che cheste aplicazion e pues doprâ, va in Impostazions &gt; Aplicazions</string>
+    <string name="manage_permissions_rationale" description="Text informing the user that data they share with an app is covered by that app's data privacy policy [CHAR_LIMIT=NONE]">I dâts che tu condividis cun <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> a son cuvierts des lôr normis su la riservatece</string>
+    <string name="other_android_permissions_content_description" description="Content description that describes how users can change other android permissions through the system settings [CHAR_LIMIT=NONE]">Par gjestî altris permès di Android che cheste aplicazion e pues doprâ, va in Impostazions, dopo tocje Aplicazions</string>
+    <string name="manage_permissions_learn_more" description="Link text that open's a third party app's data privacy policy [CHAR_LIMIT=NONE]">Lei lis normis su la riservatece</string>
+    <string name="app_perms_content_provider_24h" description="Summary for showing the last access text for content provider permissions [CHAR LIMIT=70]">Acès fat tes ultimis 24 oris</string>
+    <string name="app_access_title" description="Title of screen for a user to manage the health and fitness data a particular app has access to [CHAR_LIMIT=40]">Acès des aplicazions</string>
+    <string name="connected_apps_empty_list_section_title" description="Title of section when there are no connected apps">In chest moment no tu âs nissune aplicazion compatibile instalade</string>
+    <string name="denied_apps_banner_title" description="Title of a banner that provides information about apps that have been denied, in other words their permissions have been removed. [CHAR_LIMIT=100]">Permès di aplicazion gjavâts</string>
+    <string name="denied_apps_banner_message_one_app" description="Message of a banner that provides information about an app that has been denied. [CHAR_LIMIT=NONE]">Permès gjavâts di Conession salût par <xliff:g id="app_data" example="Strava">%s</xliff:g></string>
+    <string name="denied_apps_banner_message_two_apps" description="Message of a banner that provides information about two apps that have been denied. [CHAR_LIMIT=NONE]">Permès gjavâts di Conession salût par <xliff:g id="app_data" example="Strava">%1$s</xliff:g> e <xliff:g id="app_data_two" example="Strava">%2$s</xliff:g></string>
+    <string name="denied_apps_banner_message_three_apps" description="Message of a banner that provides information about three apps that have been denied. [CHAR_LIMIT=NONE]">Permès gjavâts di Conession salût par <xliff:g id="app_data" example="Strava">%1$s</xliff:g>, <xliff:g id="app_data_two" example="Strava">%2$s</xliff:g> e <xliff:g id="app_data_three" example="Strava">%3$s</xliff:g></string>
+    <string name="denied_apps_banner_message_many_apps" description="Message of a banner that provides information about more than three apps that have been denied. [CHAR_LIMIT=NONE]">Conession salût al à gjavât i permès par <xliff:g id="app_data" example="Strava">%1$s</xliff:g>, <xliff:g id="app_data_two" example="Strava">%2$s</xliff:g>, <xliff:g id="app_data_three" example="Strava">%3$s</xliff:g> e altris aplicazions</string>
+    <string name="denied_apps_banner_button" description="Label of a button that opens a page with more details about denied apps. [CHAR_LIMIT=40]">Viôt i detais</string>
+    <string name="denied_apps_dialog_title" description="Title of a dialog that provides information about apps with permissions removed by Health Connect. [CHAR_LIMIT=NONE]">Parcè Conession salût gjavial i permès des aplicazions?</string>
+    <string name="denied_apps_dialog_message" description="Label of a button that opens a page with more details about denied apps. [CHAR_LIMIT=NONE]">Se une aplicazion e je sospindude o gjavade di Google Play, Conession salût al gjave in automatic i siei permès.\n\nChest al vûl dî che la aplicazion no rivarà plui a acedi ai dâts archiviâts in Conession salût. Se prime cheste aplicazion e à scrit dâts, e ven fûr te liste des aplicazions inativis.</string>
+    <string name="denied_apps_dialog_got_it_button" description="Label of a button that closes the dialog. [CHAR_LIMIT=40]">Capît</string>
+    <string name="onboarding_description" description="Content description of Health Connect app on the onboarding page">Conession salût al archivie i tiei dâts su salût e forme fisiche e e semplifiche la sincronizazion di diviersis aplicazions sul telefon</string>
+    <string name="share_data" description="Label used to show how the user can share data with apps">Condivît i dâts cu lis tôs aplicazions</string>
+    <string name="share_data_description" description="Content description for how the user can share data with apps">Sielç cuai dâts che ogni aplicazion e pues lei o scrivi su Conession salût</string>
+    <string name="manage_your_settings" description="Label used to show how the user can manage settings and privacy">Gjestìs lis impostazions e la riservatece</string>
+    <string name="manage_your_settings_description" description="Content description for how the user can change app permissions and manage data">Cambie i permès des aplicazions e gjestìs i tiei dâts cuant che tu vûs</string>
+    <string name="onboarding_go_back_button_text" description="Content description for button to exit from onboarding page">Tone indaûr</string>
+    <string name="onboarding_get_started_button_text" description="Content description for button to get started with Health Connect app">Scomence</string>
+    <string name="delete_button_content_description" description="Content description of a button that starts the deletion flow. [CHAR_LIMIT=50]">Elimine dâts</string>
+    <string name="time_range_title" description="Window title where user can choose the time range for data deletion. [CHAR_LIMIT=50]">Sielç i dâts di eliminâ</string>
+    <string name="time_range_next_button" description="Label of a button that navigates to the next window of the deletion flow. [CHAR_LIMIT=50]">Indevant</string>
+    <string name="time_range_message_all" description="Description explaining that this data deletion user activity is permanent. [CHAR_LIMIT=NONE]">Chest al eliminarà par simpri ducj i dâts zontâts in Conession salût tal periodi sielt</string>
+    <string name="time_range_message_data_type" description="Description explaining that this data deletion user activity is permanent. [CHAR_LIMIT=NONE]">Chest al eliminarà par simpri i dâts di <xliff:g id="data_type" example="heart rate">%s</xliff:g> zontâts in Conession salût tal periodi sielt</string>
+    <string name="time_range_message_category" description="Description explaining that this data deletion user activity is permanent. [CHAR_LIMIT=NONE]">Chest al eliminarà par simpri i dâts di <xliff:g id="category" example="activity">%s</xliff:g> zontâts in Conession salût tal periodi sielt</string>
+    <string name="time_range_message_app_data" description="Description explaining that this data deletion user activity is permanent. [CHAR_LIMIT=NONE]">Chest al eliminarà par simpri i dâts di <xliff:g id="app_data" example="Strava">%s</xliff:g> zontâts in Conession salût tal periodi sielt</string>
+    <string name="time_range_one_day" description="Item on list of possible deletion time ranges the user can choose. This option deletes data for the last 24 hours. [CHAR_LIMIT=50]">Elimine lis ultimis 24 oris</string>
+    <string name="time_range_one_week" description="Item on list of possible deletion time ranges the user can choose. This option deletes data for the last 7 days. [CHAR_LIMIT=50]">Elimine i ultins 7 dîs</string>
+    <string name="time_range_one_month" description="Item on list of possible deletion time ranges the user can choose. This option deletes data for the last 30 days. [CHAR_LIMIT=50]">Elimine i ultins 30 dîs</string>
+    <string name="time_range_all" description="Item on list of possible deletion time ranges the user can choose. This option deletes all data written during the selected time period. [CHAR_LIMIT=50]">Elimine ducj i dâts</string>
+    <string name="confirming_question_all" description="Description of what permanent deletion of some data means. [CHAR_LIMIT=NONE]">Eliminâ par simpri ducj i dâts di simpri?</string>
+    <string name="confirming_question_one_day" description="Description of what permanent deletion of some data means. [CHAR_LIMIT=NONE]">Eliminâ par simpri ducj i dâts des ultimis 24 oris?</string>
+    <string name="confirming_question_one_week" description="Description of what permanent deletion of some data means. [CHAR_LIMIT=NONE]">Eliminâ par simpri ducj i dâts dai ultins 7 dîs?</string>
+    <string name="confirming_question_one_month" description="Description of what permanent deletion of some data means. [CHAR_LIMIT=NONE]">Eliminâ par simpri ducj i dâts dai ultins 30 dîs?</string>
+    <string name="confirming_question_data_type_all" description="Description of what permanent deletion of all given data type data means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="data_type" example="heart rate">%s</xliff:g> di simpri?</string>
+    <string name="confirming_question_data_type_one_day" description="Description of what permanent deletion of given data type data from the lat 24 hours means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="data_type" example="heart rate">%s</xliff:g> des ultimis 24 oris?</string>
+    <string name="confirming_question_data_type_one_week" description="Description of what permanent deletion of given data type data from the last 7 days means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="data_type" example="heart rate">%s</xliff:g> dai ultins 7 dîs?</string>
+    <string name="confirming_question_data_type_one_month" description="Description of what permanent deletion of given data type data from the last 30 days means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="data_type" example="heart rate">%s</xliff:g> dai ultins 30 dîs?</string>
+    <string name="confirming_question_category_all" description="Description of what permanent deletion of all given activity data means. [CHAR_LIMIT=NONE]">Elinimâ par simpri i dâts di <xliff:g id="category" example="activity">%s</xliff:g> di simpri?</string>
+    <string name="confirming_question_category_one_day" description="Description of what permanent deletion of given activity data from the lat 24 hours means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="category" example="activity">%s</xliff:g> des ultimis 24 oris?</string>
+    <string name="confirming_question_category_one_week" description="Description of what permanent deletion of given activity data from the lat 7 days means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="category" example="activity">%s</xliff:g> dai ultins 7 dîs?</string>
+    <string name="confirming_question_category_one_month" description="Description of what permanent deletion of given activity data from the lat 30 days means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="category" example="activity">%s</xliff:g> dai ultins 30 dîs?</string>
+    <string name="confirming_question_app_data_all" description="Description of what permanent deletion of all data written by given app means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="app_data" example="Strava">%s</xliff:g> di simpri?</string>
+    <string name="confirming_question_app_data_one_day" description="Description of what permanent deletion of data written by given app from the lat 24 hours means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="app_data" example="Strava">%s</xliff:g> des ultimis 24 oris?</string>
+    <string name="confirming_question_app_data_one_week" description="Description of what permanent deletion of data written by given app from the lat 7 days means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="app_data" example="Strava">%s</xliff:g> dai ultins 7 dîs?</string>
+    <string name="confirming_question_app_data_one_month" description="Description of what permanent deletion of data written by given app from the lat 30 days means. [CHAR_LIMIT=NONE]">Eliminâ par simpri i dâts di <xliff:g id="app_data" example="Strava">%s</xliff:g> dai ultins 30 dîs?</string>
+    <string name="confirming_question_app_remove_all_permissions" description="Message of a check box that gives the user an option to remove all permissions from an app they're deleting data from. [CHAR_LIMIT=NONE]">Gjave di Conession salût ancje ducj i permès di <xliff:g id="app_with_permissions" example="Strava">%s</xliff:g></string>
+    <string name="confirming_question_data_type_from_app_all" description="Description of what permanent deletion of given data type written by given app means. [CHAR_LIMIT=NONE]">Eliminâ par simpri ducj i dâts di <xliff:g id="data_type" example="heart rate">%1$s</xliff:g> zontâts di <xliff:g id="app_data" example="Strava">%2$s</xliff:g>?</string>
+    <string name="confirming_question_single_entry" description="Description of what permanent deletion of a single data point means. [CHAR_LIMIT=NONE]">Eliminâ par simpri cheste vôs?</string>
+    <string name="confirming_question_message" description="Description of what permanent deletion of some data means. [CHAR_LIMIT=NONE]">Lis aplicazions colegadis no rivaran plui a acedi a chescj dâts di Conession salût</string>
+    <string name="confirming_question_message_menstruation" description="Description of what menstruation entries this action will delete [CHAR_LIMIT=NONE]">Chest al eliminarà dutis lis vôs di mestruazion dai <xliff:g example="22 January 2022" id="start_date">%1$s</xliff:g> ai <xliff:g example="22 January 2022" id="end_date">%2$s</xliff:g>.</string>
+    <string name="confirming_question_delete_button" description="Label of a button that deletes data. [CHAR_LIMIT=50]">Elimine</string>
+    <string name="confirming_question_go_back_button" description="Label of a button that goes back to the previous dialog. [CHAR_LIMIT=50]">Tone indaûr</string>
+    <string name="delete_dialog_success_got_it_button" description="Label of a button that dismisses the pop-up window. [CHAR_LIMIT=50]">Fat</string>
+    <string name="delete_dialog_failure_close_button" description="Label of a button that closes the window. [CHAR_LIMIT=50]">Siere</string>
+    <string name="delete_dialog_success_title" description="Title of the confirmation window of successful data deletion. [CHAR_LIMIT=50]">Dâts eliminâts</string>
+    <string name="delete_dialog_success_message" description="A message that confirms successful data deletion. [CHAR_LIMIT=NONE]">Chescj dâts no son plui archiviâts in Conession salût.</string>
+    <string name="delete_progress_indicator" description="Label of a message on a loading page with a progress bar during data deletion. [CHAR_LIMIT=100]">Daûr a eliminâ i tiei dâts</string>
+    <string name="delete_dialog_failure_title" description="Title of the window that nforms the user about failed data deletion. [CHAR_LIMIT=50]">Impussibil eliminâ i dâts</string>
+    <string name="delete_dialog_failure_message" description="A message that informs the user about failed data deletion. [CHAR_LIMIT=NONE]">Alc al è lât strucj e Conession salût nol rive a eliminâ i tiei dâts</string>
+    <string name="delete_dialog_failure_try_again_button" description="Label of a button that closes the window and goes back to the previous one. [CHAR_LIMIT=50]">Torne prove</string>
+    <string name="delete_data_notification_title" description="The title text of the notification that is shown while data is being deleted. [CHAR_LIMIT=50]">Daûr a eliminâ i dâts di Conession salût</string>
+    <string name="delete_data_notification_ticker_text" description="The ticker text of the notification that is shown while data is being deleted, which is read out by screen readers. [CHAR_LIMIT=50]">Daûr a eliminâ i dâts di Conession salût</string>
+    <string name="delete_data_notification_channel_name" description="The channel name for the notification that is shown while data is being deleted, which is visible to users in system settings. [CHAR_LIMIT=50]">Eliminazion dâts</string>
+    <string name="data_point_action_content_description" description="Content description for the menu button of an individual data entry [CHAR LIMIT=NONE]">Elimine vôs dai dâts</string>
+    <string name="delete_data_point" description="Menu option for deleting an individual data entry [CHAR LIMIT=50]">Elimine vôs</string>
+    <string name="aggregation_total" description="Description before the total value. For instance, Total: 1000 steps. [CHAR LIMIT=50]">Totâl: <xliff:g id="total_value" example="1000 steps">%s</xliff:g></string>
+    <string name="watt_format" description="Power value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1 W} other {# W}}</string>
+    <string name="watt_format_long" description="Power value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1 watt} other {# watts}}</string>
+    <string name="steps_value" translation_description="Value of steps taken. [ICU SYNTAX][CHAR LIMIT=10]">{count, plural, one {}=1 {1 pas} other {# pas}}</string>
+    <string name="steps_per_minute" description="Step cadence value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1 pas/min} other {# pas/min}}</string>
+    <string name="steps_per_minute_long" description="Step cadence value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1 pas al minût} other {# pas al minût}}</string>
+    <string name="heart_rate_value" translation_description="Value of heart rate beats per minute. [ICU SYNTAX][CHAR LIMIT=10]">{count, plural, one {}=1 {1 bpm} other {# bpm}}</string>
+    <string name="heart_rate_long_value" translation_description="Value of heart rate beats per minute. [ICU SYNTAX][CHAR LIMIT=10]">{count, plural, one {}=1 {1 batude al minût} other {# batudis al minût}}</string>
+    <string name="velocity_speed_miles" translation_description="Speed in miles per hour formatted. [ICU SYNTAX][CHAR LIMIT=15]">{value, plural, one {}=1 {1 mph} other {# mph}}</string>
+    <string name="velocity_speed_km" translation_description="Speed in kilometers per hour formatted. [ICU SYNTAX][CHAR LIMIT=15]">{value, plural, one {}=1 {1 km/h} other {# km/h}}</string>
+    <string name="velocity_speed_miles_long" translation_description="Speed in miles per hour formatted for audible announcement. [ICU SYNTAX][CHAR LIMIT=100]">{value, plural, one {}=1 {1 mie a la ore} other {# miis a la ore}}</string>
+    <string name="velocity_speed_km_long" translation_description="Speed in kilometers per hour formatted audible announcement. [ICU SYNTAX][CHAR LIMIT=100]">{value, plural, one {}=1 {1 chilometri a la ore} other {# chilometris a la ore}}</string>
+    <string name="time_range_long" description="Content description for time interval. [CHAR_LIMIT=NONE]"> di <xliff:g example="14:41" id="start_time">%1$s</xliff:g> a <xliff:g example="15:41" id="end_time">%2$s</xliff:g></string>
+    <string name="date_range_long" description="Content description for date interval. [CHAR_LIMIT=NONE]"> di <xliff:g example="October 30, 2021" id="start_time">%1$s</xliff:g> a <xliff:g example="November 11, 2021" id="end_time">%2$s</xliff:g></string>
+    <string name="wheelchair_pushes" description="Number of wheelchair pushes. [ICU SYNTAX][CHAR LIMIT=50]">{count, plural, one {}=1 {1 sburtade di carocele} other {# sburtadis di carocele}}</string>
+    <string name="liter" description="Volume value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{count, plural, one {}=1 {1 L} other {# L}}</string>
+    <string name="liter_long" description="Volume value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{count, plural, one {}=1 {1 litri} other {# litris}}</string>
+    <string name="floors_climbed" description="Value of floors climbed. [ICU SYNTAX][CHAR LIMIT=50]">{count, plural, one {}=1 {1 plan} other {# plans}}</string>
+    <string name="elevation_meters" translation_description="Shown as the label in the tooltip for weight chart. [ICU SYNTAX][CHAR LIMIT=60]">{count, plural, one {}=1 {1 m} other {# m}}</string>
+    <string name="elevation_meters_long" translation_description="Shown as the label in the tooltip for weight chart. [ICU SYNTAX][CHAR LIMIT=60]">{count, plural, one {}=1 {1 metri} other {# metris}}</string>
+    <string name="cycling_rpm" description="Pedaling rate, in crank revolutions per minute (RPM). [ICU SYNTAX][CHAR LIMIT=50]">{count, plural, one {}=1 {1 rpm} other {# rpm}}</string>
+    <string name="cycling_rpm_long" description="Pedaling rate, in crank revolutions per minute (RPM).  [ICU SYNTAX][CHAR LIMIT=50]">{count, plural, one {}=1 {1 rivoluzion par minût} other {# rivoluzions par minût}}</string>
+    <string name="cycling_cadence_series_range_long" description="Pedaling rate range, in crank revolutions per minute (RPM)"> di <xliff:g example="100 revolutions per minute" id="min">%1$s</xliff:g> a <xliff:g example="109 revolutions per minute" id="max">%2$s</xliff:g></string>
+    <string name="sexual_activity_protected" description="Whether protection was used during sexual activity. [CHAR LIMIT=50]">Protet</string>
+    <string name="sexual_activity_unprotected" description="Whether protection was used during sexual activity. [CHAR LIMIT=50]">Cence protezions</string>
+    <string name="spotting" description="Intermenstrual bleeding type: spotting. [CHAR LIMIT=50]">Pierditis vagjinâls di sanc</string>
+    <string name="flow_spotting" description="How heavy the user's menstruation flow was - spotting. [CHAR LIMIT=50]">Pierditis vagjinâls di sanc</string>
+    <string name="flow_light" description="How heavy the user's menstruation flow was - light. [CHAR LIMIT=50]">Flus scjars</string>
+    <string name="flow_medium" description="How heavy the user's menstruation flow was - medium. [CHAR LIMIT=50]">Flus medi</string>
+    <string name="flow_heavy" description="How heavy the user's menstruation flow was - heavy. [CHAR LIMIT=50]">Flus abondant</string>
+    <string name="period_day" description="Which day of the user's menstruation period it was. [CHAR LIMIT=50]">Dì <xliff:g example="2" id="day">%1$d</xliff:g> di <xliff:g example="5" id="total_length">%2$d</xliff:g> dal periodi</string>
+    <string name="ovulation_positive" description="The positive result of a user's ovulation test. [CHAR LIMIT=50]">Positive</string>
+    <string name="ovulation_negative" description="The negative result of a user's ovulation test. [CHAR LIMIT=50]">Negative</string>
+    <string name="ovulation_high" description="The high fertility result of a user's ovulation test. [CHAR LIMIT=50]">Elevade</string>
+    <string name="ovulation_inconclusive" description="The inconclusive result of a user's ovulation test. [CHAR LIMIT=50]">Improdutive</string>
+    <string name="milliseconds" description="Heart rate variability value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{count, plural, one {}=1 {1 ms} other {# ms}}</string>
+    <string name="milliseconds_long" description="Heart rate variability value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{count, plural, one {}=1 {1 milisecont} other {# miliseconts}}</string>
+    <string name="repetitions" description="Repetitions of an exercise set. [ICU SYNTAX][CHAR LIMIT=50]">{count, plural, one {}=1 {1 rip} other {# rips}}</string>
+    <string name="repetitions_long" description="Repetitions of an exercise set.  [ICU SYNTAX][CHAR LIMIT=50]">{count, plural, one {}=1 {1 ripetizion} other {# ripetizions}}</string>
+    <string name="exercise_segments_header" description="Header for a group of exercise segments. [CHAR LIMIT=50]">Segments di esercizi</string>
+    <string name="exercise_laps_header" description="Header for a group of exercise laps. [CHAR LIMIT=50]">Zîrs</string>
+    <string name="back_extension" description="Name of the back extension gym exercise. [CHAR LIMIT=50]">Estension de schene</string>
+    <string name="badminton" description="Activity type: playing badminton. [CHAR LIMIT=50]">Badminton</string>
+    <string name="barbell_shoulder_press" description="Name of the back extension gym exercise. [CHAR LIMIT=50] [CHAR LIMIT=50]">Sburt cun belancîr pes spalis</string>
+    <string name="baseball" description="Activity type: playing baseball. [CHAR LIMIT=50]">Baseball</string>
+    <string name="basketball" description="Activity type: playing basketball. [CHAR LIMIT=50]">Bale tal zei</string>
+    <string name="bench_press" description="Name of the bench press gym exercise. [CHAR LIMIT=50]">Bancje plane</string>
+    <string name="bench_sit_up" description="Name of the bench sit up gym exercise. [CHAR LIMIT=50]">Solevament de bancje</string>
+    <string name="biking" description="Activity type: riding a bike. [CHAR LIMIT=50]">Ciclisim</string>
+    <string name="biking_stationary" description="Activity type: riding a stationary bike. [CHAR LIMIT=50]">Cyclette</string>
+    <string name="boot_camp" description="Activity type: boot camp class. [CHAR LIMIT=50]">Cjamp alenament</string>
+    <string name="boxing" description="Activity type: boxing. [CHAR LIMIT=50]">Boxe</string>
+    <string name="burpee" description="Name of the burpee gym exercise. [CHAR LIMIT=50]">Burpee</string>
+    <string name="calisthenics" description="Activity type: calisthenics. [CHAR LIMIT=50]">Gjinastiche a cuarp libar</string>
+    <string name="cricket" description="Activity type: playing cricket. [CHAR LIMIT=50]">Cricket</string>
+    <string name="crunch" description="Name of the crunch gym exercise. [CHAR LIMIT=50]">Flession adominâl</string>
+    <string name="dancing" description="Activity type: dancing. [CHAR LIMIT=50]">Danze</string>
+    <string name="deadlift" description="Name of the deadlift gym exercise. [CHAR LIMIT=50]">Solevament di par tiere</string>
+    <string name="dumbbell_curl_left_arm" description="Name of the dumbbell curl gym exercise on the left arm. [CHAR LIMIT=50]">Flession cun manuvri pal braç di çampe</string>
+    <string name="dumbbell_curl_right_arm" description="Name of the dumbbell curl gym exercise on the right arm. [CHAR LIMIT=50]">Flession cun manuvri pal braç di diestre</string>
+    <string name="dumbbell_front_raise" description="Name of the dumbbell front raise gym exercise. [CHAR LIMIT=50]">Solevament frontâl cun manuvri</string>
+    <string name="dumbbell_lateral_raise" description="Name of the dumbbell front raise gym exercise. [CHAR LIMIT=50]">Solevament laterâl cun manuvri</string>
+    <string name="dumbbell_triceps_extension_left_arm" description="Name of the dumbbell triceps extension gym exercise on the left arm. [CHAR LIMIT=50]">Estension dal tricipit cun manuvri pal braç di çampe</string>
+    <string name="dumbbell_triceps_extension_right_arm" description="Name of the dumbbell triceps extension gym exercise on the right arm. [CHAR LIMIT=50]">Estension dal tricipit cun manuvri pal braç di diestre</string>
+    <string name="dumbbell_triceps_extension_two_arm" description="Name of the dumbbell triceps extension gym exercise done with both arms. [CHAR LIMIT=50]">Estension dai tricipits cun manuvri pai doi braçs</string>
+    <string name="elliptical" description="Activity type: dancing. [CHAR LIMIT=50]">Elitiche</string>
+    <string name="exercise_class" description="Activity type: participation in an exercise class. [CHAR LIMIT=50]">Classe di esercizi</string>
+    <string name="fencing" description="Activity type: fencing. [CHAR LIMIT=50]">Scherme</string>
+    <string name="football_american" description="Activity type: playing American football. [CHAR LIMIT=50]">Football american</string>
+    <string name="football_australian" description="Activity type: playing Australian football. [CHAR LIMIT=50]">Football australian</string>
+    <string name="forward_twist" description="Name of the forward twist gym exercise. [CHAR LIMIT=50]">Torsion indevant</string>
+    <string name="frisbee_disc" description="Activity type: playing frisbee. [CHAR LIMIT=50]">Frisbee</string>
+    <string name="golf" description="Activity type: playing golf. [CHAR LIMIT=50]">Golf</string>
+    <string name="guided_breathing" description="Activity type: guided breathing. [CHAR LIMIT=50]">Respirazion vuidade</string>
+    <string name="gymnastics" description="Activity type: doing gymnastics. [CHAR LIMIT=50]">Gjinastiche</string>
+    <string name="handball" description="Activity type: playing handball. [CHAR LIMIT=50]">Bale a man</string>
+    <string name="high_intensity_interval_training" description="Activity type: performing high intensity interval training (HIIT). [CHAR LIMIT=50]">Alenament a alte intensitât a intervai</string>
+    <string name="hiking" description="Activity type: hiking. [CHAR LIMIT=50]">Escursionisim</string>
+    <string name="ice_hockey" description="Activity type: playing ice hokey. [CHAR LIMIT=50]">Hockey su glaç</string>
+    <string name="ice_skating" description="Activity type: ice skating. [CHAR LIMIT=50]">Sgliciâ</string>
+    <string name="jumping_jack" description="Name of the jumping jack gym exercise. [CHAR LIMIT=50]">Salt a stele</string>
+    <string name="jump_rope" description="Activity type: rope jumping. [CHAR LIMIT=50]">Cuarde par saltâ</string>
+    <string name="lat_pull_down" description="Name of the lat pulldown gym exercise. [CHAR LIMIT=50]">Remadôr ae cuarde</string>
+    <string name="lunge" description="Name of the lunge gym exercise. [CHAR LIMIT=50]">Moviment indenant</string>
+    <string name="martial_arts" description="Activity type: martial arts practice. [CHAR LIMIT=50]">Arts marziâls</string>
+    <string name="meditation" description="Activity type: performing meditation. [CHAR LIMIT=50]">Meditazion</string>
+    <string name="paddling" description="Activity type: paddling. [CHAR LIMIT=50]">Remâ</string>
+    <string name="paragliding" description="Activity type: paragliding. [CHAR LIMIT=50]">Parecleve</string>
+    <string name="pilates" description="Activity type: doing pilates. [CHAR LIMIT=50]">Pilates</string>
+    <string name="plank" description="Name of the plank gym exercise. [CHAR LIMIT=50]">Puint</string>
+    <string name="racquetball" description="Activity type: playing racquetball. [CHAR LIMIT=50]">Rachete</string>
+    <string name="rock_climbing" description="Activity type: rock climbing. [CHAR LIMIT=50]">Rimpinade</string>
+    <string name="roller_hockey" description="Activity type: playing roller hockey. [CHAR LIMIT=50]">Hockey su piste</string>
+    <string name="rowing" description="Activity type: rowing. [CHAR LIMIT=50]">Canotaç</string>
+    <string name="rowing_machine" description="Activity type: rowing on a rowing machine. [CHAR LIMIT=50]">Ergometri</string>
+    <string name="rugby" description="Activity type: playing rugby. [CHAR LIMIT=50]">Rugby</string>
+    <string name="running" description="Activity type: running. [CHAR LIMIT=50]">Corse</string>
+    <string name="running_treadmill" description="Activity type: treadmill running. [CHAR LIMIT=50]">Corse su tapis roulant</string>
+    <string name="sailing" description="Activity type: sailing. [CHAR LIMIT=50]">Navigazion</string>
+    <string name="scuba_diving" description="Activity type: scuba diving. [CHAR LIMIT=50]">Imersion subacuie</string>
+    <string name="skating" description="Activity type: skating. [CHAR LIMIT=50]">Patinaç</string>
+    <string name="skiing" description="Activity type: skiing. [CHAR LIMIT=50]">Schiâ</string>
+    <string name="snowboarding" description="Activity type: snowboarding. [CHAR LIMIT=50]">Lâ su bree di nêf</string>
+    <string name="snowshoeing" description="Activity type: snowshoeing. [CHAR LIMIT=50]">Cjaminade cu lis gjaspis</string>
+    <string name="soccer" description="Activity type: playing soccer. [CHAR LIMIT=50]">Balon</string>
+    <string name="softball" description="Activity type: playing softball. [CHAR LIMIT=50]">Softball</string>
+    <string name="squash" description="Activity type: playing squash. [CHAR LIMIT=50]">Squash</string>
+    <string name="squat" description="Name of the squat gym exercise. [CHAR LIMIT=50]">Squat</string>
+    <string name="stair_climbing" description="Activity type: stair climbing. [CHAR LIMIT=50]">Lâ sù pes scjalis</string>
+    <string name="stair_climbing_machine" description="Activity type: stair climbing on a machine. [CHAR LIMIT=50]">Machine par lâ sù pes scjalis</string>
+    <string name="strength_training" description="Activity type: generic strength training. [CHAR LIMIT=50]">Alenament de fuarce</string>
+    <string name="stretching" description="Name of the stretching exercise. [CHAR LIMIT=50]">Slungjament</string>
+    <string name="surfing" description="Activity type: surfing. [CHAR LIMIT=50]">Surfing</string>
+    <string name="swimming_open_water" description="Activity type: swimming in open water. [CHAR LIMIT=50]">Nadâ in aghe libare</string>
+    <string name="swimming_pool" description="Activity type: swimming in a pool. [CHAR LIMIT=50]">Nadâ in pissine</string>
+    <string name="swimming_freestyle" description="Swimming stroke type: freestyle. [CHAR LIMIT=50]">Stîl libar</string>
+    <string name="swimming_backstroke" description="Swimming stroke type: backstroke. [CHAR LIMIT=50]">Schene</string>
+    <string name="swimming_breaststroke" description="Swimming stroke type: breaststroke. [CHAR LIMIT=50]">Crot</string>
+    <string name="swimming_butterfly" description="Swimming stroke type: butterfly. [CHAR LIMIT=50]">Pavee</string>
+    <string name="swimming_mixed" description="Swimming stroke type: mixed. [CHAR LIMIT=50]">Mist</string>
+    <string name="swimming_other" description="Swimming stroke type: other. [CHAR LIMIT=50]">Altri</string>
+    <string name="table_tennis" description="Activity type: playing table tennis. [CHAR LIMIT=50]">Ping pong</string>
+    <string name="tennis" description="Activity type: playing tennis. [CHAR LIMIT=50]">Tenis</string>
+    <string name="upper_twist" description="Name of the upper twist gym exercise. [CHAR LIMIT=50]">Torsion superiôr</string>
+    <string name="volleyball" description="Activity type: playing volleyball. [CHAR LIMIT=50]">Bale a svol</string>
+    <string name="walking" description="Activity type: walking. [CHAR LIMIT=50]">Cjaminade</string>
+    <string name="water_polo" description="Activity type: playing water polo. [CHAR LIMIT=50]">Waterpolo</string>
+    <string name="weightlifting" description="Activity type: generic weightlifting training. [CHAR LIMIT=50]">Solevament pês</string>
+    <string name="wheelchair" description="Activity type: wheelchair. [CHAR LIMIT=50]">Cjadree cu lis rudielis</string>
+    <string name="workout" description="Activity type: generic workout. [CHAR LIMIT=50]">Alenament</string>
+    <string name="yoga" description="Activity type: yoga. [CHAR LIMIT=50]">Yoga</string>
+    <string name="arm_curl" description="Exercise type: arm curl. [CHAR LIMIT=50]">Flession dal braç</string>
+    <string name="ball_slam" description="Exercise type: ball slam. [CHAR LIMIT=50]">Batiment de bale</string>
+    <string name="double_arm_triceps_extension" description="Exercise type: double arm triceps extension. [CHAR LIMIT=50]">Estension tricipits cun ducj i doi i braçs</string>
+    <string name="dumbbell_row" description="Activity type: dumbbell row. [CHAR LIMIT=50]">Remadôr cun manuvri</string>
+    <string name="front_raise" description="Exercise type: front raise. [CHAR LIMIT=50]">Solevament frontâl</string>
+    <string name="hip_thrust" description="Exercise type: hip thrust. [CHAR LIMIT=50]">Solevament dal bacin</string>
+    <string name="hula_hoop" description="Exercise type: hula hoop. [CHAR LIMIT=50]">Hula hoop</string>
+    <string name="kettlebell_swing" description="Exercise type: kettlebell swing. [CHAR LIMIT=50]">Ossilazion cun kettlebell</string>
+    <string name="lateral_raise" description="Exercise type: lateral raise. [CHAR LIMIT=50]">Solevament laterâl</string>
+    <string name="leg_curl" description="Exercise type: leg curl. [CHAR LIMIT=50]">Flession des gjambis</string>
+    <string name="leg_extension" description="Exercise type: leg extension. [CHAR LIMIT=50]">Estension des gjambis</string>
+    <string name="leg_press" description="Exercise type: leg press. [CHAR LIMIT=50]">Pression des gjambis</string>
+    <string name="leg_raise" description="Exercise type: leg raise. [CHAR LIMIT=50]">Solevament des gjambis</string>
+    <string name="mountain_climber" description="Exercise type: mountain climber. [CHAR LIMIT=50]">Rimpinade sul puest</string>
+    <string name="pull_up" description="Exercise type: pull up. [CHAR LIMIT=50]">Trazion ae sbare</string>
+    <string name="punch" description="Exercise type: punch. [CHAR LIMIT=50]">Pugn</string>
+    <string name="shoulder_press" description="Exercise type: shoulder press. [CHAR LIMIT=50]">Presse spalis</string>
+    <string name="single_arm_triceps_extension" description="Exercise type: single arm triceps extension. [CHAR LIMIT=50]">Estension tricipits cun singul braç</string>
+    <string name="sit_up" description="Exercise type: sit up. [CHAR LIMIT=50]">Alçâsi impins</string>
+    <string name="rest" description="Auto-detected periods of rest during an activity session. There should be no user movement detected during rest and any movement detected should finish rest event. [CHAR LIMIT=50]">Polsâ</string>
+    <string name="pause" description="Explicit pause during an activity session, requested by the user. [CHAR LIMIT=50]">Pause</string>
+    <string name="activity_type_australian_football" translation_description="Activity type: playing australian football. [CHAR LIMIT=40]">Football australian</string>
+    <string name="sleep_session_default" description="Label that shows sleep session duration.[CHAR LIMIT=80]">Durmide di <xliff:g example="4 hours" id="duration"> %1$s</xliff:g></string>
+    <string name="sleep_stage_default" description="Label that shows sleep session duration.[CHAR LIMIT=80]"><xliff:g example="light sleep" id="name">%2$s</xliff:g> di <xliff:g example="4 hours" id="duration">%1$s</xliff:g></string>
+    <string name="sleep_stage_awake" description="Awake stage throughout the sleep session. [CHAR LIMIT=50]">dismot</string>
+    <string name="sleep_stage_awake_in_bed" description="Awake stage throughout the sleep session. [CHAR LIMIT=50]">dismot tal jet</string>
+    <string name="sleep_stage_sleeping" description="Sleeping stage throughout the sleep session. [CHAR LIMIT=50]">durmide</string>
+    <string name="sleep_stage_out_of_bed" description="Out of bed stage throughout the sleep session. [CHAR LIMIT=50]">fûr dal jet</string>
+    <string name="sleep_stage_rem" description="REM stage throughout the sleep session. [CHAR LIMIT=50]">polse REM</string>
+    <string name="sleep_stage_light" description="Light sleep stage throughout the sleep session. [CHAR LIMIT=50]">sium lizêr</string>
+    <string name="sleep_stage_deep" description="Deep sleep stage throughout the sleep session. [CHAR LIMIT=50]">sium profont</string>
+    <string name="sleep_stage_unknown" description="Unknown sleep stage throughout the sleep session. [CHAR LIMIT=50]">no cognossût</string>
+    <string translation_description="minute duration representation [CHAR LIMIT=8]" name="minute_duration"><xliff:g id="minute" example="1">%1$s</xliff:g>m</string>
+    <string translation_description="Hour and minute time duration representation [CHAR LIMIT=8]" name="hour_minute_duration_short"><xliff:g id="hour" example="1">%1$s</xliff:g>h <xliff:g id="min" example="31">%2$s</xliff:g>m</string>
+    <string translation_description="hour duration representation [CHAR LIMIT=8]" name="hour_duration"><xliff:g id="hour" example="1">%1$s</xliff:g>h</string>
+    <string name="hour_minute_duration_accessibility" translation_description="Hour and minute time duration representation used by accessibility, 'space' between minute and second should be deleted or replaced according to each language to translate [CHAR LIMIT=NONE]">  <xliff:g example="2 hours" id="hours">%1$s</xliff:g> <xliff:g example="2 minutes" id="minutes">%2$s</xliff:g>
+  </string>
+    <string translation_description="Hour time duration representation used by accessibility. [ICU SYNTAX][CHAR LIMIT=NONE]" name="hour_duration_accessibility">{count, plural, one {}=1 {1 ore} other {# oris}}</string>
+    <string translation_description="minute duration representation used by accessibility. [ICU SYNTAX][CHAR LIMIT=NONE]" name="minute_duration_accessibility">{count, plural, one {}=1 {1 minût} other {# minûts}}</string>
+    <string translation_description="Days duration representation [CHAR LIMIT=8]" name="day_duration"><xliff:g id="days" example="2 days">%1$s</xliff:g></string>
+    <string translation_description="Days and hours time duration representation [CHAR LIMIT=8]" name="day_hour_duration"><xliff:g id="days" example="2 days">%1$s</xliff:g> e <xliff:g id="hours" example="3 hours">%2$s</xliff:g></string>
+    <string translation_description="Days duration representation used by accessibility. [ICU SYNTAX][CHAR LIMIT=NONE]" name="day_duration_accessibility">{count, plural, one {}=1 {1 dì} other {# dîs}}</string>
+    <string name="vo2_max" description="VO₂ max value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1 mL/(kg·min)} other {# mL/(kg·min)}}</string>
+    <string name="vo2_max_long" description="VO₂ max value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1  mililitri di ossigjen par chilogram di masse corporie par minût} other {#  mililitris di ossigjen par chilogram di masse corporie par minût}}</string>
+    <string name="vo2_metabolic_cart" description="A method of VO₂ max measurement - metabolic cart. [CHAR LIMIT=50]">Carel metabolic</string>
+    <string name="vo2_heart_rate_ratio" description="A method of VO₂ max measurement - heart rate ratio. [CHAR LIMIT=50]">Rapuart de frecuence cardiache</string>
+    <string name="vo2_cooper_test" description="A method of VO₂ max measurement - Cooper test. [CHAR LIMIT=50]">Prove di Cooper</string>
+    <string name="vo2_multistage_fitness_test" description="A method of VO₂ max measurement - multistage fitness test. [CHAR LIMIT=50]">Provis di forme fisiche a plui fasis</string>
+    <string name="vo2_rockport_fitness_test" description="A method of VO₂ max measurement - Rockport fitness test [CHAR LIMIT=50]">Prove di forme fisiche di Rockport</string>
+    <string name="vo2_other" description="A method of VO₂ max measurement - other [CHAR LIMIT=50]">Altri</string>
+    <string name="mucus_dry" description="The consistency or texture of the user's cervical mucus - dry. [CHAR LIMIT=50]">Sec</string>
+    <string name="mucus_sticky" description="The consistency or texture of the user's cervical mucus - sticky. [CHAR LIMIT=50]">Tacadiç</string>
+    <string name="mucus_creamy" description="The consistency or texture of the user's cervical mucus - creamy. [CHAR LIMIT=50]">Cremôs</string>
+    <string name="mucus_watery" description="The consistency or texture of the user's cervical mucus - watery. [CHAR LIMIT=50]">Agadôs</string>
+    <string name="mucus_egg_white" description="The consistency or texture of the user's cervical mucus - Egg white. [CHAR LIMIT=50]">Blanc dal ûf</string>
+    <string name="mucus_unusual" description="The consistency or texture of the user's cervical mucus - unusual. [CHAR LIMIT=50]">Insolit</string>
+    <string name="mucus_light" description="The amount of the user's cervical mucus - light. [CHAR LIMIT=50]">Lizêr</string>
+    <string name="mucus_medium" description="The amount of the user's cervical mucus - medium. [CHAR LIMIT=50]">Medi</string>
+    <string name="mucus_heavy" description="The amount of the user's cervical mucus - heavy. [CHAR LIMIT=50]">Pesant</string>
+    <string name="blood_pressure" description="Blood pressure value with unit. [CHAR LIMIT=80]"><xliff:g example="120" id="systolic">%1$s</xliff:g>/<xliff:g example="80" id="diastolic">%2$s</xliff:g> mmHg</string>
+    <string name="blood_pressure_long" description="Blood pressure value with unit. [CHAR LIMIT=160]"><xliff:g example="120" id="systolic">%1$s</xliff:g>/<xliff:g example="80" id="diastolic">%2$s</xliff:g> milimetri di mercuri</string>
+    <string name="body_position_standing_up" description="Body position when taking blood pressure - standing up. [CHAR LIMIT=50]">Impins</string>
+    <string name="body_position_sitting_down" description="Body position when taking blood pressure - sitting down. [CHAR LIMIT=50]">Sentât</string>
+    <string name="body_position_lying_down" description="Body position when taking blood pressure - lying down. [CHAR LIMIT=50]">Distirât</string>
+    <string name="body_position_reclining" description="Body position when taking blood pressure - reclining. [CHAR LIMIT=50]">Poiât</string>
+    <string name="blood_pressure_left_wrist" description="Body part where the blood pressure was taken - left wrist. [CHAR LIMIT=50]">Conole di çampe</string>
+    <string name="blood_pressure_right_wrist" description="Body part where the blood pressure was taken - right wrist. [CHAR LIMIT=50]">Conole di diestre</string>
+    <string name="blood_pressure_left_arm" description="Body part where the blood pressure was taken - left upper arm. [CHAR LIMIT=50]">Part superiôr dal braç di çampe</string>
+    <string name="blood_pressure_right_arm" description="Body part where the blood pressure was taken - right upper arm. [CHAR LIMIT=50]">Part superiôr dal braç di diestre</string>
+    <string name="millimoles_per_liter" description="Blood glucose value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{count, plural, one {}=1 {1 mmol/L} other {# mmol/L}}</string>
+    <string name="millimoles_per_liter_long" description="Blood glucose value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{count, plural, one {}=1 {1 milimole par litri} other {# milimolis par litri}}</string>
+    <string name="specimen_source_interstitial_fluid" description="Source of the blood glucose measurement - interstitial fluid. [CHAR LIMIT=50]">Fluit interstiziâl</string>
+    <string name="specimen_source_capillary_blood" description="Source of the blood glucose measurement - capillary blood. [CHAR LIMIT=50]">Sanc capilâr</string>
+    <string name="specimen_source_plasma" description="Source of the blood glucose measurement - plasma. [CHAR LIMIT=50]">Plasme</string>
+    <string name="specimen_source_serum" description="Source of the blood glucose measurement - serum. [CHAR LIMIT=50]">Sîr</string>
+    <string name="specimen_source_tears" description="Source of the blood glucose measurement - tears. [CHAR LIMIT=50]">Lagrimis</string>
+    <string name="specimen_source_whole_blood" description="Source of the blood glucose measurement - whole blood. [CHAR LIMIT=50]">Sanc intîr</string>
+    <string name="blood_glucose_general" description="Relationship of the meal to the blood glucose measurement - general. [CHAR LIMIT=50]">Gjenerâl</string>
+    <string name="blood_glucose_fasting" description="Relationship of the meal to the blood glucose measurement - fasting. [CHAR LIMIT=50]">A dizun</string>
+    <string name="blood_glucose_before_meal" description="Relationship of the meal to the blood glucose measurement - before meal. [CHAR LIMIT=50]">Prime di mangjâ</string>
+    <string name="blood_glucose_after_meal" description="Relationship of the meal to the blood glucose measurement - after meal. [CHAR LIMIT=50]">Dopo mangjât</string>
+    <string name="mealtype_label" description="Meal type label, displayed when showing a nutrition entry. [CHAR LIMIT=50]">Gjenar di past</string>
+    <string name="mealtype_unknown" description="Unknown meal type, displayed when showing a nutrition entry. [CHAR LIMIT=50]">No cognossût</string>
+    <string name="mealtype_breakfast" description="Breakfast, a meal type, usually eaten as a first meal in the day, in the morning, displayed when showing a nutrition entry. [CHAR LIMIT=50]">Gulizion</string>
+    <string name="mealtype_lunch" description="Lunch, a meal type, eaten in the middle of the day, displayed when showing a nutrition entry. [CHAR LIMIT=50]">Gustâ</string>
+    <string name="mealtype_dinner" description="Dinner, a meal type, usually eaten as a last warm meal of the day, displayed when showing a nutrition entry. [CHAR LIMIT=50]">Cene</string>
+    <string name="mealtype_snack" description="Snack, a meal type, eaten in between big meals, displayed when showing a nutrition entry. [CHAR LIMIT=50]">Mirinde</string>
+    <string name="biotin" description="Biotin, also called vitamin B7, one of the vitamins found in food. [CHAR LIMIT=50]">Biotine</string>
+    <string name="caffeine" description="Caffeine, a chemical with stimulant effects, found in food and drink. [CHAR LIMIT=50]">Cafeine</string>
+    <string name="calcium" description="Calcium, a nutrient associated with bones and teeth. [CHAR LIMIT=50]">Calci</string>
+    <string name="chloride" description="Chloride, a crucial electrolyte responsible for proper blood volume and pressure. [CHAR LIMIT=50]">Clorûr</string>
+    <string name="cholesterol" description="Dietary cholesterol, found in animal based food. [CHAR LIMIT=50]">Colesterôl</string>
+    <string name="chromium" description="Chromium, an essential nutrient required for sugar and fat metabolism. [CHAR LIMIT=50]">Crom</string>
+    <string name="copper" description="Copper,a nutrient which, together with iron, enables the body to form red blood cells. [CHAR LIMIT=50]">Ram</string>
+    <string name="dietary_fiber" description="Dietary fiber, also known as roughage, is the indigestible part of plant foods. [CHAR LIMIT=50]">Fibre alimentâr</string>
+    <string name="energy_consumed_total" description="Kcal or Kj found in consumed food. [CHAR LIMIT=50]">Energjie</string>
+    <string name="energy_consumed_from_fat" description="Kcal or Kj found in consumed food, coming from consuming fat. [CHAR LIMIT=50]">Energjie dai gras</string>
+    <string name="folate" description="Folate is the natural form of vitamin B9. [CHAR LIMIT=50]">Folât</string>
+    <string name="folic_acid" description="Folic acid, also known as vitamin B₉ and folacin, is one of the B vitamins. [CHAR LIMIT=50]">Acit folic</string>
+    <string name="iodine" description="Iodine is a mineral used by the thyroid gland to make thyroid hormones. [CHAR LIMIT=50]">Jodi</string>
+    <string name="iron" description="Iron, a mineral that helps maintain healthy blood. [CHAR LIMIT=50]">Fier</string>
+    <string name="magnesium" description="Magnesium, a macromineral found in nuts and leafy greens. [CHAR LIMIT=50]">Magnesi</string>
+    <string name="manganese" description="Manganese, a micromineral found in nuts and leafy greens. [CHAR LIMIT=50]">Manganês</string>
+    <string name="molybdenum" description="Molybdenum, a mineral which activates enzymes that help break down harmful sulfites and prevent toxins from building up in the body. [CHAR LIMIT=50]">Molibden</string>
+    <string name="monounsaturated_fat" description="Monosaturated fat, fat molecules that have one unsaturated carbon bond in the molecule. Monounsaturated fatty acids (MUFAs) are a healthy type of fa [CHAR LIMIT=50]">Gras monoinsaturs</string>
+    <string name="niacin" description="Niacin, also known as nicotinic acid, is an organic compound and a form of vitamin B3. [CHAR LIMIT=50]">Niacine</string>
+    <string name="pantothenic_acid" description="Pantothenic acid, also called vitamin B5. [CHAR LIMIT=50]">Acit pantotenic</string>
+    <string name="phosphorus" description="Phosphorus, a mineral that works with calcium to help build bones. [CHAR LIMIT=50]">Fosfar</string>
+    <string name="polyunsaturated_fat" description="Polyunsaturated fat is a type of dietary fat. It is one of the healthy fats, along with monounsaturated fat. [CHAR LIMIT=50]">Gras polinsaturs</string>
+    <string name="potassium" description="Potassium, a mineral with main role in the body to help maintain normal levels of fluid inside our cells. [CHAR LIMIT=50]">Potassi</string>
+    <string name="protein" description="Protein, a macronutrient, one of the building blocks of body tissue and can also serve as a fuel source. [CHAR LIMIT=50]">Proteine</string>
+    <string name="riboflavin" description="Riboflavin, also known as vitamin B2. [CHAR LIMIT=50]">Riboflavine</string>
+    <string name="saturated_fat" description="Saturated fat, one of the unhealthy fats, along with trans fat, found in food. [CHAR LIMIT=50]">Gras saturs</string>
+    <string name="selenium" description="Selenium, an essential trace mineral that supports many bodily processes. [CHAR LIMIT=50]">Seleni</string>
+    <string name="sodium" description="Sodium is an essential nutrient and is needed by the body in relatively small amounts. [CHAR LIMIT=50]">Sodi</string>
+    <string name="sugar" description="Sugar is the generic name for sweet-tasting, soluble carbohydrates, many of which are used in food. [CHAR LIMIT=50]">Sucar</string>
+    <string name="thiamin" description="Thiamin, also known as thiamine and vitamin B1. [CHAR LIMIT=50]">Tiamine</string>
+    <string name="total_carbohydrate" description="total carbohydrates includes all types of carbohydrate found in the food or beverage. [CHAR LIMIT=50]">Carboidrâts totâi</string>
+    <string name="total_fat" description="Total fat indicates how much fat is in a single serving of food. [CHAR LIMIT=50]">Gras totâi</string>
+    <string name="trans_fat" description="Trans fat, also called trans-unsaturated fatty acids or trans fatty acids, is a type of unsaturated fat that is considered the most unhealthy. [CHAR LIMIT=50]">Gras trans</string>
+    <string name="unsaturated_fat" description="Unsaturated fats help lower a person's levels of LDL cholesterol. [CHAR LIMIT=50]">Gras insaturs</string>
+    <string name="vitamin_a" description="Vitamin A, also known as retinol, is key for good vision, a healthy immune system, and cell growth. [CHAR LIMIT=50]">Vitamine A</string>
+    <string name="vitamin_b12" description="Vitamin B12, also known as cobalamin, is a water-soluble vitamin involved in metabolism. [CHAR LIMIT=50]">Vitamine B12</string>
+    <string name="vitamin_b6" description="Vitamin B6 is one of the B vitamins, and thus an essential nutrient. [CHAR LIMIT=50]">Vitamine B6</string>
+    <string name="vitamin_c" description="Vitamin C is a water-soluble vitamin found in various foods and sold as a dietary supplement. [CHAR LIMIT=50]">Vitamine C</string>
+    <string name="vitamin_d" description="Vitamin D helps regulate the amount of calcium and phosphate in the body. [CHAR LIMIT=50]">Vitamine D</string>
+    <string name="vitamin_e" description="Vitamin E is an important fat-soluble nutrient. It's a powerful antioxidant and is needed for immune health and cellular signaling in your body. [CHAR LIMIT=50]">Vitamine E</string>
+    <string name="vitamin_k" description="Vitamin K is a group of vitamins that the body needs for blood clotting, helping wounds to heal. [CHAR LIMIT=50]">Vitamine K</string>
+    <string name="zinc" description="Zinc is a trace mineral necessary for almost 100 enzymes to carry out vital chemical reactions. [CHAR LIMIT=50]">Zinc</string>
+    <string name="nutrient_with_value" description="Used for formatting nutrition data. Example: Copper: 29g [CHAR LIMIT=50]"><xliff:g example="Copper" id="nutrient">%1$s</xliff:g>: <xliff:g example="29g" id="amount">%2$s</xliff:g></string>
+    <string name="meal_name" description="Name for food or drink provided by the user. [CHAR LIMIT=50]">Non</string>
+    <string name="gram_short_format" description="Weight in grams. [ICU SYNTAX][CHAR LIMIT=80]">{count, plural, one {}=1 {1 g} other {# g}}</string>
+    <string name="gram_long_format" description="Weight in grams. [ICU SYNTAX][CHAR LIMIT=160]">{count, plural, one {}=1 {1 gram} other {# grams}}</string>
+    <string translation_description="Value of respiratory rate. rpm is short for 'respirations per minute'. [ICU SYNTAX][CHAR LIMIT=18]" name="respiratory_rate_value">{count, plural, one {}=1 {1 rpm} other {# rpm}}</string>
+    <string translation_description="Value of respiratory rate in respirations per minute. [ICU SYNTAX][CHAR LIMIT=26]" name="respiratory_rate_value_long">{count, plural, one {}=1 {1 respirazion par minût} other {# respirazions par minût}}</string>
+    <string translation_description="Weight in kilograms. [ICU SYNTAX][CHAR LIMIT=60]" name="kilograms_short_label">{count, plural, one {}=1 {1 kg} other {# kg}}</string>
+    <string translation_description="Weight in pounds. [ICU SYNTAX][CHAR LIMIT=60]" name="pounds_short_label">{count, plural, one {}=1 {1 lb} other {# lb}}</string>
+    <string translation_description="Weight in stone. [ICU SYNTAX][CHAR LIMIT=60]" name="stone_short_label">{count, plural, one {}=1 {1 st} other {# st}}</string>
+    <string translation_description="Weight in stone and pounds. Example: 9st 2lb. [ICU][CHAR LIMIT=60]" name="stone_pound_short_label">{stone_part} {pound_part}</string>
+    <string translation_description="Weight in kilograms representation used by accessibility. [ICU SYNTAX][CHAR LIMIT=60]" name="kilograms_long_label">{count, plural, one {}=1 {1 chilogram} other {# chilograms}}</string>
+    <string translation_description="Weight in pounds representation used by accessibility. [ICU SYNTAX][CHAR LIMIT=60]" name="pounds_long_label">{count, plural, one {}=1 {1 lire} other {# liris}}</string>
+    <string translation_description="Weight in stone representation used by accessibility. [ICU SYNTAX][CHAR LIMIT=60]" name="stone_long_label">{count, plural, one {}=1 {1 stone} other {# stones}}</string>
+    <string translation_description="Weight in stone and pounds representation used by accessibility. Example: 9 stone, 2 pounds. [ICU][CHAR LIMIT=60]" name="stone_pound_long_label">{stone_part} {pound_part}</string>
+    <string name="temperature_celsius" description="Temperature value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1 ℃} other {# ℃}}</string>
+    <string name="temperature_celsius_long" description="Temperature value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1 grât Celsius} other {# grâts Celsius}}</string>
+    <string name="temperature_kelvin" description="Temperature value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1 K} other {# K}}</string>
+    <string name="temperature_kelvin_long" description="Temperature value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1 kelvin} other {# kelvins}}</string>
+    <string name="temperature_fahrenheit" description="Temperature value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1 ℉} other {# ℉}}</string>
+    <string name="temperature_fahrenheit_long" description="Temperature value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1 grât Fahrenheit} other {# grâts Fahrenheit}}</string>
+    <string name="temperature_location_armpit" description="Where the body temperature measurement was taken - armpit. [CHAR LIMIT=50]">Lesine</string>
+    <string name="temperature_location_finger" description="Where the body temperature measurement was taken - finger. [CHAR LIMIT=50]">Dêt</string>
+    <string name="temperature_location_forehead" description="Where the body temperature measurement was taken - forehead. [CHAR LIMIT=50]">Cerneli</string>
+    <string name="temperature_location_mouth" description="Where the body temperature measurement was taken - mouth. [CHAR LIMIT=50]">Bocje</string>
+    <string name="temperature_location_rectum" description="Where the body temperature measurement was taken - rectum. [CHAR LIMIT=50]">Ret (cûl)</string>
+    <string name="temperature_location_temporal_artery" description="Where the body temperature measurement was taken - temporal artery. [CHAR LIMIT=50]">Arterie temporâl</string>
+    <string name="temperature_location_toe" description="Where the body temperature measurement was taken - toe. [CHAR LIMIT=50]">Ponte dal dêt</string>
+    <string name="temperature_location_ear" description="Where the body temperature measurement was taken - ear. [CHAR LIMIT=50]">Orele</string>
+    <string name="temperature_location_wrist" description="Where the body temperature measurement was taken - wrist. [CHAR LIMIT=50]">Conole</string>
+    <string name="temperature_location_vagina" description="Where the body temperature measurement was taken - vagina. [CHAR LIMIT=50]">Vagjine</string>
+    <string translation_description="miles formatted. [ICU SYNTAX][CHAR LIMIT=60]" name="distance_miles">{dist, plural, one {}=1 {1 mie} other {# miis}}</string>
+    <string translation_description="Kilometers formatted. [ICU SYNTAX][CHAR LIMIT=60]" name="distance_km">{dist, plural, one {}=1 {1 km} other {# km}}</string>
+    <string translation_description="miles formatted for speech. [ICU SYNTAX][CHAR LIMIT=NONE]" name="distance_miles_long">{dist, plural, one {}=1 {1 mie} other {# miis}}</string>
+    <string translation_description="Kilometers formatted for speech. [ICU SYNTAX][CHAR LIMIT=NONE]" name="distance_km_long">{dist, plural, one {}=1 {1 chilometri} other {# chilometris}}</string>
+    <string translation_description="Height in centimeters. [ICU SYNTAX][CHAR LIMIT=10]" name="height_cm">{height, plural, one {}=1 {1 cm} other {# cm}}</string>
+    <string translation_description="Height in centimeters. [ICU SYNTAX][CHAR LIMIT=30]" name="height_cm_long">{height, plural, one {}=1 {1 centimetri} other {# centimetris}}</string>
+    <string translation_description="Height measurement part in inches. [ICU SYNTAX][CHAR LIMIT=30]" name="height_in_long">{height, plural, one {}=1 {1 once} other {# oncis}}</string>
+    <string translation_description="Height measurement part in feet. [ICU SYNTAX][CHAR LIMIT=30]" name="height_ft_long">{height, plural, one {}=1 {1 pît} other {# pîts}}</string>
+    <string translation_description="Height measurement part in inches compacted. [ICU SYNTAX][CHAR LIMIT=5]" name="height_in_compacted">{height, plural, one {}=1 {1\u2033} other {#\u2033}}</string>
+    <string translation_description="Height measurement part in feet compacted. [ICU SYNTAX][CHAR LIMIT=5]" name="height_ft_compacted">{height, plural, one {}=1 {1\u2032} other {#\u2032}}</string>
+    <string translation_description="Format for displaying height in feet and inches in compacted form e.g. 5′11″ [CHAR LIMIT=10]" name="feet_inches_format"><xliff:g id="ft" example="5′">%1$s</xliff:g><xliff:g id="in" example="11″">%2$s</xliff:g></string>
+    <string translation_description="Format for displaying height in feet and inches in long form e.g. 5 feet 11 inches [CHAR LIMIT=60]" name="feet_inches_format_long"><xliff:g id="ft" example="5 feet">%1$s</xliff:g> <xliff:g id="in" example="11 inches">%2$s</xliff:g></string>
+    <string translation_description="Calories formatted. [ICU SYNTAX][CHAR LIMIT=60]" name="calories_long">{count, plural, one {}=1 {1 calorie} other {# caloriis}}</string>
+    <string translation_description="Calories formatted. [ICU SYNTAX][CHAR LIMIT=60]" name="calories">{count, plural, one {}=1 {1 Cal} other {# Cal}}</string>
+    <string translation_description="KiloJoules (the energy unit) formatted. [ICU SYNTAX][CHAR LIMIT=20]" name="kj">{count, plural, one {}=1 {1 kJ} other {# kJ}}</string>
+    <string translation_description="KiloJoules (the energy unit) formatted to be spoken aloud. [ICU SYNTAX][CHAR LIMIT=20]" name="kj_long">{count, plural, one {}=1 {1 chilojoule} other {# chilojoules}}</string>
+    <string name="percent" formatted="false" description="Percentage value with unit. [ICU SYNTAX][CHAR LIMIT=80]">{value, plural, one {}=1 {1%} other {#%}}</string>
+    <string name="percent_long" description="Percentage value with unit. [ICU SYNTAX][CHAR LIMIT=160]">{value, plural, one {}=1 {1 par cent} other {# par cent}}</string>
+    <string name="units_cancel" description="Label for button to cancel changing units. [CHAR_LIMIT=20]">Cancele</string>
+    <string name="units_title" description="Title on a screen allowing users to go to display units (weight/height/temperature etc) in the app[CHAR_LIMIT=50]">Unitâts</string>
+    <string name="set_units_label" description="Label in the drop down menu, allowing users to go to display units (weight/height/temperature etc) in the app [CHAR_LIMIT=50]">Stabilìs unitâts dai dâts</string>
+    <string name="distance_unit_title" description="Label of a unit preference in settings, allowing the user to change height display unit in the app [CHAR_LIMIT=50]">Distance</string>
+    <string name="height_unit_title" description="Label of a unit preference in settings, allowing the user to change height display unit in the app [CHAR_LIMIT=50]">Altece</string>
+    <string name="weight_unit_title" description="Label of a unit preference in settings, allowing the user to change height display unit in the app [CHAR_LIMIT=50]">Pês</string>
+    <string name="energy_unit_title" description="Label of a unit preference in settings, allowing the user to change height display unit in the app [CHAR_LIMIT=50]">Energjie</string>
+    <string name="temperature_unit_title" description="Label of a unit preference in settings, allowing the user to change height display unit in the app [CHAR_LIMIT=50]">Temperadure</string>
+    <string name="distance_unit_kilometers_label" translation_description="The label for the metric option within the distance unit preferences menu. [CHAR LIMIT=19]">Chilometris</string>
+    <string name="distance_unit_miles_label" translation_description="The label for the imperial option within the distance unit preferences menu. [CHAR LIMIT=19]">Miis</string>
+    <string name="height_unit_centimeters_label" translation_description="The label for the metric option within the height unit preferences menu. [CHAR LIMIT=19]">Centimetris</string>
+    <string name="height_unit_feet_label" translation_description="The label for the imperial option within the height unit preferences menu. [CHAR LIMIT=19]">Pîts e oncis</string>
+    <string name="weight_unit_pound_label" translation_description="The label for the pound option within the weight unit preferences menu. [CHAR LIMIT=19]">Liris</string>
+    <string name="weight_unit_kilogram_label" translation_description="The label for the Kilogram option within the weight unit preferences menu. [CHAR LIMIT=19]">Chilograms</string>
+    <string name="weight_unit_stone_label" translation_description="The label for the Stone option within the weight unit preferences menu. [CHAR LIMIT=19]">Stones</string>
+    <string name="energy_unit_calorie_label" translation_description="The label for the calorie option within the energy unit preferences menu. [CHAR LIMIT=19]">Caloriis</string>
+    <string name="energy_unit_kilojoule_label" translation_description="The label for the Kilojoule option within the energy unit preferences menu. [CHAR LIMIT=19]">Chilojoules</string>
+    <string name="temperature_unit_celsius_label" translation_description="The label for the Celsius option within the weight unit preferences menu. [CHAR LIMIT=19]">Celsius</string>
+    <string name="temperature_unit_fahrenheit_label" translation_description="The label for the Fahrenheit option within the weight unit preferences menu. [CHAR LIMIT=19]">Fahrenheit</string>
+    <string name="temperature_unit_kelvin_label" translation_description="The label for the Kelvin option within the weight unit preferences menu. [CHAR LIMIT=19]">Kelvin</string>
+    <string name="help_and_feedback" description="Label used to display help and feedback">Jutori e valutazions</string>
+    <string name="cant_see_all_your_apps_description" description="Description of can't see all your apps screen">Se no tu viodis une aplicazion che e je instalade, al è pussibil che no sedi ancjemò compatibile cun Conession salût</string>
+    <string name="things_to_try" description="Label used to show how user can try with different options">Robis di provâ</string>
+    <string name="check_for_updates" description="Label for a button that is used to check for updates">Controle i inzornaments</string>
+    <string name="check_for_updates_description" description="Content description for a button that is used to check for updates">Verifiche che lis aplicazions instaladis a sedin inzornadis</string>
+    <string name="see_all_compatible_apps" description="Label for a button that is used to show all compatible apps on Google Play">Viôt dutis lis aplicazions compatibilis</string>
+    <string name="see_all_compatible_apps_description" description="Content description for a button that is used to show all compatible apps on Google Play">Cjate lis aplicazions su Google Play</string>
+    <string name="send_feedback" description="Label for a button that is used to send feedback">Mande opinion</string>
+    <string name="send_feedback_description" description="Content description for a button that is used to send feedback">Continus cualis aplicazions di salût e forme fisiche che tu desideris che a funzionin cun Conession salût</string>
+    <string name="playstore_app_title" description="Navigates to the Play Store and shows a collection of apps compatible with Health Connect [CHAR_LIMIT=40]">Play Store</string>
+    <string name="auto_delete_button" description="Label for a button that open the auto-deletion settings. [CHAR_LIMIT=50]">Auto-elimine</string>
+    <string name="auto_delete_title" description="Title of screen for a user to manage the auto-deletion settings [CHAR_LIMIT=40]">Auto-elimine</string>
+    <string name="auto_delete_header" description="Description for the auto-delete settings page. [CHAR_LIMIT=NONE]">Controle par trop timp che a restin memorizâts i tiei dâts in Conession salût programant la lôr eliminazion dopo un ciert timp</string>
+    <string name="auto_delete_learn_more" description="Label of a link that helps to learn more about auto-delete. [CHAR_LIMIT=50]">Scuvierç di plui su la eliminazion automatiche</string>
+    <string name="auto_delete_section" description="Label for a section that picks the time range for auto-deletion. [CHAR_LIMIT=50]">Auto-elimine i dâts</string>
+    <string name="range_after_x_months" description="Item in a list of possible time ranges for auto-deletion. Choosing this will automatically delete data older than x months. [CHAR_LIMIT=50]">{count, plural, one {}=1{Dopo # mês}other{Dopo # mês}}</string>
+    <string name="range_never" description="Item in a list of possible time ranges for auto-deletion. Choosing this will never delete data automatically. [CHAR_LIMIT=50]">Mai</string>
+    <string name="range_off" description="Summary of the auto-delete button when auto-delete is set to never. [CHAR_LIMIT=50]">Off</string>
+    <string name="auto_delete_rationale" description="Footer note explaining that after changing auto-delete settings, corresponding data will be deleted. [CHAR_LIMIT=NONE]">Cuant che tu cambiis chestis impostazions, Conession salût al elimine i dâts esistents par rifleti lis tôs gnovis preferencis</string>
+    <string name="confirming_question_x_months" description="Title of a dialog that asks the user to confirm whether they want to auto-delete all data that is older than x months. [CHAR_LIMIT=NONE]">{count, plural,
+    one {}=1{Auto-eliminâ i dâts dopo # mês?}
+    other{Auto-eliminâ i dâts dopo # mês?}
+  }</string>
+    <string name="confirming_message_x_months" description="Description to explain what auto-deleting data older than x months means. [CHAR_LIMIT=NONE]">{count, plural,
+    one {}=1{Conession salût al eliminarà in automatic i gnûfs dâts dopo # mês. La configurazion di cheste opzion e puartarà ancje ae eliminazion dai dâts esistents plui vecjos di # mês.}
+    other{Conession salût al eliminarà in automatic i gnûfs dâts dopo # mês. La configurazion di cheste opzion e puartarà ancje ae eliminazion dai dâts esistents plui vecjos di # mês.}
+  }</string>
+    <string name="set_auto_delete_button" description="Label of a button that sets the chosen auto-delete setting. [CHAR_LIMIT=50]">Stabilìs auto-eliminazion</string>
+    <string name="deletion_started_title" description="Title of a dialog that lets the user know about some existing data being deleted. [CHAR_LIMIT=50]">I dâts esistents a vignaran eliminâts</string>
+    <string name="deletion_started_x_months" description="Description explaining what deleting data older than x months means and when the changes will be visible. [CHAR_LIMIT=NONE]">{count, plural,
+    one {}=1{Conession salût al eliminarà ducj i dâts plui vecjos di # mês. Par viodi chestis modifichis tes tôs aplicazions colegadis al è pussibil che e passi une zornade.}
+    other{Conession salût al eliminarà ducj i dâts plui vecjos di # mês. Par viodi chestis modifichis tes tôs aplicazions colegadis al è pussibil che e passi une zornade.}
+  }</string>
+    <string name="deletion_started_category_list_section" description="Title of a section that lists those categories where data will be deleted from. [CHAR_LIMIT=NONE]">Dâts di eliminâ di chescj</string>
+    <string name="deletion_started_done_button" description="Button that closes the dialog. [CHAR_LIMIT=40]">Fat</string>
+    <string name="priority_dialog_title" description="Window title where user can set the priority order of apps. [CHAR_LIMIT=50]">Stabilìs prioritât aplicazions</string>
+    <string name="priority_dialog_message" description="Description of the dar-and-drop list of apps that is modifiable by the user. [CHAR_LIMIT=NONE]">Se plui di une aplicazion e zonte dâts di <xliff:g id="data_type" example="heart rate">%s</xliff:g>, Conession salût al da prioritât ae aplicazion plui insom di cheste liste. Strissine lis aplicazions par rangjâlis.</string>
+    <string name="priority_dialog_positive_button" description="Label of the button that saves modifications made by the user. [CHAR_LIMIT=50]">Salve</string>
+    <string name="action_drag_label_move_up" description="Label for an accessibility action that moves an app up in the ordered app priority list [CHAR LIMIT=50]">Môf insù</string>
+    <string name="action_drag_label_move_down" description="Label for an accessibility action that moves an app down in the ordered app priority list [CHAR LIMIT=50]">Môf injù</string>
+    <string name="action_drag_label_move_top" description="Label for an accessibility action that moves an app to the top of the ordered app priority list [CHAR LIMIT=50]">Môf insom</string>
+    <string name="action_drag_label_move_bottom" description="Label for an accessibility action that moves an app to the bottom of the ordered app priority list [CHAR LIMIT=50]">Môf da pît</string>
+    <string name="search_keywords_home" description="A list of search terms used to search Health Connect in the Settings app. The terms aren’t shown to users. [CHAR LIMIT=NONE]">forme fisiche, benstâ</string>
+    <string name="search_keywords_permissions" description="A list of search terms used to search Health Connect in the Settings app. The terms aren’t shown to users. [CHAR LIMIT=NONE]">permès</string>
+    <string name="search_keywords_data" description="A list of search terms used to search Health Connect in the Settings app. The terms aren’t shown to users. [CHAR LIMIT=NONE]">conession salût, dâts di salût, categoriis de salût, acès ai dâts, ativitât, misurazions cuarp, tignî di voli i ciclis, nutrizion, polse, orghins vitâi</string>
+    <string name="search_breadcrumbs_permissions" description="The path to find permissions screen in Settings, shown in search results. [CHAR LIMIT=70]">Conession salût &gt; Permès aplicazion</string>
+    <string name="search_breadcrumbs_data" description="The path to find data and access screen in Settings, shown in search results. [CHAR LIMIT=70]">Conession salût &gt; Dâts e acès</string>
+    <string name="search_connected_apps" description="Hint shown on search input field">Cîr tes aplicazions</string>
+    <string name="no_results" description="Content shown when there is no search result">Nissun risultât</string>
+    <string name="help" description="Menu option for accessing help [CHAR LIMIT=50]">Jutori</string>
+    <string name="request_route_header_title" description="Title for screen to give permissions to an app to access a route for an exercise session. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]">Permeti a <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> di acedi a chest percors di esercizi in Conession salût?</string>
+    <string name="request_route_disclaimer_notice" description="A note on a dialog asking to grant access to a specific exercise route, stressing the fact that the route contains past locations of the user. [CHAR_LIMIT=NONE]">Cheste aplicazion e rivarà a lei lis tôs posizions passadis intal percors</string>
+    <string name="date_owner_format" description="Format for displaying a date attributed to the data and the name of the application the data comes from. Example: Mon 13 Jun - Nokia Health Mate. [CHAR LIMIT=NONE]"><xliff:g example="Mon 13 Jun" id="date">%1$s</xliff:g> \u2022 <xliff:g example="Nokia Health Mate" id="app_name">%2$s</xliff:g></string>
+    <string name="request_route_info_header_title" description="Title for screen explaining in more detail what it means to give permissions to an app to access a route for an exercise session. [CHAR_LIMIT=NONE]">I percors dai esercizis a includin lis informazions su la posizion</string>
+    <string name="request_route_info_who_can_see_data_title" description="Title for the section explaining in more detail what it means to give permissions to an app to access a route for an exercise session and who will have access to the data. [CHAR_LIMIT=NONE]">Cui puedial viodi chest dât?</string>
+    <string name="request_route_info_who_can_see_data_summary" description="Summary of the section explaining in more detail what it means to give permissions to an app to access a route for an exercise session and who will have access to the data. [CHAR_LIMIT=NONE]">Dome lis aplicazions che a ricevin il to permès di acès ai percors dai tiei esercizis</string>
+    <string name="request_route_info_access_management_title" description="Title for the section explaining in more detail what it means to give permissions to an app to access a route for an exercise session and how to manage the access. [CHAR_LIMIT=NONE]">Cemût puedio gjestî l\'acès?</string>
+    <string name="request_route_info_access_management_summary" description="Summary of the section explaining in more detail what it means to give permissions to an app to access a route for an exercise session and and how to manage the access. Note: Health Connect is the brand. [CHAR_LIMIT=NONE]">Tu puedis gjestî l\'acès de aplicazion ai percors dai esercizis intes impostazions di Conession salût</string>
+    <string name="back_button" description="Label on the back button. [CHAR_LIMIT=20]">Indaûr</string>
+    <string name="loading" description="Label shown when loading data. [CHAR_LIMIT=40]">Daûr a cjariâ…</string>
+    <string name="migration_in_progress_screen_title" description="Title of screen shown when migration is in progress">Integrazion in cors</string>
+    <string name="migration_in_progress_screen_integration_details" description="Detail information shown when migration is in progress">Conession salût si sta integrant cul sisteme Android.\n\nAl podarès lâ vie un pôc di timp prime che i tiei dâts e i permès a sedin trasferîts.</string>
+    <string name="migration_in_progress_screen_integration_dont_close" description="Instruction to not close application shown when migration is in progress">No stas sierâ la aplicazion fintremai che no tu ricevis la notifiche che il procès al è stât completât.</string>
+    <string name="migration_in_progress_notification_title" description="Title of notification sent when migration is in progress">Integrazion di Conession salût in cors</string>
+    <string name="migration_update_needed_screen_title" description="Title of screen shown when migration is pending and an update is needed.">Inzornament necessari</string>
+    <string name="migration_update_needed_screen_details" description="Detail information shown when migration is pending and an update is needed.">Conession salût si sta integrant cul sisteme Android in mût che tu podedis doprâlu dret da lis impostazions.</string>
+    <string name="update_button" description="Text of a button prompting the user to update an app or their phone system [CHAR_LIMIT=40]">Inzorne</string>
+    <string name="migration_update_needed_notification_content" description="Content of notification sent when migration is pending and an app or module update is needed.">Scomence chest inzornament in mût che Conession salût al podedi continuâ la integrazion cu lis impostazions dal sisteme</string>
+    <string name="migration_update_needed_notification_action" description="Action of notification sent when migration is pending and an app or module update is needed.">Inzorne daurman</string>
+    <string name="migration_module_update_needed_notification_title" description="Title of notification sent when migration is pending and an app or module update is needed.">Inzornament di sisteme necessari</string>
+    <string name="migration_module_update_needed_action" description="Action information shown when migration is pending and a system update is needed.">Prime di continuâ, inzorne il sisteme dal to telefon.</string>
+    <string name="migration_module_update_needed_restart" description="Detail information shown when migration is pending and one update is needed.">Se tu âs za inzornât il sisteme dal telefon, prove a tornâ a inviâlu par continuâ la integrazion</string>
+    <string name="migration_app_update_needed_notification_title" description="Title of notification sent when migration is pending and an app or module update is needed.">Inzornament di Conession salût necessari</string>
+    <string name="migration_app_update_needed_action" description="Action information shown when migration is pending and an app update is needed.">Prime di continuâ, inzorne la aplicazion di Conession salût ae ultime version.</string>
+    <string name="migration_more_space_needed_screen_title" description="Title of screen shown when migration is pending and more space is needed.">Al covente plui spazi</string>
+    <string name="migration_more_space_needed_screen_details" description="Detail information shown when migration is pending and more space is needed.">Par podê continuâ la integrazion, Conession salût al à bisugne di <xliff:g example="500MB" id="space_needed">%1$s</xliff:g> di spazi di memorie sul telefon.\n\nNete vie un pôc di spazi sul telefon e torne prove.</string>
+    <string name="try_again_button" description="Text of a button prompting the user to try looking at the space again [CHAR_LIMIT=40]">Torne prove</string>
+    <string name="free_up_space_button" description="Text of a button leading the user to their system storage so they can free up space. [CHAR_LIMIT=40]">Libere spazi</string>
+    <string name="migration_more_space_needed_notification_title" description="Title of notification sent when migration is pending and more space is needed.">Al covente plui spazi</string>
+    <string name="migration_more_space_needed_notification_content" description="Content of notification sent when migration is pending and more space is needed.">Par podê continuâ la integrazion, Conession salût al à bisugne di <xliff:g example="500MB" id="space_needed">%1$s</xliff:g> di spazi di memorie di archiviazion sul telefon.</string>
+    <string name="migration_paused_screen_title" description="Title of screen shown when migration has been paused.">Integrazion in pause</string>
+    <string name="migration_paused_screen_details" description="Detail information shown when migration has been paused.">La aplicazion Conession salût si è sierade intant che si stave integrant cul sisteme Android.\n\nFâs clic su ripie par tornâ a vierzi la aplicazion e continuâ il trasferiment dai dâts e dai permès.</string>
+    <string name="migration_paused_screen_details_timeout" description="Detail information about migration timeout shown when migration has been paused.">Par podê tignî i tiei dâts di Conession salût, finìs cheste operazion dentri di <xliff:g example="1 day" id="time_needed">%1$s</xliff:g></string>
+    <string name="resume_button" description="Text of a button prompting the user resume migration [CHAR_LIMIT=40]">Ripie</string>
+    <string name="migration_paused_notification_title" description="Title of notification sent when migration has been paused.">Integrazion in pause</string>
+    <string name="migration_paused_notification_content" description="Content of notification sent when migration has been paused.">Conession salût si sta integrant cul sisteme Android. Tocje par continuâ</string>
+    <string name="resume_migration_banner_title" description="Title of banner prompting the user to resume actions needed for migration">Ripie la integrazion</string>
+    <string name="resume_migration_banner_description" description="Description of banner prompting the user to resume actions needed for migration">Tocje par continuâ la integrazion di Conession salût cul sisteme Android. Par podê mantignî i tiei dâts, finìs cheste operazion dentri di <xliff:g example="1 day" id="time_needed">%1$s</xliff:g></string>
+    <string name="resume_migration_banner_description_fallback" description="Fallback description of banner prompting the user to resume actions needed for migration">Tocje par continuâ la integrazion di Conession salût cul sisteme Android.</string>
+    <string name="resume_migration_banner_button" description="Button of banner prompting the user to resume actions needed for migration">Continue</string>
+    <string name="resume_migration_notification_title" description="Title of notification prompting the user to resume actions needed for migration">Ripie la integrazion di Conession salût</string>
+    <string name="resume_migration_notification_content" description="Content of notification prompting the user to resume actions needed for migration">Par podê tignî i tiei dâts, finìs cheste operazion dentri di <xliff:g example="1 day" id="time_needed">%1$s</xliff:g></string>
+    <string name="app_update_needed_banner_title" description="Title of banner prompting the user to update an app which is not currently working on this Android version.">Inzornament de aplicazion necessari</string>
+    <string name="app_update_needed_banner_description_single" description="Description of banner prompting the user to update an app which is not currently working on this Android version.">Par podê continuâ a lavorâ cun Conession salût al è necessari che la aplicazion <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> e sedi inzornade</string>
+    <string name="app_update_needed_banner_description_multiple" description="Description of banner prompting the user to update an app which is not currently working on this Android version.">Par podê continuâ a lavorâ cun Conession salût, al è necessari che cualchi aplicazion e vegni inzornade.</string>
+    <string name="app_update_needed_banner_button" description="Button of banner prompting the user to update an app which is not currently working on this Android version.">Controle i inzornaments</string>
+    <string name="migration_pending_permissions_dialog_title" description="Title of dialog shown to the user when migration is pending and an app is requesting permissions.">Integrazion di Conession salût</string>
+    <string name="migration_pending_permissions_dialog_content" description="Content of dialog shown to the user when migration is pending and an app is requesting permissions.">Conession salût al è pront pe integrazion cul to sisteme Android. Se cumò tu concedi l\'acès a <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g>, al è pussibil che cualchi funzionalitât no funzioni fintremai che la integrazion no je completade.</string>
+    <string name="migration_pending_permissions_dialog_content_apps" description="Content of dialog shown to the user when migration is pending and the user is viewing health permissions.">Conession salût al è pront pe integrazion cul to sisteme Android. Se cumò tu concedis l\'acès aes aplicazions, al è pussibil che cualchi funzionalitât no funzioni fintremai che la integrazion no sedi completade.</string>
+    <string name="migration_pending_permissions_dialog_button_continue" description="Button of dialog shown to the user when migration is pending and an app is requesting permissions.">Continue</string>
+    <string name="migration_pending_permissions_dialog_button_start_integration" description="Button of dialog shown to the user when migration is pending and an app is requesting permissions.">Invie la integrazion</string>
+    <string name="migration_in_progress_permissions_dialog_title" description="Title of dialog shown to the user when migration is in progress and an app is requesting permissions.">Integrazion di Conession salût in cors</string>
+    <string name="migration_in_progress_permissions_dialog_content" description="Content of dialog shown to the user when migration is in progress and an app is requesting permissions.">Conession salût si sta integrant tal sisteme Android.\n\nTu ricevarâs une notifiche al completament dal procès e tu podarâs doprâ <xliff:g example="Run Tracker" id="app_name">%1$s</xliff:g> cun Conession salût.</string>
+    <string name="migration_in_progress_permissions_dialog_content_apps" description="Content of dialog shown to the user when migration is in progress and the user is viewing health permissions.">Conession salût si sta integrant tal sisteme Android.\n\nTu ricevarâs une notifiche al completament dal procès e tu podarâs doprâ Conession salût.</string>
+    <string name="migration_in_progress_permissions_dialog_button_got_it" description="Button of dialog shown to the user when migration is in progress and an app is requesting permissions.">Capît</string>
+    <string name="migration_not_complete_dialog_title" description="Title of dialog shown to the user when migration did not complete due to an error.">La integrazion di Conession salût no je stade completade</string>
+    <string name="migration_not_complete_dialog_content" description="Content of dialog shown to the user when migration did not complete due to an error.">Tu ricevarâs une notifiche cuant che al tornarà disponibil.</string>
+    <string name="migration_not_complete_dialog_button" description="Button of dialog shown to the user when migration did not complete due to an error.">Capît</string>
+    <string name="migration_not_complete_notification_title" description="Title of notification shown to the user when migration did not complete due to an error.">La integrazion di Conession salût no je stade completade</string>
+    <string name="migration_not_complete_notification_action" description="Action of notification shown to the user when migration did not complete due to an error.">Lei dut</string>
+    <string name="migration_complete_notification_title" description="Title of notification shown to the user when migration is complete">Integrazion di Conession salût completade</string>
+    <string name="migration_complete_notification_action" description="Action of notification shown to the user when migration is complete">Vierç</string>
+    <string name="migration_whats_new_dialog_title" description="Title of dialog shown to the user after migration is done, informing them how to access the Health Connect module.">Novitâts</string>
+    <string name="migration_whats_new_dialog_button" description="Button of dialog shown to the user after migration is done, informing them how to access the Health Connect module.">Capît</string>
+</resources>
diff --git a/overlay/packages/modules/NetworkStack/res/values-ast-rES/strings.xml b/overlay/packages/modules/NetworkStack/res/values-ast-rES/strings.xml
deleted file mode 100644
index 34b8493..0000000
--- a/overlay/packages/modules/NetworkStack/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2020 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="notification_channel_name_connected">Autenticación en portales cativos</string>
-    <string name="notification_channel_description_connected">Avisos qu\'apaecen cuando\'l teléfonu s\'autenticó correutamente nun portal cativu</string>
-    <string name="notification_channel_name_network_venue_info">Información del llugar de la rede</string>
-    <string name="notification_channel_description_network_venue_info">Avisos qu\'apaecen pa indicar que la rede tien una páxina d\'información del llugar</string>
-    <string name="connected">Conectóse</string>
-    <string name="tap_for_info">Conectóse / Toca pa ver el sitiu web</string>
-    <string name="application_label">Xestor de xeres</string>
-</resources>
diff --git a/overlay/packages/modules/Permission/PermissionController/res/values-ast-rES/strings.xml b/overlay/packages/modules/Permission/PermissionController/res/values-ast-rES/strings.xml
index 75e882e..ca7f24e 100644
--- a/overlay/packages/modules/Permission/PermissionController/res/values-ast-rES/strings.xml
+++ b/overlay/packages/modules/Permission/PermissionController/res/values-ast-rES/strings.xml
@@ -31,7 +31,6 @@
     <string name="permission_summary_enabled_by_policy_foreground_only">La política activó l\'accesu al primer planu</string>
     <string name="loading">Cargando\u2026</string>
     <string name="all_permissions">Tolos permisos</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
     <string name="review_button_cancel">Encaboxar</string>
     <string name="review_button_continue">Siguir</string>
     <string name="new_permissions_category">Permisos nuevos</string>
diff --git a/overlay/packages/modules/Permission/PermissionController/res/values-cy/strings.xml b/overlay/packages/modules/Permission/PermissionController/res/values-cy/strings.xml
index d9f6721..4cef487 100644
--- a/overlay/packages/modules/Permission/PermissionController/res/values-cy/strings.xml
+++ b/overlay/packages/modules/Permission/PermissionController/res/values-cy/strings.xml
@@ -118,8 +118,6 @@
     <string name="all_permissions">Pob caniatâd</string>
     <string name="other_permissions">Galluoedd eraill yr ap</string>
     <string name="permission_request_title">Cais am ganiatâd</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
-    <string name="wear_not_allowed_dlg_text">Gosod/dadosod gweithredoedd na sy\'n gydnaws â Wear.</string>
     <string name="permission_review_title_template_install">Dewisa pa bethau mae &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; yn cael mynediad iddynt</string>
     <string name="permission_review_title_template_update">Cafodd &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; ei ddiweddaru.
 Dewisa pa bethau i roi mynediad iddynt gan yr ap hwn.</string>
@@ -290,6 +288,8 @@
     <string name="auto_revoke_preference_summary">Tynnwyd caniatâd yn ôl i warchod dy breifatrwydd</string>
     <string name="background_location_access_reminder_notification_title">Cafodd <xliff:g id="app_name" example="Gmail">%s</xliff:g> dy leoliad wrth redeg yn y cefndir</string>
     <string name="background_location_access_reminder_notification_content">Gall yr ap hwn gael gwybod dy leoliad o hyd. Tapia i newid hyn.</string>
+    <string name="notification_listener_reminder_notification_content">Gall <xliff:g id="app_name" example="Gmail">%s</xliff:g> diystyrru, gweithredu ar, a chael mynediad at gynnwys o fewn dy hysbysiadau</string>
+    <string name="accessibility_access_reminder_notification_content">Gall <xliff:g id="app_name" example="Gmail">%s</xliff:g> weld dy sgrin a pherfformio gweithrediadau ar dy ddyfais. Mae ar apiau hygyrchedd angen y math hwn o fynediad er mwyn gweithio fel y bwriedir.</string>
     <string name="auto_revoke_after_notification_title">Tynnwyd caniatâd yr ap yn ôl i warchod dy breifatrwydd</string>
     <string name="auto_revoke_after_notification_content_one">Dyw <xliff:g id="app_name" example="Gmail">%s</xliff:g> heb ei ddefnyddio ers rhai misoedd. Tapia i adolygu.</string>
     <string name="auto_revoke_after_notification_content_two">Dyw <xliff:g id="app_name" example="Gmail">%s</xliff:g> ac 1 ap arall heb eu defnyddio ers rhai misoedd. Tapia i adolygu.</string>
@@ -510,11 +510,13 @@
     <string name="blocked_sensor_summary">Ar gyfer apiau a gwasanaethau</string>
     <string name="blocked_mic_summary">Gall data meicroffon dal i gael ei rannu os wyt ti\u2019n galw rhif argyfwng.</string>
     <string name="blocked_sensor_button_label">Newid</string>
+    <string name="safety_center_dashboard_page_title">Diogelwch a phreifatrwydd</string>
     <string name="safety_center_issue_card_dismiss_button">Diystyru</string>
     <string name="safety_center_issue_card_confirm_dismiss_button">Diystyru</string>
     <string name="safety_center_issue_card_cancel_dismiss_button">Diddymu</string>
     <string name="safety_center_entries_category_title">Gosodiadau</string>
     <string name="security_settings">Gosodiadau Diogelwch</string>
+    <string name="safety_privacy_qs_tile_title">Diogelwch a phreifatrwydd</string>
     <string name="safety_privacy_qs_tile_subtitle">Gwirio statws</string>
     <string name="permissions_removed_qs">Caniatâd wedi\'i dynnu yn ôl</string>
     <string name="manage_service_qs">Rheoli gwasanaeth</string>
@@ -545,6 +547,7 @@
     <string name="media_confirm_dialog_message_q_to_s_aural_deny">Nid yw\u2019r ap hwn yn cefnogi fersiwn diweddaraf Android. Os na chaiff yr ap hwn fynediad at ffeiliau sain a cherddoriaeth, ni fydd ganddo chwaith mynediad at luniau na fideos.</string>
     <string name="media_confirm_dialog_message_q_to_s_visual_allow">Nid yw\u2019r ap hwn yn cefnogi fersiwn diweddaraf Android. Os caiff yr ap hwn fynediad at luniau a fideos, mi fydd ganddo hefyd mynediad at ffeiliau sain a cherddoriaeth.</string>
     <string name="media_confirm_dialog_message_q_to_s_visual_deny">Nid yw\u2019r ap hwn yn cefnogi fersiwn diweddaraf Android. Os na chaiff yr ap hwn fynediad at ffeiliau sain a cherddoriaeth, ni fydd ganddo chwaith mynediad at luniau na fideos.</string>
+    <string name="safety_center_background_location_access_reminder_notification_content">Gall <xliff:g id="app_name" example="Gmail">%s</xliff:g> gael mynediad at dy leoliad o hyd, hyd yn oed pan nad yw\u2019r ap ar agor</string>
     <string name="perm_toggle_description">Ar gyfer apiau a gwasanaethau</string>
     <string name="safety_label_changes_gear_description">Gosodiadau</string>
 </resources>
diff --git a/overlay/packages/modules/Permission/PermissionController/res/values-fur-rIT/strings.xml b/overlay/packages/modules/Permission/PermissionController/res/values-fur-rIT/strings.xml
index e609ae7..7913320 100644
--- a/overlay/packages/modules/Permission/PermissionController/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/modules/Permission/PermissionController/res/values-fur-rIT/strings.xml
@@ -21,6 +21,7 @@
     <string name="back">Indaûr</string>
     <string name="available">Disponibil</string>
     <string name="blocked">Blocât</string>
+    <string name="on">On</string>
     <string name="off">Off</string>
     <string name="uninstall_or_disable">Disinstale o disative</string>
     <string name="app_not_found_dlg_title">Aplicazion no cjatade</string>
@@ -29,6 +30,11 @@
     <string name="grant_dialog_button_no_upgrade">Manten \u201cIntat che tu dopris la aplicazion\u201d</string>
     <string name="grant_dialog_button_no_upgrade_one_time">Manten \u201cDome cheste volte\u201d</string>
     <string name="grant_dialog_button_more_info">Plui infos</string>
+    <string name="grant_dialog_button_allow_all">Permet dut</string>
+    <string name="grant_dialog_button_always_allow_all">Permet dut simpri</string>
+    <string name="grant_dialog_button_allow_selected_photos">Selezione fotos e videos</string>
+    <string name="grant_dialog_button_allow_more_selected_photos">Selezione di plui</string>
+    <string name="grant_dialog_button_dont_select_more">No sta selezionâ di plui</string>
     <string name="grant_dialog_button_deny_anyway">No sta permeti distès</string>
     <string name="grant_dialog_button_dismiss">Ignore</string>
     <string name="current_permission_template">        <xliff:g id="current_permission_index" example="1">%1$s</xliff:g> di
@@ -120,8 +126,6 @@
     <string name="all_permissions">Ducj i permès</string>
     <string name="other_permissions">Altris capacitâts de aplicazion</string>
     <string name="permission_request_title">Richieste di permès</string>
-    <string name="wear_not_allowed_dlg_title">Android Wear</string>
-    <string name="wear_not_allowed_dlg_text">Lis azions Instale/Disinstale no son supuartadis su Wear.</string>
     <string name="permission_review_title_template_install">Sielç ce che
         &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; al pues acedi</string>
     <string name="permission_review_title_template_update">        &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; al è stât inzornât.
@@ -142,12 +146,41 @@
     <string name="permission_group_usage_subtitle_7d">Secuence temporâl di cuant che lis aplicazions a àn doprât il grup di permès <xliff:g id="permgroup" example="Location">%1$s</xliff:g> tai ultins 7 dîs</string>
     <string name="permission_usage_access_dialog_subtitle">Cuant che cheste aplicazion e à doprât il permès <xliff:g id="permgroup" example="Location">%1$s</xliff:g></string>
     <string name="permission_usage_access_dialog_learn_more">Plui informazions</string>
+    <string name="learn_more_content_description">Plui informazions su <xliff:g id="permgroup" example="Location">%1$s</xliff:g></string>
     <string name="manage_permission_summary">Controle l\'acès de aplicazion a <xliff:g id="permgroup" example="Location">%1$s</xliff:g></string>
     <string name="auto_permission_usage_timeline_summary"><xliff:g id="access_time" example="12:23am">%1$s</xliff:g> \u2022 <xliff:g id="summary_text" example="2 mins">%2$s</xliff:g></string>
     <string name="history_preference_subtext_2"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> \u2022 <xliff:g id="truncated_time" example="1 hr 20min">%2$s</xliff:g></string>
     <string name="history_preference_subtext_3"><xliff:g id="attribution_name" example="Nearby Share">%1$s</xliff:g> \u2022 <xliff:g id="app_name" example="Gmail">%2$s</xliff:g> \u2022 <xliff:g id="truncated_time" example="1 hr 20min">%3$s</xliff:g></string>
+    <string name="duration_used_days">{count, plural,
+        one {}=1      {# dì}
+        other   {# dîs}
+    }</string>
+    <string name="duration_used_hours">{count, plural,
+        one {}=1      {# ore}
+        other   {# oris}
+    }</string>
+    <string name="duration_used_minutes">{count, plural,
+        one {}=1      {# min}
+        other   {# mins}
+    }</string>
+    <string name="duration_used_seconds">{count, plural,
+        one {}=1      {# sec}
+        other   {# secs}
+    }</string>
     <string name="permission_usage_any_permission">Ducj i permès</string>
     <string name="permission_usage_any_time">Cualsisei ore</string>
+    <string name="permission_usage_last_n_days">{count, plural,
+        one {}=1    {Ultime zornade}
+        other {Ultins # dîs}
+    }</string>
+    <string name="permission_usage_last_n_hours">{count, plural,
+        one {}=1    {Ultime ore}
+        other {Ultimis # oris}
+    }</string>
+    <string name="permission_usage_last_n_minutes">{count, plural,
+        one {}=1    {Ultin minût}
+        other {Ultins # minûts}
+    }</string>
     <string name="no_permission_usages">Nissune utilizazion dal permès</string>
     <string name="permission_usage_list_title_any_time">Acès plui resint di simpri</string>
     <string name="permission_usage_list_title_last_7_days">Acès plui resint tai ultins 7 dîs</string>
@@ -161,6 +194,14 @@
     <string name="permission_usage_bar_chart_title_last_hour">Utilizazion permès te ultime ore</string>
     <string name="permission_usage_bar_chart_title_last_15_minutes">Utilizazion permès tai ultins 15 minûts</string>
     <string name="permission_usage_bar_chart_title_last_minute">Utilizazion permès tal ultin minût</string>
+    <string name="permission_usage_preference_summary_not_used_in_past_n_days">{count, plural,
+        one {}=1    {No doprât tal ultin dì}
+        other {No doprât tai ultins # dîs}
+    }</string>
+    <string name="permission_usage_preference_summary_not_used_in_past_n_hours">{count, plural,
+        one {}=1    {No doprât te ultime ore}
+        other {No doprât tes ultimis # oris}
+    }</string>
     <string name="permission_usage_preference_label">{count, plural,
         one {}=1      {Doprât di 1 aplicazion}
         other   {Doprât di # aplicazions}
@@ -189,6 +230,7 @@
     <string name="app_permission_button_allow_media_only">Permet l\'acès dome ai files multimediâi</string>
     <string name="app_permission_button_allow_always">Permet par dut il timp</string>
     <string name="app_permission_button_allow_foreground">Permet dome intant che tu dopris la aplicazion</string>
+    <string name="app_permission_button_always_allow_all">Permet dut simpri</string>
     <string name="app_permission_button_ask">Domande ogni volte</string>
     <string name="app_permission_button_deny">No sta permeti</string>
     <string name="precise_image_description">Posizion precise</string>
@@ -220,6 +262,12 @@
     <string name="auto_revoked_app_summary_many"><xliff:g id="permission_name" example="Microphone">%1$s</xliff:g> e <xliff:g id="number" example="2">%2$s</xliff:g> altris permès gjavâts</string>
     <string name="unused_apps_page_title">Aplicazions no dopradis</string>
     <string name="unused_apps_page_summary">Se une aplicazion no ven doprade par un pôcs di mês:\n\n\u2022 I vegnin gjavâts i permès par protezi i tiei dâts\n\u2022 Lis notifichis a vegnin interotis par sparagnâ batarie\n\u2022 I files temporanis a vegnin gjavâts par liberâ spazi\n\nPar tornâ a concedi i permès e lis notifichis, vierç la aplicazion.</string>
+    <string name="unused_apps_page_tv_summary">Se une aplicazion no ven doprade par un mês:\n\n\u2022 I vegnin gjavâts i permès par protezi i tiei dâts\n\u2022 I files temporanis a vegnin gjavâts par liberâ spazi\n\nPar tornâ a concedi i permès, vierç la aplicazion.</string>
+    <string name="last_opened_category_title"> {count, plural,
+        one {}=1{Vierts la ultime volte plui di # mês indaûr}
+        other{Vierts la ultime volte plui di # mês indaûr}
+        }
+    </string>
     <string name="last_opened_summary">Ultime utilizazion de aplicazion: <xliff:g id="date" example="March 12, 2020">%s</xliff:g></string>
     <string name="last_opened_summary_short">Ultime utilizazion: <xliff:g id="date" example="March 12, 2020">%s</xliff:g></string>
     <string name="app_permission_footer_special_file_access">Se tu permetis la gjestion di ducj i files, cheste aplicazion e podarà acedi, modificâ e eliminâ ducj i files tal archivi comun su chest dispositîf o sui dispositîfs di archiviazion colegâts. La aplicazion e podarès doprâ files cence domandâti nuie.</string>
@@ -255,6 +303,18 @@
         one {}=1      {1 dì}
         other   {# dîs}
     }</string>
+    <string name="hours">{count, plural,
+        one {}=1      {# ore}
+        other   {# oris}
+    }</string>
+    <string name="minutes">{count, plural,
+        one {}=1      {# minût}
+        other   {# minûts}
+    }</string>
+    <string name="seconds">{count, plural,
+        one {}=1      {# secont}
+        other   {# seconts}
+    }</string>
     <string name="permission_reminders">Pro memoria permès</string>
     <string name="auto_revoke_permission_reminder_notification_title_one">1 aplicazion no doprade</string>
     <string name="auto_revoke_permission_reminder_notification_title_many"><xliff:g id="number_of_apps" example="4">%s</xliff:g> aplicazions no dopradis</string>
@@ -266,6 +326,9 @@
         other   {# aplicazions no dopradis}
     }</string>
     <string name="unused_apps_notification_content">I permès e i files temporanis a son stâts gjavâts e lis notifichis a son stadis interotis. Tocje par controlâ.</string>
+    <string name="unused_apps_safety_center_card_title">Torne viôt lis aplicazions cun permès gjavâts</string>
+    <string name="unused_apps_safety_center_card_content">Pes aplicazions che no tu âs doprât di un pôc, i permès e i files temporanis a son stâts gjavâts e lis notifichis a son stadis interotis.</string>
+    <string name="unused_apps_safety_center_action_title">Revisione lis aplicazions</string>
     <string name="post_drive_permission_decision_reminder_title">Controle i permès resints</string>
     <string name="post_drive_permission_decision_reminder_summary_1_app_1_permission">Intant de vuide, tu âs dât a <xliff:g id="app" example="Waze">%1$s</xliff:g> l\'acès a <xliff:g id="permission" example="location">%2$s</xliff:g></string>
     <string name="post_drive_permission_decision_reminder_summary_1_app_2_permissions">Intant de vuide, tu âs dât a <xliff:g id="app" example="Waze">%1$s</xliff:g> l\'acès a <xliff:g id="permission_1" example="location">%2$s</xliff:g> e <xliff:g id="permission_2" example="microphone">%3$s</xliff:g></string>
@@ -283,6 +346,19 @@
     <string name="auto_revoke_preference_summary">Permès gjavâts par protezi la tô riservatece</string>
     <string name="background_location_access_reminder_notification_title"><xliff:g id="app_name" example="Gmail">%s</xliff:g> al à otignude la tô posizion in sotfont</string>
     <string name="background_location_access_reminder_notification_content">Cheste aplicazion e pues simpri acedi ae tô posizion. Tocje par cambiâ.</string>
+    <string name="notification_listener_reminder_notification_title">Revisione la aplicazion cun acès aes tôs notifichis</string>
+    <string name="notification_listener_reminder_notification_content"><xliff:g id="app_name" example="Gmail">%s</xliff:g> al pues scartâ, agjî e acedi ai contignûts des tôs notifichis</string>
+    <string name="notification_listener_warning_card_content">Cheste aplicazion e pues scartâ, agjî e acedi ai contignûts dentri des tôs notifichis. Cualchi aplicazion e domande chest acès par funzionâ ben come previodût.</string>
+    <string name="notification_listener_remove_access_button_label">Gjave acès</string>
+    <string name="notification_listener_review_app_button_label">Viôt altris opzions</string>
+    <string name="notification_listener_remove_access_success_label">Acès gjavât</string>
+    <string name="accessibility_access_reminder_notification_title">Revisione la aplicazion cun plen acès al dispositîf</string>
+    <string name="accessibility_access_reminder_notification_content"><xliff:g id="app_name" example="Gmail">%s</xliff:g> al pues viodi il to schermi e eseguî azions sul dispositîf. Lis aplicazions pal acès facilitât a àn bisugne di chest gjenar di acès par funzionâ ben come previodût.</string>
+    <string name="accessibility_access_warning_card_content">Cheste aplicazion e pues viodi il schermi e eseguî azions sul dispositîf. Lis aplicazions pal acès facilitât a àn bisugne di chest gjenar di acès par funzionâ ben, ma controle la aplicazion e verifiche che e je fidade.</string>
+    <string name="accessibility_remove_access_button_label">Gjave acès</string>
+    <string name="accessibility_show_all_apps_button_label">Viôt lis aplicazions cun acès complet</string>
+    <string name="accessibility_remove_access_success_label">Acès gjavât</string>
+    <string name="safety_center_notification_app_label">Sisteme Android</string>
     <string name="auto_revoke_after_notification_title">Permès di aplicazion gjavâts par protezi la tô riservatece</string>
     <string name="auto_revoke_after_notification_content_one"><xliff:g id="app_name" example="Gmail">%s</xliff:g> nol è stât doprât di un pôcs di mês. Tocje par controlâ.</string>
     <string name="auto_revoke_after_notification_content_two"><xliff:g id="app_name" example="Gmail">%s</xliff:g> e une altre aplicazion no son stadis dopradis di un pôcs di mês. Tocje par controlâ.</string>
@@ -385,6 +461,10 @@
     <string name="role_watch_description">La aplicazion <xliff:g id="app_name" example="Wear">%1$s</xliff:g> e podarà interagjî cu lis notifichis e e podarà acedi ai permès di Telefon, SMS, Contats e Calendari.</string>
     <string name="role_app_streaming_description">Al vignarà concedût a <xliff:g id="app_name" example="Cross-Device Communciation">%1$s</xliff:g> di interagjî cu lis notifichis e di trasmeti lis tôs aplicazions sul dispositîf colegât.</string>
     <string name="role_companion_device_computer_description">Chest servizi al condivît lis tôs fotos, i contignûts multimediâi e lis notifichis dal to telefon a altris dispositîfs.</string>
+    <string name="role_notes_label">Aplicazion predefinide pes notis</string>
+    <string name="role_notes_short_label">Aplicazions pes notis</string>
+    <string name="role_notes_description">Aplicazions che ti permetin di cjapâ notis sul to dispositîf</string>
+    <string name="role_notes_search_keywords">notis</string>
     <string name="request_role_current_default">Predefinît atuâl</string>
     <string name="request_role_dont_ask_again">No sta domandâ plui</string>
     <string name="request_role_set_as_default">Met come predefinît</string>
@@ -471,6 +551,8 @@
         &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; di acedi a &lt;b&gt;fotos, videos, musiche, audio e altris files&lt;/b&gt; su chest dispositîf?</string>
     <string name="permgrouprequest_read_media_aural">Permeti a &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; di acedi a musiche e audio su chest dispositîf?</string>
     <string name="permgrouprequest_read_media_visual">Permeti a &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; di acedi a fotos e videos su chest dispositîf?</string>
+    <string name="permgrouprequest_more_photos">Permeti a
+        &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; di acedi a plui fotos e videos su chest dispositîf?</string>
     <string name="permgrouprequest_microphone">Permeti a
         &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b&gt; di regjistrâ audio?</string>
     <string name="permgrouprequestdetail_microphone">La aplicazion e rivarà a regjistrâ l\'audio dome cuant che tu le stâs doprant</string>
@@ -503,6 +585,8 @@
     <string name="permgrouprequest_notifications">Permeti a
         &lt;b&gt;<xliff:g id="app_name" example="Gmail">%1$s</xliff:g> di mandâti notifichis?</string>
     <string name="auto_granted_permissions">Permès controlâts</string>
+    <string name="auto_granted_location_permission_notification_title"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> al à l\'acès ae posizion</string>
+    <string name="auto_granted_permission_notification_body">La tô organizazion e permet a <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> di acedi ae tô posizion</string>
     <string name="other_permissions_label">Altris permès</string>
     <string name="not_used_permissions_label">Permès doprâts dal sisteme</string>
     <string name="not_used_permissions_description">Permès doprâts dome da lis aplicazions di sisteme.</string>
@@ -523,13 +607,28 @@
     <string name="blocked_sensor_summary">Par aplicazions e servizis</string>
     <string name="blocked_mic_summary">Al è pussibil che i dâts dal microfon a vegnin condividûts distès cuant che tu clamis un numar di emergjence.</string>
     <string name="blocked_sensor_button_label">Cambie</string>
+    <string name="safety_center_dashboard_page_title">Sigurece e riservatece</string>
+    <string name="safety_center_rescan_button">Scansione dispositîf</string>
     <string name="safety_center_issue_card_dismiss_button">Ignore</string>
+    <string name="safety_center_issue_card_dismiss_confirmation_title">Scartâ chest avîs?</string>
+    <string name="safety_center_issue_card_dismiss_confirmation_message">Torne viôt lis impostazions di sigurece e riservatece cuant che tu vûs par zontâ plui protezion</string>
     <string name="safety_center_issue_card_confirm_dismiss_button">Ignore</string>
     <string name="safety_center_issue_card_cancel_dismiss_button">Anule</string>
     <string name="safety_center_entries_category_title">Impostazions</string>
+    <string name="safety_status_preference_title_and_summary_content_description">Stât de sigurece e riservatece: <xliff:g id="overall safety status" example="Looks Good">%1$s</xliff:g><xliff:g id="summary of device status" example="This device is up to date">%2$s</xliff:g></string>
     <string name="security_settings">Impostazions di sigurece</string>
+    <string name="sensor_permissions_qs">Permès</string>
+    <string name="safety_privacy_qs_tile_title">Sigurece e riservatece</string>
     <string name="safety_privacy_qs_tile_subtitle">Controle il stât</string>
+    <string name="privacy_controls_qs">I tiei controi di riservatece</string>
+    <string name="security_settings_button_label_qs">Altris impostazions</string>
+    <string name="camera_toggle_label_qs">Acès ae fotocjamare</string>
+    <string name="microphone_toggle_label_qs">Acès al microfon</string>
     <string name="permissions_removed_qs">Permès gjavât</string>
+    <string name="camera_usage_qs">Viôt la utilizazion resinte de fotocjamare</string>
+    <string name="microphone_usage_qs">Viôt la utilizazion resinte dal microfon</string>
+    <string name="remove_camera_qs">Gjave i permès par cheste aplicazion</string>
+    <string name="remove_microphone_qs">Gjave i permès par cheste aplicazion</string>
     <string name="manage_service_qs">Gjestìs il servizi</string>
     <string name="manage_permissions_qs">Gjestìs i permès</string>
     <string name="active_call_usage_qs">In ûs de clamade telefoniche</string>
@@ -558,6 +657,61 @@
     <string name="media_confirm_dialog_message_q_to_s_aural_deny">Cheste aplicazion no supuarte la ultime version di Android. Se cheste aplicazion no pues acedi a musiche e files audio, no podarà nancje acedi a fotos e videos.</string>
     <string name="media_confirm_dialog_message_q_to_s_visual_allow">Cheste aplicazion no supuarte la ultime version di Android. Se cheste aplicazion e pues acedi a fotos e videos, e podarà ancje acedi a musiche e files audio.</string>
     <string name="media_confirm_dialog_message_q_to_s_visual_deny">Cheste aplicazion no supuarte la ultime version di Android. Se cheste aplicazion no pues acedi a musiche e files audio, no podarà nancje acedi a fotos e videos.</string>
+    <string name="safety_center_background_location_access_notification_title">Torne esamine l\'acès de aplicazion in sotfont ae posizion</string>
+    <string name="safety_center_background_location_access_reminder_notification_content"><xliff:g id="app_name" example="Gmail">%s</xliff:g> al pues simpri acedi ae tô posizion, ancje cuant che la aplicazion e je sierade</string>
+    <string name="safety_center_background_location_access_reminder_title">Torne esamine l\'acès in sotfont ae posizion de aplicazion</string>
+    <string name="safety_center_background_location_access_reminder_summary">Cheste aplicazion e pues simpri acedi ae tô posizion, ancje cuant che e je sierade.\u000a\u000aCualchi aplicazion di sigurece e di emergjence par funzionâ ben e domande l\'acès in sotfont ae posizion.</string>
+    <string name="safety_center_background_location_access_revoked">Acès cambiât</string>
+    <string name="safety_center_view_recent_location_access">Viôt la utilizazion resinte de posizion</string>
+    <string name="camera_toggle_enable_config">camera_toggle_enabled</string>
+    <string name="mic_toggle_enable_config">mic_toggle_enabled</string>
+    <string name="clipboard_show_access_notifications_config">clipboard_show_access_notifications</string>
+    <string name="show_access_notifications_default_config">show_access_notifications</string>
+    <string name="privacy_controls_title">Controi di riservatece</string>
+    <string name="camera_toggle_title">Acès ae fotocjamare</string>
+    <string name="mic_toggle_title">Acès al microfon</string>
     <string name="perm_toggle_description">Par aplicazions e servizis</string>
+    <string name="mic_toggle_description">Par aplicazions e servizis. Se cheste impostazion e je disativade, i dâts dal microfon a podaran ancjemò jessi condividûts cuant che tu clamis un numar di emergjence.</string>
+    <string name="location_settings_subtitle">Viôt lis aplicazions e i servizis che a àn acès ae posizion</string>
+    <string name="show_clip_access_notification_title">Mostre acès aes notis</string>
+    <string name="show_clip_access_notification_summary">Mostre un messaç cuant che lis aplicazions a doprin test, imagjins o altris contignûts che tu âs copiâts</string>
+    <string name="show_password_title">Mostre passwords</string>
+    <string name="show_password_summary">Visualize in mût rapit i caratars, a man a man che tu ju scrivis</string>
+    <string name="permission_rationale_message_location">Cheste aplicazion e declare che e podarès condividi i dâts de posizion cun tiercis parts</string>
+    <string name="permission_rationale_location_title">Condivision dâts e posizion</string>
+    <string name="permission_rationale_data_sharing_source_title">Di dulà che i dâts di condivision a rivin</string>
+    <string name="permission_rationale_data_sharing_device_manufacturer_message">Il svilupadôr al à furnît informazions al produtôr di chest dispositîf su cemût che cheste aplicazion e condivît i dâts. Al è pussibil che il svilupadôr al inzorni chestis informazions vie pal timp.</string>
+    <string name="permission_rationale_data_sharing_source_message">Il svilupadôr al à furnît informazion a &lt;annotation id="link"&gt;&lt;annotation id="install_source" example="App Store"&gt;&lt;/annotation&gt; su cemût che cheste aplicazion e condivît i dâts. Al è pussibil che il svilupadôr al inzorni chestis informazions vie pal timp.</string>
+    <string name="permission_rationale_location_purpose_title">Cheste aplicazion e podarès condividi dâts di posizion par:</string>
+    <string name="permission_rationale_permission_data_sharing_varies_title">La condivision di dâts e varie</string>
+    <string name="permission_rationale_data_sharing_varies_message">Lis pratichis relativis ai dâts a podaressin variâ in base a version de tô aplicazion, ûs, regjon e etât. <annotation id="link">Altris informazions su la condivision dai dâts</annotation></string>
+    <string name="permission_rationale_data_sharing_varies_message_without_link">Lis pratichis relativis ai dâts a podaressin variâin base a version, ûs, regjon e etât.</string>
+    <string name="permission_rationale_location_settings_title">Dâts de tô posizion</string>
+    <string name="permission_rationale_permission_settings_message">Cambie l\'acès di cheste aplicazion intes <annotation id="link">impostazions de riservatece</annotation></string>
+    <string name="permission_rationale_purpose_app_functionality">Funzionalitât de aplicazion</string>
+    <string name="permission_rationale_purpose_analytics">Analitiche</string>
+    <string name="permission_rationale_purpose_developer_communications">Comunicazions dal svilupadôr</string>
+    <string name="permission_rationale_purpose_advertising">Publicitât e comercializazion</string>
+    <string name="permission_rationale_purpose_fraud_prevention_security">Prevenzion da lis fraudis, sigurece e conformitât</string>
+    <string name="permission_rationale_purpose_personalization">Personalizazion</string>
+    <string name="permission_rationale_purpose_account_management">Gjestion accounts</string>
+    <string name="app_permission_rationale_message">Sigurece dai dâts</string>
+    <string name="app_location_permission_rationale_title">I dâts de posizion a podaressin vignî condividûts</string>
+    <string name="app_location_permission_rationale_subtitle">Cheste aplicazion e declare che e podarès condividi i dâts de tô posizion cun tiercis parts</string>
+    <string name="data_sharing_updates_title">Inzornaments condivision dâts pe posizion</string>
+    <string name="data_sharing_updates_summary">Torne esamine lis aplicazions che a àn cambiât la maniere di condividi i dâts de posizion</string>
+    <string name="data_sharing_updates_subtitle">Chestis aplicazions a àn cambiât la maniere di condividi i dâts de tô posizion. Al è pussibil che prime no ju vedin condividûts o che cumò ju condividedin par finalitâts di publicitât o di comercializazion.</string>
+    <string name="data_sharing_updates_footer_message">I svilupadôrs di chestis aplicazions a àn furnît informazions su lis lôr pratichis di condivision dai dâts a un negozi di aplicazions (app store). Al è pussibil che lis inzornin vie pal timp.\n\nLis pratichis di condivision dai dâts a podaressin variâ in base a version de aplicazion, ûs, regjon e etât.</string>
+    <string name="learn_about_data_sharing">Informazions su condivision dâts</string>
+    <string name="shares_location_with_third_parties">Cumò i dâts de tô posizion a son condividûts cun tiercis parts</string>
+    <string name="shares_location_with_third_parties_for_advertising">Cumò i dâts de tô posizion a son condividûts cun tiercis parts par publicitâts o comercializazions</string>
+    <string name="updated_in_last_days">{count, plural,
+        one {}=0    {Inzornât inte ultime zornade}
+        =1    {Inzornât te ultime zornade}
+        other {Inzornâts tai ultins # dîs}
+        }</string>
+    <string name="no_updates_at_this_time">In chest moment, nissun inzornament</string>
+    <string name="safety_label_changes_notification_title">Inzornaments di condivision dâts</string>
+    <string name="safety_label_changes_notification_desc">Cualchi aplicazion e à cambiât la maniere di condividi i dâts de tô posizion</string>
     <string name="safety_label_changes_gear_description">Impostazions</string>
 </resources>
diff --git a/overlay/packages/modules/Wifi/service/ServiceWifiResources/res/values-fur-rIT/strings.xml b/overlay/packages/modules/Wifi/service/ServiceWifiResources/res/values-fur-rIT/strings.xml
index e0c84d7..d6d7e21 100644
--- a/overlay/packages/modules/Wifi/service/ServiceWifiResources/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/modules/Wifi/service/ServiceWifiResources/res/values-fur-rIT/strings.xml
@@ -25,6 +25,7 @@
     <string name="notification_channel_network_status">Stât de rêt</string>
     <string name="notification_channel_network_alerts">Alertis di rêt</string>
     <string name="notification_channel_network_available">Rêt disponibile</string>
+    <string name="notification_channel_apm_alerts">Alertis APM</string>
     <string name="wifi_suggestion_title">Permeti lis rêts Wi\u2011Fi sugjeridis?</string>
     <string name="wifi_suggestion_content">Rêts sugjeridis di <xliff:g id="name" example="App123">%s</xliff:g>. Il dispositîf al podarès conetisi in automatic. </string>
     <string name="wifi_suggestion_action_allow_app">Permet</string>
@@ -52,6 +53,11 @@
     <string name="ok">Va ben</string>
     <string name="wifi_p2p_invitation_sent_title">Invît mandât</string>
     <string name="wifi_p2p_invitation_to_connect_title">Invît ae conession</string>
+    <string name="wifi_p2p_invitation_seconds_remaining">        {0, plural,
+            one {}=1 {Acete dentri di # secont.}
+            other {Acete dentri di # seconts.}
+        }
+    </string>
     <string name="wifi_p2p_from_message">Di: </string>
     <string name="wifi_p2p_to_message">A: </string>
     <string name="wifi_p2p_enter_pin_message">Scrîf il PIN necessari: </string>
@@ -102,9 +108,21 @@
         <item><xliff:g id="carrier_id_prefix">:::1839:::</xliff:g><xliff:g id="ssid">%1$s</xliff:g> : l\'Acès Wi-Fi di Verizon nol è disponibil de tô posizion. Torne prove plui tart o prove di une altre posizion. (Erôr = 32766)</item>
     </string-array>
     <string name="wifi_eap_error_message_code_32767"><xliff:g id="ssid">%1$s</xliff:g> : erôr 32767 de autenticazion EAP</string>
+    <string-array name="wifi_eap_error_message_code_32767_carrier_overrides">
+        <item><xliff:g id="carrier_id_prefix">:::1839:::</xliff:g><xliff:g id="ssid">%1$s</xliff:g> : Al è vignût fûr un probleme tal conetiti a Verizon Wi-Fi Access. Torne prove plui indevant o prove di une altre posizion. (Error = 32767)</item>
+    </string-array>
     <string name="wifi_eap_error_message_code_16384"><xliff:g id="ssid">%1$s</xliff:g> : erôr 16384 de autenticazion EAP</string>
+    <string-array name="wifi_eap_error_message_code_16384_carrier_overrides">
+        <item><xliff:g id="carrier_id_prefix">:::1839:::</xliff:g><xliff:g id="ssid">%1$s</xliff:g> : Al è vignût fûr un probleme tal conetiti a Verizon Wi-Fi. (Error = 16384)</item>
+    </string-array>
     <string name="wifi_eap_error_message_code_16385"><xliff:g id="ssid">%1$s</xliff:g> : erôr 16385 de autenticazion EAP</string>
+    <string-array name="wifi_eap_error_message_code_16385_carrier_overrides">
+        <item><xliff:g id="carrier_id_prefix">:::1839:::</xliff:g><xliff:g id="ssid">%1$s</xliff:g> : Al è vignût fûr un probleme tal conetiti a Verizon Wi-Fi. (Error = 16385)</item>
+    </string-array>
     <string name="wifi_eap_error_message_unknown_error_code"><xliff:g id="ssid">%1$s</xliff:g> : erôr di autenticazion EAP, codiç di erôr no cognossût</string>
+    <string-array name="wifi_eap_error_message_unknown_error_code_carrier_overrides">
+        <item><xliff:g id="carrier_id_prefix">:::1839:::</xliff:g><xliff:g id="ssid">%1$s</xliff:g> : Al è vignût fûr un probleme tal conetiti a Verizon Wi-Fi. (Error = no cognossût)</item>
+    </string-array>
     <string name="wifi_softap_auto_shutdown_timeout_expired_title">Pont di acès disativât</string>
     <string name="wifi_softap_auto_shutdown_timeout_expired_summary">Nissun dispositîf conetût. Tocje par modificâ.</string>
     <string name="wifi_sim_required_title">Wi\u2011Fi disconetût</string>
@@ -114,6 +132,11 @@
     <string name="wifi_interface_priority_message_plural">Cheste operazion e podarès causâ problemis a chestis aplicazions: <xliff:g id="apps">%3$s</xliff:g></string>
     <string name="wifi_interface_priority_approve">Permet</string>
     <string name="wifi_interface_priority_reject">No sta permeti</string>
+    <string name="wifi_interface_priority_interface_name_sta">STA</string>
+    <string name="wifi_interface_priority_interface_name_ap">Pont di acès Wi\u2011Fi</string>
+    <string name="wifi_interface_priority_interface_name_ap_bridge">Pont di acès Wi\u2011Fi</string>
+    <string name="wifi_interface_priority_interface_name_p2p">Wi\u2011Fi Diret</string>
+    <string name="wifi_interface_priority_interface_name_nan">Wi\u2011Fi Cussient</string>
     <string name="wifi_ca_cert_dialog_title">Cheste rêt ise atendibile?</string>
     <string name="wifi_ca_cert_dialog_continue_text">Sì, conetiti</string>
     <string name="wifi_ca_cert_dialog_abort_text">No, no sta conetiti</string>
@@ -143,4 +166,15 @@
     <string name="wifi_enable_request_dialog_message">Tu puedis disativâ il Wi\u2011Fi tes impostazions rapidis</string>
     <string name="wifi_enable_request_dialog_positive_button">Permet</string>
     <string name="wifi_enable_request_dialog_negative_button">No sta permeti</string>
+    <string name="wifi_enabled_apm_first_time_title">Wi\u2011Fi atîf in modalitât avion</string>
+    <string name="wifi_enabled_apm_first_time_message">Se tu tegnis impiât il Wi\u2011Fi, il dispositîf si impensarà di tignîlu impiât la prossime volte che tu sarâs in modalitât avion</string>
+    <string name="apm_enabled_first_time_title">Il Wi\u2011Fi al reste atîf</string>
+    <string name="apm_enabled_first_time_message">Il dispositîf si impensarà di tignî il Wi\u2011Fi atîf in modalitât avion. Distude il Wi\u2011Fi se no tu desideris che al resti atîf.</string>
+    <string name="wifi_network_disabled_by_admin_title">Rêt no disponibile</string>
+    <string name="wifi_network_disabled_by_admin_message"><xliff:g id="ssid">%1$s</xliff:g> al è disabilitât dal to aministradôr.</string>
+    <string name="wifi_network_disabled_by_admin_button">Siere</string>
+    <string name="wifi_network_switch_dialog_title_no_internet">Al somee che <xliff:g id="ssid">%1$s</xliff:g> nol sedi colegât a internet. Passâ a <xliff:g id="ssid">%2$s</xliff:g>?</string>
+    <string name="wifi_network_switch_dialog_title_bad_internet"><xliff:g id="ssid">%1$s</xliff:g> al à une basse cualitât. Passâ a <xliff:g id="ssid">%2$s</xliff:g>?</string>
+    <string name="wifi_network_switch_dialog_positive_button">Cambie</string>
+    <string name="wifi_network_switch_dialog_negative_button">No sta cambiâ</string>
 </resources>
diff --git a/overlay/packages/providers/BlockedNumberProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/BlockedNumberProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index e01e322..0000000
--- a/overlay/packages/providers/BlockedNumberProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:android="http://schemas.android.com/apk/res/android" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_label">Almacenamientu de númberos bloquiaos</string>
-</resources>
diff --git a/overlay/packages/providers/BookmarkProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/BookmarkProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index d32305b..0000000
--- a/overlay/packages/providers/BookmarkProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2015 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="application_name">Fornidor de marcadores</string>
-</resources>
diff --git a/overlay/packages/providers/CalendarProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/CalendarProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index 1d2e07e..0000000
--- a/overlay/packages/providers/CalendarProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2009 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="calendar_storage">Almacenamientu de Calendariu</string>
-    <string name="calendar_default_name">Por defeutu</string>
-    <string name="calendar_info">Información de Calendariu</string>
-    <string name="calendar_info_error">Fallu</string>
-    <string name="calendar_info_no_calendars">Nun hai calendarios</string>
-    <string name="calendar_info_events">Eventos: <xliff:g id="events">%1$d</xliff:g></string>
-    <string name="calendar_info_events_dirty">Eventos: <xliff:g id="events">%1$d</xliff:g>, ensin guardar: <xliff:g id="dirty events">%2$d</xliff:g></string>
-    <string name="provider_label">Calendariu</string>
-    <string name="debug_tool_delete_button">Desaniciar agora</string>
-    <string name="debug_tool_start_button">Aniciar</string>
-    <string name="debug_tool_message">Tas a piques de 1) facer una copia de la base de datos de Calendariu na tarxeta SD/almacenamientu USB, lleíble por cualesquier aplicación, y 2) d\'unviala per corréu electrónicu. Acuérdate de desaniciar la copia namás que la copies fuera del preséu o se reciba\'l mensaxe de corréu electrónicu.</string>
-    <string name="debug_tool_email_sender_picker">Escueyi un programa pa unviar el ficheru</string>
-    <string name="debug_tool_email_subject">Base de datos de Calendariu</string>
-    <string name="debug_tool_email_body">Axunto la mio base de datos de Calendariu que contién toles mios cites y tola mio información personal. Remánala con curiáu.</string>
-</resources>
diff --git a/overlay/packages/providers/CallLogProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/CallLogProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index 1d82424..0000000
--- a/overlay/packages/providers/CallLogProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2015 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:android="http://schemas.android.com/apk/res/android" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="sharedUserLabel">Aplicaciones básiques d\'Android</string>
-</resources>
diff --git a/overlay/packages/providers/ContactsProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/ContactsProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index d1f2cbc..0000000
--- a/overlay/packages/providers/ContactsProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2009 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:android="http://schemas.android.com/apk/res/android" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="sharedUserLabel">Aplicaciones básiques d\'Android</string>
-    <string name="app_label">Almacenamientu de Contautos</string>
-    <string name="provider_label">Contautos</string>
-    <string name="upgrade_out_of_memory_notification_ticker">L\'anovamientu de los contautos precisa más memoria.</string>
-    <string name="upgrade_out_of_memory_notification_title">Anovando l\'almacenamientu pa los contautos</string>
-    <string name="default_directory">Contautos</string>
-    <string name="local_invisible_directory">Otros contautos</string>
-    <string name="voicemail_from_column">"Mensaxe de voz de: "</string>
-    <string name="debug_dump_title">Copiar la base de datos de contautos</string>
-    <string name="debug_dump_database_message">Tas a piques de 1) facer una copia de la base de datos de Contautos qu\'inclúi tola información rellacionada colos contautos y tol rexistru de llamaes del almacenamientu internu, y 2) d\'unviala per corréu electrónicu.  Acuérdate de desaniciar la copia namás que la copies fuera del preséu o se reciba\'l mensaxe de corréu electrónicu.</string>
-    <string name="debug_dump_delete_button">Desaniciar agora</string>
-    <string name="debug_dump_start_button">Aniciar</string>
-    <string name="debug_dump_email_sender_picker">Escueyi un programa pa unviar el ficheru</string>
-    <string name="debug_dump_email_subject">Base de datos de Contautos</string>
-    <string name="debug_dump_email_body">Axunto la mio base de datos de Contautos que contién tola información de los mios contautos.  Remánala con curiáu.</string>
-</resources>
diff --git a/overlay/packages/providers/DownloadProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/DownloadProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index 83f6122..0000000
--- a/overlay/packages/providers/DownloadProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,75 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2007 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_label">Xestor de descargues</string>
-    <string name="storage_description">Descargues</string>
-    <string name="permlab_downloadManager">accesu al xestor de descargues.</string>
-    <string name="permdesc_downloadManager">Permite que l\'aplicación
-        acceda al xestor de descargues y lu use pa baxar ficheros.
-        Les aplicaciones malicioses puen usar esti permisu pa
-        torgar descargues y acceder a información privada.</string>
-    <string name="permlab_downloadManagerAdvanced">funciones avanzaes
-        del xestor de descargues.</string>
-    <string name="permdesc_downloadManagerAdvanced">Permite que l\'aplicación
-        acceda a les funciones avanzaes del xestor de descargues.
-        Les aplicaciones malicioses puen usar esti permisu pa
-        torgar les descargues y acceder a información privada.</string>
-    <string name="permlab_downloadCompletedIntent">unviu d\'avisos
-        de descarga.</string>
-    <string name="permdesc_downloadCompletedIntent">Permite que l\'aplicación
-        unvie avisos tocante a les descargues completaes. Les aplicaciones
-        malicioses puen usar esti permisu pa confundir a otres aplicaciones
-        que baxen ficheros.</string>
-    <string name="permlab_downloadCacheNonPurgeable">espaciu acutáu na
-    caché de descargues</string>
-    <string name="permdesc_downloadCacheNonPurgeable">Permite que l\'aplicación
-    baxe ficheros a la caché de descargues, que nun se puen desaniciar automáticamente
-    cuando\'l xestor de descargues precise más espaciu.</string>
-    <string name="permlab_downloadWithoutNotification">descarga de ficheros ensin
-        avisar</string>
-    <string name="permdesc_downloadWithoutNotification">Permite que l\'aplicación
-    baxe ficheros pente\'l xestor de descargues ensin amosar nengún avisu
-    al usuariu.</string>
-    <string name="permlab_accessAllDownloads">accesu a toles descargues
-    del sistema</string>
-    <string name="permdesc_accessAllDownloads">Permite que l\'aplicación vea
-    y modifique toles descargues aniciaes por cualesquier aplicación del sistema.</string>
-    <string name="download_unknown_title">&lt;Ensin títulu&gt;</string>
-    <string name="notification_download_complete">Completóse la descarga.</string>
-    <string name="notification_download_failed">Nun se completó la descarga.</string>
-    <string name="notification_need_wifi_for_size">La descarga rique una Wi-Fi.</string>
-    <string name="notification_paused_in_background">Posóse en segundu planu.</string>
-    <string name="wifi_required_title">La descarga ye pergrande pa la operadora de rede</string>
-    <string name="wifi_recommended_title">¿Quies meter l\'elementu na cola pa baxalu dempués?</string>
-    <string name="button_queue_for_wifi">Meter na cola</string>
-    <string name="button_cancel_download">Encaboxar</string>
-    <string name="button_start_now">Aniciar agora</string>
-    <plurals name="notif_summary_active">
-        <item quantity="one">1 ficheru en descarga</item>
-        <item quantity="other"><xliff:g id="number">%d</xliff:g> ficheros en descarga</item>
-    </plurals>
-    <plurals name="notif_summary_waiting">
-        <item quantity="one">1 ficheru n\'espera</item>
-        <item quantity="other"><xliff:g id="number">%d</xliff:g> ficheros n\'espera</item>
-    </plurals>
-    <string name="download_remaining">Tiempu que queda: <xliff:g id="duration" example="3 minutes">%s</xliff:g></string>
-    <string name="download_no_application_title">Nun se pue abrir el ficheru</string>
-    <string name="root_downloads">Descargues</string>
-    <string name="download_queued">Na cola</string>
-    <string name="download_running">En cursu</string>
-    <string name="download_error">Produxéronse fallos</string>
-    <string name="download_running_percent">En cursu, <xliff:g id="percentage" example="50%">%s</xliff:g></string>
-</resources>
diff --git a/overlay/packages/providers/DownloadProvider/ui/res/values-ast-rES/strings.xml b/overlay/packages/providers/DownloadProvider/ui/res/values-ast-rES/strings.xml
deleted file mode 100644
index 030e319..0000000
--- a/overlay/packages/providers/DownloadProvider/ui/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,55 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2010 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_label">Descargues</string>
-    <string name="download_title_sorted_by_date">Descargues: ordenaes pola data</string>
-    <string name="download_title_sorted_by_size">Descargues: ordenaes pol tamañu</string>
-    <string name="no_downloads">Nun hai descargues.</string>
-    <string name="missing_title">&lt;Desconozse&gt;</string>
-    <string name="button_sort_by_size">Ordenar pol tamañu</string>
-    <string name="button_sort_by_date">Ordenar pola data</string>
-    <string name="download_queued">Na cola</string>
-    <string name="download_running">En cursu</string>
-    <string name="download_success">Completóse</string>
-    <string name="download_error">Hebo fallos</string>
-    <string name="dialog_title_not_available">Nun se pudo baxar</string>
-    <string name="dialog_failed_body">¿Quies retentar la descarga del ficheru
-          dempués o quies quitalu de la cola?</string>
-    <string name="dialog_title_queued_body">Ficheru na cola</string>
-    <string name="dialog_queued_body">Esti ficheru ta na cola pa baxalu dempués, polo qu\'entá nun ta disponible.</string>
-    <string name="dialog_file_missing_body">Nun se pue atopar el ficheru baxáu.</string>
-    <string name="dialog_insufficient_space_on_external">Nun se pue finar la descarga. Nun hai
-        abondu espaciu nel almacenamientu
-        esternu.</string>
-    <string name="dialog_insufficient_space_on_cache">Nun se pue finar la descarga. Nun hai
-        abondu espaciu nel almacenamientu
-        de descargues internu.</string>
-    <string name="dialog_cannot_resume">Interrumpióse la descarga y nun se pue siguir con ella.</string>
-    <string name="dialog_file_already_exists">Nun se pue baxar. El ficheru de destín yá esiste.
-    </string>
-    <string name="dialog_media_not_found">Nun se pue baxar. El mediu esternu nun ta disponible.
-    </string>
-    <string name="download_no_application_title">Nun se pue abrir el ficheru</string>
-    <string name="remove_download">Quitar</string>
-    <string name="delete_download">Desaniciar</string>
-    <string name="keep_queued_download">Caltener</string>
-    <string name="cancel_running_download">Encaboxar</string>
-    <string name="retry_download">Retentar</string>
-    <string name="deselect_all">Deseleicionar too</string>
-    <string name="select_all">Esbillar too</string>
-    <string name="selected_count"><xliff:g id="number" example="3">%1$d</xliff:g> de <xliff:g id="total" example="15">%2$d</xliff:g> na esbilla</string>
-    <string name="download_share_dialog">Compartir per</string>
-</resources>
diff --git a/overlay/packages/providers/MediaProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/MediaProvider/res/values-ast-rES/strings.xml
index b431a95..3edf870 100644
--- a/overlay/packages/providers/MediaProvider/res/values-ast-rES/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-ast-rES/strings.xml
@@ -14,19 +14,23 @@
      limitations under the License.
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="uid_label">Multimedia</string>
-    <string name="app_label">Almacenamientu multimedia</string>
-    <string name="picker_app_label">Multimedia</string>
-    <string name="artist_label">Artista</string>
-    <string name="unknown">Descripción desconocida</string>
-    <string name="root_images">Imáxenes</string>
-    <string name="root_videos">Vídeos</string>
-    <string name="root_audio">Audiu</string>
-    <string name="root_documents">Documentos</string>
-    <string name="cache_clearing_dialog_title">Borráu de los ficheros temporales de les aplicaciones</string>
-    <string name="cache_clearing_dialog_text">«<xliff:g id="app_seeking_permission" example="File manager">%s</xliff:g>» quier borrar dalgunos ficheros temporales. Esta aición pue aumentar el consumu de la batería o de los datos móviles.</string>
-    <string name="cache_clearing_in_progress_title">Borrando los ficheros temporales de les aplicaciones\u2026</string>
-    <string name="clear">Borrar</string>
+    <string name="picker_photos">Semeyes</string>
+    <string name="picker_videos">@string/root_videos</string>
+    <string name="picker_albums">Álbumes</string>
+    <string name="picker_profile_work_paused_title">Les aplicaciones llaborales tán en posa</string>
+    <string name="picker_privacy_message">Esta aplicación namás pue acceder a les semeyes que seleiciones</string>
+    <string name="picker_album_item_count"> {count, plural,
+        one {}=1    {<xliff:g id="count" example="1">^1</xliff:g> elementu}
+        other {<xliff:g id="count" example="42">^1</xliff:g> elementos}
+    }</string>
+    <string name="picker_category_camera">Cámara</string>
+    <string name="picker_category_downloads">Descargues</string>
+    <string name="picker_category_favorites">Favoritos</string>
+    <string name="picker_category_screenshots">Captures de pantalla</string>
+    <string name="picker_category_videos">@string/root_videos</string>
+    <string name="picker_photo">Semeya</string>
+    <string name="picker_gif">GIF</string>
+    <string name="preloading_cancel_button">Encaboxar</string>
     <string name="transcode_denied">«<xliff:g id="app_name" example="File manager">%s</xliff:g>» nun pue procesar los ficheros multimedia</string>
     <string name="transcode_processing">Procesando\'l conteníu multimedia…</string>
     <string name="transcode_cancel">Encaboxar</string>
diff --git a/overlay/packages/providers/MediaProvider/res/values-cy/strings.xml b/overlay/packages/providers/MediaProvider/res/values-cy/strings.xml
index bcc616f..83dc3a2 100644
--- a/overlay/packages/providers/MediaProvider/res/values-cy/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-cy/strings.xml
@@ -16,8 +16,6 @@
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">Cyfryngau</string>
     <string name="storage_description">Storfa leol</string>
-    <string name="app_label">Storfa Cyfryngau</string>
-    <string name="picker_app_label">Cyfryngau</string>
     <string name="artist_label">Artist</string>
     <string name="unknown">Anhysybys</string>
     <string name="root_images">Delweddau</string>
@@ -101,8 +99,8 @@
     <string name="picker_motion_photo">Llun Symud</string>
     <string name="picker_mute_video">Distewi fideo</string>
     <string name="picker_unmute_video">Dad-tewi\'r fideo</string>
-    <string name="picker_cloud_sync">Mae cyfryngau o\u2019r cwmwl bellach ar gael o <xliff:g id="pkg_name" example="Gmail">%1$s</xliff:g></string>
     <string name="not_selected">heb ei ddewis</string>
+    <string name="preloading_cancel_button">Diddymu</string>
     <string name="permission_write_audio"> {count, plural,
         zero {}
 		=1    {Caniatáu <xliff:g id="app_name" example="Gmail">^1</xliff:g> i addasu\'r ffeil sain hon?}
diff --git a/overlay/packages/providers/MediaProvider/res/values-fur-rIT/strings.xml b/overlay/packages/providers/MediaProvider/res/values-fur-rIT/strings.xml
index e1fcfa6..527201c 100644
--- a/overlay/packages/providers/MediaProvider/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-fur-rIT/strings.xml
@@ -16,8 +16,6 @@
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">Supuarts multimediâi</string>
     <string name="storage_description">Archiviazion locâl</string>
-    <string name="app_label">Media Storage</string>
-    <string name="picker_app_label">Supuarts multimediâi</string>
     <string name="artist_label">Artist</string>
     <string name="unknown">No cognossût</string>
     <string name="root_images">Imagjins</string>
@@ -42,6 +40,14 @@
     <string name="clear">Nete</string>
     <string name="allow">Permet</string>
     <string name="deny">Dinee</string>
+    <string name="picker_browse">Esplore\u2026</string>
+    <string name="picker_settings">Aplic. par multimedia in cloud</string>
+    <string name="picker_settings_system_settings_menu_title">Aplicazion par multimedia in cloud</string>
+    <string name="picker_settings_title">Aplic. par multimedia in cloud</string>
+    <string name="picker_settings_description">Dopre i tiei files multimediâi in cloud cuant che une aplicazion o un sît web ti domandin di selezionâ fotos o videos</string>
+    <string name="picker_settings_selection_message">Dopre il multimedia in cloud di</string>
+    <string name="picker_settings_no_provider">Nissun</string>
+    <string name="picker_settings_toast_error">Impussibil cambiâ cumò la app multimedia in cloud.</string>
     <string name="add">Zonte</string>
     <string name="deselect">Deselezione</string>
     <string name="deselected">Deselezionât</string>
@@ -53,9 +59,11 @@
     }</string>
     <string name="recent">Resint</string>
     <string name="picker_photos_empty_message">Nissune foto o video</string>
+    <string name="picker_album_media_empty_message">Nissune foto o video supuartâts</string>
     <string name="picker_albums_empty_message">Nissun album</string>
     <string name="picker_view_selected">Viôt selezionât</string>
     <string name="picker_photos">Fotos</string>
+    <string name="picker_videos">@string/root_videos</string>
     <string name="picker_albums">Albums</string>
     <string name="picker_preview">Anteprime</string>
     <string name="picker_work_profile">Passe a lavôr</string>
@@ -66,11 +74,13 @@
     <string name="picker_profile_work_paused_title">Lis aplicazions di lavôr a son in pause</string>
     <string name="picker_profile_work_paused_msg">Par vierzi lis fotos di lavôr, ative lis aplicazions di lavôr e dopo torne prove</string>
     <string name="picker_privacy_message">Cheste aplicazion e pues acedi dome aes fotos che tu selezionis</string>
+    <string name="picker_header_permissions">"Selezione lis fotos e i videos che tu concedis a cheste aplicazion di acedi"</string>
     <string name="picker_album_item_count"> {count, plural,
         one {}=1    {<xliff:g id="count" example="1">^1</xliff:g> element}
         other {<xliff:g id="count" example="42">^1</xliff:g> elements}
     }</string>
     <string name="picker_add_button_multi_select">Zonte (<xliff:g id="count" example="42">^1</xliff:g>)</string>
+    <string name="picker_add_button_multi_select_permissions">Permet (<xliff:g id="count" example="42">^1</xliff:g>)</string>
     <string name="picker_category_camera">Fotocjamare</string>
     <string name="picker_category_downloads">Discjariâts</string>
     <string name="picker_category_favorites">Preferîts</string>
@@ -84,8 +94,27 @@
     <string name="picker_motion_photo">Foto in moviment</string>
     <string name="picker_mute_video">Cidine il video</string>
     <string name="picker_unmute_video">Ative sun al video</string>
-    <string name="picker_cloud_sync">I contignûts multimediâi su cloud a son cumò disponibii di <xliff:g id="pkg_name" example="Gmail">%1$s</xliff:g></string>
+    <string name="picker_play_video">Riprodûs</string>
+    <string name="picker_pause_video">Met in pause</string>
+    <string name="picker_error_snackbar">Impussibil riprodusi il video</string>
+    <string name="picker_error_dialog_title">Probleme tal riprodusi il video</string>
+    <string name="picker_error_dialog_body">Controle la conession a internet e torne prove</string>
+    <string name="picker_error_dialog_positive_action">Torne prove</string>
     <string name="not_selected">element no selezionât</string>
+    <string name="preloading_progress_message"><xliff:g id="number_preloaded">%1$d</xliff:g> di <xliff:g id="number_total">%2$d</xliff:g> pronts</string>
+    <string name="preloading_cancel_button">Anule</string>
+    <string name="picker_banner_cloud_first_time_available_title">Cumò includudis lis fotos di backup</string>
+    <string name="picker_banner_cloud_first_time_available_desc">Tu puedis selezionâ lis fotos dal account <xliff:g id="app_name" example="Photos">%1$s</xliff:g> <xliff:g id="user_account" example="johndoe123@gmail.com">%2$s</xliff:g></string>
+    <string name="picker_banner_cloud_account_changed_title">Account di <xliff:g id="app_name" example="Photos">%1$s</xliff:g> inzornât</string>
+    <string name="picker_banner_cloud_account_changed_desc">Lis fotos di <xliff:g id="user_account" example="johndoe123@gmail.com">%1$s</xliff:g> a son cumò includudis achì</string>
+    <string name="picker_banner_cloud_choose_app_title">Sielç la aplicazion dai files multimediâi in cloud</string>
+    <string name="picker_banner_cloud_choose_app_desc">Par includi achì lis fotos di backup, sielç une aplicazion pai files multimediâi in cloud tes Impostazions</string>
+    <string name="picker_banner_cloud_choose_account_title">Sielç account di <xliff:g id="app_name" example="Photos">%1$s</xliff:g></string>
+    <string name="picker_banner_cloud_choose_account_desc">Par includi lis fotos di <xliff:g id="app_name" example="Photos">%1$s</xliff:g> achì, sielç un account te aplicazion</string>
+    <string name="picker_banner_cloud_dismiss_button">Ignore</string>
+    <string name="picker_banner_cloud_choose_app_button">Sielç aplicazion</string>
+    <string name="picker_banner_cloud_choose_account_button">Sielç account</string>
+    <string name="picker_banner_cloud_change_account_button">Cambie account</string>
     <string name="permission_write_audio"> {count, plural,
         one {}=1    {Permeti a <xliff:g id="app_name" example="Gmail">^1</xliff:g> di modificâ chest file audio?}
         other {Permeti a <xliff:g id="app_name" example="Gmail">^1</xliff:g> di modificâ <xliff:g id="count" example="42">^2</xliff:g> files audio?}
@@ -222,4 +251,7 @@
     <string name="transcode_processing">Elaborazion multimediâl in cors…</string>
     <string name="transcode_cancel">Anule</string>
     <string name="transcode_wait">Spiete</string>
+    <string name="safety_protection_icon_label">Protezion di sigurece</string>
+    <string name="transcode_alert_channel">Avîs Transcodifiche Native</string>
+    <string name="transcode_progress_channel">Avanzament Transcodifiche Native</string>
 </resources>
diff --git a/overlay/packages/providers/MediaProvider/res/values-gd/strings.xml b/overlay/packages/providers/MediaProvider/res/values-gd/strings.xml
index 2943fb0..da54beb 100644
--- a/overlay/packages/providers/MediaProvider/res/values-gd/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-gd/strings.xml
@@ -16,8 +16,6 @@
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">Meadhanan</string>
     <string name="storage_description">Stòras ionadail</string>
-    <string name="app_label">Stòras nam meadhanan</string>
-    <string name="picker_app_label">Meadhanan</string>
     <string name="artist_label">Neach-ciùil</string>
     <string name="unknown">Chan eil fhios</string>
     <string name="root_images">Dealbhan</string>
diff --git a/overlay/packages/providers/MediaProvider/res/values-kab-rDZ/strings.xml b/overlay/packages/providers/MediaProvider/res/values-kab-rDZ/strings.xml
index e53bc98..14ce45a 100644
--- a/overlay/packages/providers/MediaProvider/res/values-kab-rDZ/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-kab-rDZ/strings.xml
@@ -15,7 +15,6 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">Amidya</string>
-    <string name="picker_app_label">Amidya</string>
     <string name="artist_label">Anaẓur</string>
     <string name="unknown">Arussin</string>
     <string name="root_images">Tugniwin</string>
diff --git a/overlay/packages/providers/MediaProvider/res/values-ku/strings.xml b/overlay/packages/providers/MediaProvider/res/values-ku/strings.xml
index 5b44094..5a79a8c 100644
--- a/overlay/packages/providers/MediaProvider/res/values-ku/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-ku/strings.xml
@@ -15,8 +15,6 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">ڕەنگاڵە</string>
-    <string name="app_label">بیرگەی ڕاگەیانەکان</string>
-    <string name="picker_app_label">ڕەنگاڵە</string>
     <string name="artist_label">هونەرمەند</string>
     <string name="root_images">وێنەکان</string>
     <string name="root_videos">ڤیدیۆکان</string>
diff --git a/overlay/packages/providers/MediaProvider/res/values-lb/strings.xml b/overlay/packages/providers/MediaProvider/res/values-lb/strings.xml
index dfbffd8..f7eacc0 100644
--- a/overlay/packages/providers/MediaProvider/res/values-lb/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-lb/strings.xml
@@ -15,8 +15,6 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">Medien</string>
-    <string name="app_label">Mediespäicher</string>
-    <string name="picker_app_label">Medien</string>
     <string name="artist_label">Kënschtler</string>
     <string name="root_images">Biller</string>
     <string name="root_videos">Videoen</string>
diff --git a/overlay/packages/providers/MediaProvider/res/values-ug/strings.xml b/overlay/packages/providers/MediaProvider/res/values-ug/strings.xml
index 0b7e9ef..170f55d 100644
--- a/overlay/packages/providers/MediaProvider/res/values-ug/strings.xml
+++ b/overlay/packages/providers/MediaProvider/res/values-ug/strings.xml
@@ -15,8 +15,6 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="uid_label">ۋاسىتە</string>
-    <string name="app_label">ۋاسىتە ساقلىغۇچ</string>
-    <string name="picker_app_label">ۋاسىتە</string>
     <string name="artist_label">سەنئەتكار</string>
     <string name="root_images">سۈرەتلەر</string>
 </resources>
diff --git a/overlay/packages/providers/TelephonyProvider/res/values-ast-rES/strings.xml b/overlay/packages/providers/TelephonyProvider/res/values-ast-rES/strings.xml
deleted file mode 100644
index ecdc18b..0000000
--- a/overlay/packages/providers/TelephonyProvider/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="app_label" product="tablet">Configuración de la rede móvil</string>
-    <string name="app_label" product="default">Almacenamientu de telefonía y mensaxería</string>
-</resources>
diff --git a/overlay/packages/screensavers/Basic/res/values-ast-rES/strings.xml b/overlay/packages/screensavers/Basic/res/values-ast-rES/strings.xml
deleted file mode 100644
index 5980fa0..0000000
--- a/overlay/packages/screensavers/Basic/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2012 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="app_name">Curiapantalles básicos</string>
-    <string name="color_dream_name">Colores</string>
-</resources>
diff --git a/overlay/packages/screensavers/PhotoTable/res/values-ast-rES/strings.xml b/overlay/packages/screensavers/PhotoTable/res/values-ast-rES/strings.xml
deleted file mode 100644
index 6e3c1ce..0000000
--- a/overlay/packages/screensavers/PhotoTable/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2012 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="app_name">Curiapantalles de semeyes</string>
-    <string name="table_screensaver_name">Mesa de semeyes</string>
-    <string name="flipper_screensaver_name">Marcu de semeyes</string>
-    <string name="posts_album_name">Semeyes d\'espublizamientos</string>
-    <string name="unknown_album_name">Álbum ensin nome</string>
-    <string name="stock_photo_album_name">Bancu de semeyes</string>
-    <string name="local_source_name">Semeyes del preséu</string>
-    <string name="need_to_configure">Nun s\'esbilló nenguna semeya.</string>
-    <string name="photodream_select_all">Esbillar too</string>
-    <string name="photodream_select_none">Deseleicionar too</string>
-    <string name="no_photos">Nun hai nenguna semeya nel preséu.</string>
-</resources>
diff --git a/overlay/packages/services/BuiltInPrintService/res/values-fur-rIT/strings.xml b/overlay/packages/services/BuiltInPrintService/res/values-fur-rIT/strings.xml
index b4bf222..5f899ce 100644
--- a/overlay/packages/services/BuiltInPrintService/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/services/BuiltInPrintService/res/values-fur-rIT/strings.xml
@@ -47,9 +47,9 @@
     </string>
     <string name="no_printer_found">Nissune stampadore cjatade in cheste direzion</string>
     <string name="printer_not_supported">Stampadore no supuartade</string>
-    <string name="wifi_direct">Wi-Fi Direct</string>
-    <string name="find_wifi_direct">Cjate stampadoris Wi-Fi Direct</string>
-    <string name="wifi_direct_printing">Stampe Wi-Fi Direct</string>
+    <string name="wifi_direct">Wi-Fi Diret</string>
+    <string name="find_wifi_direct">Cjate stampadoris Wi-Fi Diret</string>
+    <string name="wifi_direct_printing">Stampe Wi-Fi Diret</string>
     <string name="wifi_direct_printers">Stampadoris Wi-Fi Direct</string>
     <string name="searching">Daûr a cirî\u2026</string>
     <string name="connect_hint_text">Tu podaressis vê di aprovâ cheste conession dal panel
@@ -64,7 +64,7 @@
     </string>
     <string name="saved_printers">Stampadoris salvadis</string>
     <string name="forget">Dismentee</string>
-    <string name="connects_via_wifi_direct">Si conet midiant Wi-Fi Direct</string>
+    <string name="connects_via_wifi_direct">Si conet midiant Wi-Fi Diret</string>
     <string name="connects_via_network">Si conet midiant la rêt atuâl ae
         direzion <xliff:g example="192.168.0.101" id="ip_address">%1$s</xliff:g>
     </string>
@@ -80,8 +80,8 @@
     <string name="accept">Acete</string>
     <string name="reject">Refude</string>
     <string name="connections">Conessions</string>
-    <string name="wifi_direct_problem">Il servizi di stampe predefinît nol rive a cjatâ lis stampadoris Wi-Fi Direct</string>
-    <string name="disable_wifi_direct">Disative Wi-Fi Direct</string>
+    <string name="wifi_direct_problem">Il servizi di stampe predefinît nol rive a cjatâ lis stampadoris Wi-Fi Diret</string>
+    <string name="disable_wifi_direct">Disative Wi-Fi Diret</string>
     <string name="wifi_direct_permission_rationale">Par cjatâ lis stampadoris tai contors, il servizi di stampe predefinît al à bisugne dal permès par acedi ai dispositîfs tai contors.</string>
     <string name="fix">Esamine autorizazion</string>
     <string name="print">Stampe</string>
diff --git a/overlay/packages/services/Car/FrameworkPackageStubs/res/values-fur-rIT/strings.xml b/overlay/packages/services/Car/FrameworkPackageStubs/res/values-fur-rIT/strings.xml
index 90939e7..aa1e20c 100644
--- a/overlay/packages/services/Car/FrameworkPackageStubs/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/services/Car/FrameworkPackageStubs/res/values-fur-rIT/strings.xml
@@ -3,5 +3,7 @@
     <string name="app_name">Activity Stub</string>
     <string name="message_not_supported">Nissune aplicazion e pues gjestî cheste azion</string>
     <string name="pip_not_supported">La funzion Picture in Picture (imagjin te imagjin) no je supuartade su chest dispositîf</string>
+    <string name="manage_unknown_app_sources_not_supported">Gjestìs origjins aplicazions no cognossudis nol è supuartât su chest dispositîf</string>
+    <string name="documentsui_not_supported">La gjestion dai files no je supuartade su chest dispositîf</string>
     <string name="stub_name">Nissun</string>
 </resources>
diff --git a/overlay/packages/services/Car/car-maps-placeholder/res/values-ast-rES/strings.xml b/overlay/packages/services/Car/car-maps-placeholder/res/values-ast-rES/strings.xml
deleted file mode 100644
index b8d2089..0000000
--- a/overlay/packages/services/Car/car-maps-placeholder/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 The Android Open Source Project
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-<resources>
-    <string name="app_name">Mapes</string>
-    <string name="error_text">Nun s\'instaló nenguna aplicación de mapes. Ponte en
-        contautu col fabricante.</string>
-</resources>
diff --git a/overlay/packages/services/Car/car-usb-handler/res/values-ast-rES/strings.xml b/overlay/packages/services/Car/car-usb-handler/res/values-ast-rES/strings.xml
deleted file mode 100644
index 10f3e4f..0000000
--- a/overlay/packages/services/Car/car-usb-handler/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2015 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources>
-    <string name="usb_pref_delete_yes">Sí</string>
-    <string name="usb_pref_delete_cancel">Encaboxar</string>
-    <string-array name="config_AoapIncompatibleDeviceIds">
-        <item>18d1:9302</item>
-    </string-array>
-</resources>
diff --git a/overlay/packages/services/DeviceAsWebcam/res/values-fur-rIT/strings.xml b/overlay/packages/services/DeviceAsWebcam/res/values-fur-rIT/strings.xml
new file mode 100644
index 0000000..15b83a1
--- /dev/null
+++ b/overlay/packages/services/DeviceAsWebcam/res/values-fur-rIT/strings.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2023 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<resources>
+    <string name="app_label">Servizi Webcam</string>
+    <string name="view_finder_description">Smire</string>
+    <string name="zoom_ratio_description">Fatôr di zoom</string>
+    <string name="zoom_ratio_button_current_description">Fatôr di ingrandiment corint</string>
+    <string name="zoom_seek_bar_description">Sbare di scoriment dal zoom</string>
+    <string name="toggle_camera_button_description_back">Passe ae fotocjamare posteriôr</string>
+    <string name="toggle_camera_button_description_front">Passe ae fotocjamare frontâl</string>
+    <string name="notif_channel_name">Servizi in prin plan</string>
+    <string name="notif_ticker">Webcam</string>
+    <string name="notif_title">Webcam</string>
+    <string name="notif_desc">Tocje par viodi in anteprime e configurâ la jessude de webcam</string>
+    <string name="prefs_file_name">com.android.DeviceAsWebcam.user.prefs</string>
+    <string name="prefs_camera_id_key">camera.id</string>
+    <string name="prefs_back_camera_id_key">back.camera.id</string>
+    <string name="prefs_front_camera_id_key">front.camera.id</string>
+    <string name="prefs_zoom_ratio_key">zoom.ratio.%s</string>
+    <string name="list_item_text_back_camera">Fotocjamare posteriôr</string>
+    <string name="list_item_text_front_camera">Fotocjamare frontâl</string>
+    <string name="list_item_text_standard_camera">Fotocjamare standard</string>
+    <string name="list_item_text_wide_angle_camera">Fotocjamare grandangolâr</string>
+    <string name="list_item_text_ultra_wide_camera">Fotocjamare ultragrandangolâr</string>
+    <string name="list_item_text_telephoto_camera">Fotocjamare teleobietîf</string>
+    <string name="list_item_text_other_camera">Altre fotocjamare</string>
+    <string name="list_item_text_unknown_camera">Fotocjamare no cognossude</string>
+    <string name="camera_options_list_description">Opzions di fotocjamare disponibilis</string>
+</resources>
diff --git a/overlay/packages/services/Telecomm/res/values-ast-rES/strings.xml b/overlay/packages/services/Telecomm/res/values-ast-rES/strings.xml
index 39d6136..23e8a45 100644
--- a/overlay/packages/services/Telecomm/res/values-ast-rES/strings.xml
+++ b/overlay/packages/services/Telecomm/res/values-ast-rES/strings.xml
@@ -15,41 +15,4 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="telecommAppLabel" product="default">Llamaes telefóniques</string>
-    <string name="userCallActivityLabel" product="default">Teléfonu</string>
-    <string name="notification_missedCallTitle">Llamada perdida</string>
-    <string name="notification_missedCallsTitle">Llamaes perdíes</string>
-    <string name="notification_disconnectedCall_title">Llamada desconectada</string>
-    <string name="notification_audioProcessing_title">Llamada en segundu planu</string>
-    <string name="notification_incallservice_not_responding_title">        «<xliff:g id="in_call_service_app_name">%s</xliff:g>» dexó de responder
-    </string>
-    <string name="accessibility_call_muted">Llamada col audiu desactiváu.</string>
-    <string name="accessibility_speakerphone_enabled">Altavoz habilitáu.</string>
-    <string name="respond_via_sms_canned_response_1">Nun puedo falar. ¿Qué pasó?</string>
-    <string name="respond_via_sms_canned_response_2">Llámote de siguío.</string>
-    <string name="respond_via_sms_canned_response_3">Llámote dempués.</string>
-    <string name="respond_via_sms_canned_response_4">Nun puedo falar. ¿Llámesme dempués?</string>
-    <string name="respond_via_sms_setting_title">Rempuestes rápides</string>
-    <string name="outgoing_call_error_no_phone_number_supplied">Pa facer una llamada, introduz un númberu válidu.</string>
-    <string name="duplicate_video_call_not_allowed">Nesti momentu nun se pue amestar la llamada.</string>
-    <string name="no_vm_number_msg">Nun s\'atroxó nengún númberu de buzón de voz na tarxeta SIM.</string>
-    <string name="change_default_dialer_dialog_affirmative">Predeterminar</string>
-    <string name="change_default_dialer_dialog_negative">Encaboxar</string>
-    <string name="change_default_call_screening_dialog_affirmative">Predeterminar</string>
-    <string name="change_default_call_screening_dialog_negative">Encaboxar</string>
-    <string name="unblock_button">Desbloquiar</string>
-    <string name="block_button">Bloquiar</string>
-    <string name="blocked_numbers_block_emergency_number_message">Nun ye posible bloquiar el númberu d\'emerxencia.</string>
-    <string name="test_account_0_label">Q Mobile</string>
-    <string name="test_account_1_label">Market Wireless</string>
-    <string name="test_account_2_label">Sonoma Circles Talk Plus</string>
-    <string name="test_account_3_label">Bay Voice Chat Pro</string>
-    <string name="test_account_0_short_description">Account with Q Mobile</string>
-    <string name="test_account_1_short_description">Account with Market Wireless</string>
-    <string name="test_account_2_short_description">Talk to everyone in your Circles!</string>
-    <string name="test_account_3_short_description">Chat with Chat Network users</string>
-    <string name="handle_restricted">RESTRICTED</string>
-    <string name="notification_channel_missed_call">Llamaes perdíes</string>
-    <string name="notification_channel_background_calls">Llamaes en segundu planu</string>
-    <string name="notification_channel_disconnected_calls">Llamaes desconectaes</string>
-    <string name="cancel">Encaboxar</string>
 </resources>
diff --git a/overlay/packages/services/Telecomm/res/values-fur-rIT/strings.xml b/overlay/packages/services/Telecomm/res/values-fur-rIT/strings.xml
index 9c0d4a9..7962afd 100644
--- a/overlay/packages/services/Telecomm/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/services/Telecomm/res/values-fur-rIT/strings.xml
@@ -111,6 +111,7 @@
     <string name="notification_channel_background_calls">Clamadis in sotfont</string>
     <string name="notification_channel_disconnected_calls">Clamadis disconetudis</string>
     <string name="notification_channel_in_call_service_crash">Aplicazions di telefon colassadis</string>
+    <string name="notification_channel_call_streaming">Trasmission de clamade</string>
     <string name="alert_outgoing_call">Fasint cheste camade tu terminarâs la clamade <xliff:g id="other_app">%1$s</xliff:g>.</string>
     <string name="alert_redirect_outgoing_call_or_not">Sielç cemût fâ cheste clamade</string>
     <string name="alert_place_outgoing_call_with_redirection">Devie la clamade doprant <xliff:g id="other_app">%1$s</xliff:g></string>
@@ -134,5 +135,14 @@
     <string name="developer_title">Menù svilupadôr telecomunicazions</string>
     <string name="toast_emergency_can_not_pull_call">Nol è pussibil fâ clamadis intant che e je in cors une clamade di emergjence.</string>
     <string name="cancel">Anule</string>
+    <string name="back">Indaûr</string>
+    <string name="callendpoint_name_earpiece">Auricolâr</string>
+    <string name="callendpoint_name_bluetooth">Bluetooth</string>
+    <string name="callendpoint_name_wiredheadset">Scufis cun fîl</string>
+    <string name="callendpoint_name_speaker">Casse amplificade</string>
+    <string name="callendpoint_name_streaming">Esterne</string>
     <string name="callendpoint_name_unknown">No cognossût</string>
+    <string name="call_streaming_notification_body">Trasmission audio su altri dispositîf</string>
+    <string name="call_streaming_notification_action_hang_up"> Bute jù</string>
+    <string name="call_streaming_notification_action_switch_here">Passe achì</string>
 </resources>
diff --git a/overlay/packages/services/Telephony/res/values-ast-rES/strings.xml b/overlay/packages/services/Telephony/res/values-ast-rES/strings.xml
deleted file mode 100644
index 95b15ad..0000000
--- a/overlay/packages/services/Telephony/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,184 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2007 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="phoneAppLabel" product="tablet">Datos móviles</string>
-    <string name="phoneAppLabel" product="default">Servicios telefónicos</string>
-    <string name="emergencyDialerIconLabel">Marcador d\'emerxencia</string>
-    <string name="phoneIconLabel">Teléfonu</string>
-    <string name="fdnListLabel">Llista de NMF</string>
-    <string name="private_num">Númberu priváu</string>
-    <string name="payphone">Teléfonu públicu</string>
-    <string name="onHold">N\'espera</string>
-    <string name="carrier_mmi_msg_title">Mensaxe de: <xliff:g id="mmicarrier" example="T-Mobile">%s</xliff:g></string>
-    <string name="default_carrier_mmi_msg_title">Mensaxe de la operadora</string>
-    <string name="cancel">Encaboxar</string>
-    <string name="ok">D\'acuerdu</string>
-    <string name="audio_mode_wired_headset">Cascos con cable</string>
-    <string name="audio_mode_bluetooth">Bluetooth</string>
-    <string name="send_button">Unviar</string>
-    <string name="pause_prompt_yes">Sí</string>
-    <string name="pause_prompt_no">Non</string>
-    <string name="phone_accounts_settings_header">Axustes</string>
-    <string name="voicemail_notifications_preference_title">Avisos</string>
-    <string name="additional_gsm_call_settings">Axustes adicionales</string>
-    <string name="additional_gsm_call_settings_with_label">Axustes adicionales (<xliff:g id="subscriptionlabel" example="Verizon">%s</xliff:g>)</string>
-    <string name="sum_cfu_enabled_no_number">El númberu nun ta disponible</string>
-    <string name="enable_cdma_cw">Activar</string>
-    <string name="disable_cdma_cw">Encaboxar</string>
-    <string name="call_settings_with_label">Axustes (<xliff:g id="subscriptionlabel" example="Mock Carrier">%s</xliff:g>)</string>
-    <string name="reading_settings">Lleendo los axustes\u2026</string>
-    <string name="updating_settings">Anovando los axustes\u2026</string>
-    <string name="close_dialog">D\'acuerdu</string>
-    <string name="enable">Activar</string>
-    <string name="disable">Desactivar</string>
-    <string name="change_num">Anovar</string>
-    <string name="vm_change_pin_progress_message">Espera.</string>
-    <string-array name="preferred_network_mode_choices">
-        <item>GSM/WCDMA preferred</item>
-        <item>Namás GSM</item>
-        <item>Namás WCDMA</item>
-        <item>GSM/WCDMA auto</item>
-        <item>CDMA/EvDo auto</item>
-        <item>CDMA ensin EvDo</item>
-        <item>Namás EvDo</item>
-        <item>CDMA/EvDo/GSM/WCDMA</item>
-        <item>CDMA + LTE/EvDo</item>
-        <item>GSM/WCDMA/LTE</item>
-        <item>Global</item>
-        <item>LTE</item>
-        <item>LTE / WCDMA</item>
-        <item>Namás TDSCDMA</item>
-        <item>TDSCDMA/WCDMA</item>
-        <item>LTE/TDSCDMA</item>
-        <item>TDSCDMA/GSM</item>
-        <item>LTE/TDSCDMA/GSM</item>
-        <item>TDSCDMA/GSM/WCDMA</item>
-        <item>LTE/TDSCDMA/WCDMA</item>
-        <item>LTE/TDSCDMA/GSM/WCDMA</item>
-        <item>TDSCDMA/CDMA/EVDO/GSM/WCDMA </item>
-        <item>LTE/TDSCDMA/CDMA/EVDO/GSM/WCDMA</item>
-        <item>Namás NR</item>
-        <item>NR/LTE</item>
-        <item>NR/LTE/CDMA/EvDo</item>
-        <item>NR/LTE/GSM/WCDMA</item>
-        <item>NR/LTE/CDMA/EvDo/GSM/WCDMA</item>
-        <item>NR/LTE/WCDMA</item>
-        <item>NR/LTE/TDSCDMA</item>
-        <item>NR/LTE/TDSCDMA/GSM</item>
-        <item>NR/LTE/TDSCDMA/WCDMA</item>
-        <item>NR/LTE/TDSCDMA/GSM/WCDMA</item>
-        <item>NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</item>
-    </string-array>
-    <string name="preferred_network_mode_gsm_only_summary">Mou de rede preferíu: Namás GSM</string>
-    <string name="preferred_network_mode_wcdma_only_summary">Mou de rede preferíu: Namás WCDMA</string>
-    <string name="preferred_network_mode_gsm_wcdma_summary">Mou de rede preferíu: GSM / WCDMA</string>
-    <string name="preferred_network_mode_cdma_summary">Mou de rede preferíu: CDMA</string>
-    <string name="preferred_network_mode_cdma_evdo_summary">Mou de rede preferíu: CDMA / EvDo</string>
-    <string name="preferred_network_mode_cdma_only_summary">Mou de rede preferíu: Namás CDMA</string>
-    <string name="preferred_network_mode_evdo_only_summary">Mou de rede preferíu: Namás EvDo</string>
-    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary">Mou de rede preferíu: CDMA/EvDo/GSM/WCDMA</string>
-    <string name="preferred_network_mode_lte_summary">Mou de rede preferíu: LTE </string>
-    <string name="preferred_network_mode_lte_gsm_wcdma_summary">Mou de rede preferíu: GSM/WCDMA/LTE</string>
-    <string name="preferred_network_mode_lte_cdma_evdo_summary">Mou de rede preferíu: CDMA+LTE/EVDO</string>
-    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary">Mou de rede preferíu: LTE/CDMA/EvDo/GSM/WCDMA</string>
-    <string name="preferred_network_mode_global_summary">Mou de rede preferíu: Global</string>
-    <string name="preferred_network_mode_lte_wcdma_summary">Mou de rede preferíu: LTE/WCDMA</string>
-    <string name="preferred_network_mode_lte_gsm_umts_summary">Mou de rede preferíu: LTE / GSM / UMTS</string>
-    <string name="preferred_network_mode_lte_cdma_summary">Mou de rede preferíu: LTE/CDMA</string>
-    <string name="preferred_network_mode_tdscdma_summary">Mou de rede preferíu: TDSCDMA</string>
-    <string name="preferred_network_mode_nr_only_summary">Mou de rede preferíu: namás NR</string>
-    <string name="preferred_network_mode_nr_lte_summary">Mou de rede preferíu: NR / LTE</string>
-    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary">Mou de rede preferíu: NR/LTE/CDMA/EvDo</string>
-    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary">Mou de rede preferíu: NR/LTE/GSM/WCDMA</string>
-    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary">Mou de rede preferíu: NR/LTE/CDMA/EvDo/GSM/WCDMA</string>
-    <string name="preferred_network_mode_nr_lte_wcdma_summary">Mou de rede preferíu: NR/LTE/WCDMA</string>
-    <string name="preferred_network_mode_nr_lte_tdscdma_summary">Mou de rede preferíu: NR/LTE/GSM/TDSCDMA</string>
-    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary">Mou de rede preferíu: NR/LTE/TDSCDMA/GSM</string>
-    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary">Mou de rede preferíu: NR/LTE/TDSCDMA/WCDMA</string>
-    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary">Mou de rede preferíu: NR/LTE/TDSCDMA/GSM/WCDMA</string>
-    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary">Mou de rede preferíu: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>
-    <string name="dialog_alert_title">Atención</string>
-    <string name="roaming_alert_title">¿Quies permitir el roaming de datos?</string>
-    <string name="network_recommended">\u0020(aconséyase)</string>
-    <string name="network_lte">LTE (aconséyase)</string>
-    <string name="network_4G">4G (aconséyase)</string>
-    <string name="name">Nome</string>
-    <string name="number">Númberu</string>
-    <string name="save">Guardar</string>
-    <string name="enable_in_progress">Afitando\'l PIN\u2026</string>
-    <string name="enable_pin_ok">Afitóse\'l PIN</string>
-    <string name="pin_failed">El PIN ye incorreutu</string>
-    <string name="pin_changed">Anovóse\'l PIN</string>
-    <string name="enter_pin2_text">PIN2</string>
-    <string name="newPin2Label">PIN2 nuevu</string>
-    <string name="doneButton">Fecho</string>
-    <string name="card_title_incoming_call">Llamada entrante</string>
-    <string name="card_title_on_hold">N\'espera</string>
-    <string name="incall_error_no_phone_number_supplied">Pa facer una llamada, introduz un númberu válidu.</string>
-    <string name="incall_error_supp_service_switch">Nun se pue cambiar de llamada.</string>
-    <string name="incall_error_supp_service_separate">Nun se pue separtar la llamada.</string>
-    <string name="incall_error_supp_service_transfer">Nun se pue tresferir.</string>
-    <string name="incall_error_supp_service_reject">Nun se pue refugar la llamada.</string>
-    <string name="incall_error_supp_service_hangup">Nun se puen lliberar les llamaes.</string>
-    <string name="incall_error_wfc_only_no_wireless_network">Conectate a una rede ensin filos pa facer una llamada</string>
-    <string name="emergency_enable_radio_dialog_title">Llamada d\'emerxencia</string>
-    <string name="emergency_enable_radio_dialog_retry">Nun hai serviciu. Retentando\u2026</string>
-    <string name="radio_off_during_emergency_call">Nun se pue activar el mou avión demientres una llamada d\'emerxencia.</string>
-    <string name="dial_emergency_error">Nun se pue llamar. «<xliff:g id="non_emergency_number">%s</xliff:g>» nun ye un númberu d\'emerxencia.</string>
-    <string name="dial_emergency_empty_error">Nun se pue llamar. Marca un númberu d\'emerxencia.</string>
-    <string name="failedToImportSingleContactMsg">Hebo un fallu al importar el contautu</string>
-    <string name="ota_activate">Activar</string>
-    <string name="ota_title_activate_success">El teléfonu ta activáu.</string>
-    <string name="ota_title_problem_with_activation">Hebo un problema cola activación</string>
-    <string name="ota_failure">Nun se pudo programar el preséu</string>
-    <string name="preference_category_ringtone">Timbre y vibración</string>
-    <string name="call_settings_title_font_family">sans-serif-light</string>
-    <string name="pstn_connection_service_label">Tarxetes SIM integraes</string>
-    <string name="sim_label_emergency_calls">Llamaes d\'emerxencia</string>
-    <string name="sim_description_default">Tarxeta SIM, ralura: <xliff:g id="slot_id">%s</xliff:g></string>
-    <string name="accessibility_settings_activity_title">Accesibilidá</string>
-    <string name="voicemail_visual_voicemail_key">voicemail_visual_voicemail_key</string>
-    <string name="tty_mode_key">button_tty_mode_key</string>
-    <string name="wifi_calling_settings_key">button_wifi_calling_settings_key</string>
-    <string name="message_decode_error">Hebo un fallu mentanto se descodificaba\'l mensaxe.</string>
-    <string name="callFailed_cdma_activation">        Una tarxeta SIM activó\'l serviciu y anovó la función de roaming del teléfonu.
-    </string>
-    <string name="callFailed_cdma_call_limit">        Hai milenta llamaes actives. Fina o mez dalguna enantes de facer otra.
-    </string>
-    <string name="change_pin_continue_label">Siguir</string>
-    <string name="change_pin_cancel_label">Encaboxar</string>
-    <string name="change_pin_ok_label">D\'acuerdu</string>
-    <string name="dsds_dialog_message">Tienes de reaniciar el preséu pa camudar esti axuste.</string>
-    <string name="dsds_dialog_cancel">Encaboxar</string>
-    <string name="radioInfo_service_emergency">Namás llamaes d\'emerxencia</string>
-    <string name="radioInfo_phone_offhook">Llamada en cursu</string>
-    <string name="radioInfo_display_packets">pqts</string>
-    <string name="radioInfo_display_bytes">bytes</string>
-    <string name="radioInfo_display_dbm">dBm</string>
-    <string name="radioInfo_display_asu">asu</string>
-    <string name="radioInfo_lac">LAC</string>
-    <string name="radioInfo_cid">CID</string>
-    <string name="radio_info_roaming_label">Roaming:</string>
-    <string name="radio_info_imei_label">IMEI:</string>
-    <string name="radio_info_imsi_label">IMSI:</string>
-    <string name="radio_info_signal_strength_label">Intensidá de la señal:</string>
-    <string name="radio_info_smsc_label">SMSC:</string>
-    <string name="radio_info_smsc_update_label">Anovar</string>
-    <string name="band_mode_loading">Cargando la llista de bandes\u2026</string>
-    <string name="phone_info_label" product="tablet">Información de la tableta</string>
-    <string name="phone_info_label" product="default">Información del teléfonu</string>
-    <string name="send_from_work_profile_cancel">Encaboxar</string>
-</resources>
diff --git a/overlay/packages/services/Telephony/res/values-cy/strings.xml b/overlay/packages/services/Telephony/res/values-cy/strings.xml
index 6fdd76e..8663857 100644
--- a/overlay/packages/services/Telephony/res/values-cy/strings.xml
+++ b/overlay/packages/services/Telephony/res/values-cy/strings.xml
@@ -881,7 +881,6 @@
     <string name="radio_info_dds">SubId y SIM data rhagosodedig:</string>
     <string name="radio_info_dl_kbps">Cyflymder Lawrlwytho (kb/e):</string>
     <string name="radio_info_ul_kbps">Cyflymder Uwchlwytho (kb/e):</string>
-    <string name="radio_info_phy_chan_config">Ffurfweddiad Sianel Gorfforol LTE:</string>
     <string name="radio_info_cell_info_refresh_rate">Cell Info Refresh Rate:</string>
     <string name="radio_info_cellinfo_label">All Cell Measurement Info:</string>
     <string name="radio_info_gprs_service_label">Gwasanaeth Data:</string>
diff --git a/overlay/packages/services/Telephony/res/values-fur-rIT/strings.xml b/overlay/packages/services/Telephony/res/values-fur-rIT/strings.xml
index 03650c0..64cb3d9 100644
--- a/overlay/packages/services/Telephony/res/values-fur-rIT/strings.xml
+++ b/overlay/packages/services/Telephony/res/values-fur-rIT/strings.xml
@@ -131,6 +131,7 @@
     <string name="cdma_call_waiting_in_ims_off">Clamade in spiete CDMA sot di IMS inatîf</string>
     <string name="updating_title">Impostazions clamadis</string>
     <string name="call_settings_admin_user_only">Dome l\'utent aministradôr al pues cambiâ lis impostazions des clamadis.</string>
+    <string name="phone_account_settings_user_restriction">Dome l\'aministradôr o l\'utent di lavôr a puedin cambiâ lis impostazions dal account par telefonâ.</string>
     <string name="call_settings_with_label">Impostazions (<xliff:g id="subscriptionlabel" example="Mock Carrier">%s</xliff:g>)</string>
     <string name="error_updating_title">Erôr impostazions clamadis</string>
     <string name="reading_settings">Daûr a lei lis impostazions\u2026</string>
@@ -556,6 +557,7 @@
     <string name="incall_error_supp_service_hold">Impussibil meti in spiete lis clamadis.</string>
     <string name="incall_error_wfc_only_no_wireless_network">Conetiti a une rêt cence fîi par fa une clamade.</string>
     <string name="incall_error_promote_wfc">Ative lis clamadis Wi-Fi par fâ une clamade.</string>
+    <string name="incall_error_satellite_enabled">Disative modalitât satelit par fâ une clamade.</string>
     <string name="emergency_information_hint">Informazions di emergjence</string>
     <string name="emergency_information_owner_hint">Proprietari</string>
     <string name="emergency_information_confirm_hint">Tocje di gnûf par viodi lis informazions</string>
@@ -734,6 +736,7 @@
     <string name="clh_callFailed_powerOff_txt">La modalitât avion e je ative</string>
     <string name="clh_callFailed_simError_txt">Impussibil acedi ae schede SIM</string>
     <string name="clh_incall_error_out_of_service_txt">Rêt celulâr no disponibile</string>
+    <string name="clh_callFailed_satelliteEnabled_txt">La modalitât satelit e je ative</string>
     <string name="clh_callFailed_unassigned_number_txt">Probleme cul numar di telefon che tu stâs cirint di componi. Codiç di erôr 1.</string>
     <string name="clh_callFailed_no_route_to_destination_txt">Impussibil completâ la clamade. Codiç di erôr 3.</string>
     <string name="clh_callFailed_channel_unacceptable_txt">Impussibil completâ la clamade. Codiç di erôr 6.</string>
@@ -859,6 +862,7 @@
     <string name="dsds_dialog_cancel">Anule</string>
     <string name="removable_esim_string">Met la eSIM che si pues gjavâ come predefinide</string>
     <string name="radio_info_radio_power">Potence dal segnâl radio mobil</string>
+    <string name="simulate_out_of_service_string">Simule Fûr servizi (dome version di debug)</string>
     <string name="radioInfo_menu_viewADN">Visualize la rubriche de SIM</string>
     <string name="radioInfo_menu_viewFDN">Visualize numars di composizion fis</string>
     <string name="radioInfo_menu_viewSDN">Visualize numars di composizion di servizi</string>
@@ -883,6 +887,7 @@
     <string name="radioInfo_data_connected">Conetût</string>
     <string name="radioInfo_data_suspended">Sospindût</string>
     <string name="radioInfo_unknown">No cognossût</string>
+    <string name="radioInfo_imei_primary">Primari</string>
     <string name="radioInfo_display_packets">pkts</string>
     <string name="radioInfo_display_bytes">bytes</string>
     <string name="radioInfo_display_dbm">dBm</string>
@@ -893,7 +898,6 @@
     <string name="radio_info_dds">ID secondari de SIM dâts predefinide:</string>
     <string name="radio_info_dl_kbps">Largjece di bande DL (kbps):</string>
     <string name="radio_info_ul_kbps">Largjece di bande UL (kbps):</string>
-    <string name="radio_info_phy_chan_config">Configurazion canâl fisic LTE:</string>
     <string name="radio_info_cell_info_refresh_rate">Frecuence di inzornament des informazions su lis celis:</string>
     <string name="radio_info_cellinfo_label">Informazions su la misurazion di dutis lis celis:</string>
     <string name="radio_info_gprs_service_label">Servizi dâts:</string>
@@ -913,6 +917,9 @@
     <string name="radio_info_voice_network_type_label">Gjenar di rêt vocâl:</string>
     <string name="radio_info_data_network_type_label">Gjenar di rêt dâts:</string>
     <string name="radio_info_override_network_type_label">Sostituìs gjenar di rêt:</string>
+    <string name="radio_info_voice_raw_registration_state_label">Stât regjistrazion grese de vôs:</string>
+    <string name="radio_info_data_raw_registration_state_label">Stât regjistrazion grese dai dâts:</string>
+    <string name="radio_info_wlan_data_raw_registration_state_label">Stât regjistrazion grese dai dâts WLAN:</string>
     <string name="phone_index_label">Selezione indicadôr dal telefon</string>
     <string name="radio_info_set_perferred_label">Stabilìs il gjenar di rêt preferide:</string>
     <string name="radio_info_ping_hostname_v4">Ping non host (www.google.com) IPv4:</string>
@@ -941,5 +948,9 @@
     <string name="call_quality_notification_bluetooth_details">        Il segnâl bluetooth al è debil.  Prove a passâ al amplificadôr pe casse dal telefon.</string>
     <string name="call_quality_notification_name">Notifiche su la cualitât de clamade</string>
     <string name="notification_channel_sip_account">Accounts SIP deplorâts</string>
+    <string name="send_from_work_profile_title">Impussibil mandâ messaçs di une aplicazion personâl</string>
+    <string name="send_from_work_profile_description">La tô organizazion ti permet di mandâ messaçs dome cu lis aplicazions di lavôr</string>
     <string name="send_from_work_profile_cancel">Anule</string>
+    <string name="send_from_work_profile_action_str">Passe al profîl di lavôr</string>
+    <string name="install_messages_on_work_profile_action_str">Instale une aplicazion di lavôr pai messaçs</string>
 </resources>
diff --git a/overlay/packages/services/Telephony/res/values-gd/strings.xml b/overlay/packages/services/Telephony/res/values-gd/strings.xml
index 01b8620..0689fe8 100644
--- a/overlay/packages/services/Telephony/res/values-gd/strings.xml
+++ b/overlay/packages/services/Telephony/res/values-gd/strings.xml
@@ -872,7 +872,6 @@
     <string name="radio_info_dds">SubId an t-SIM dàta bhunaiteach:</string>
     <string name="radio_info_dl_kbps">Leud banna an luchdaidh a-nuas (kbps):</string>
     <string name="radio_info_ul_kbps">Leud banna an luchdaidh a-suas (kbps):</string>
-    <string name="radio_info_phy_chan_config">Rèiteachadh fiosaigeach seanail LTE:</string>
     <string name="radio_info_cell_info_refresh_rate">Reat ath-nuadhachaidh air fiosrachadh a’ chealla:</string>
     <string name="radio_info_cellinfo_label">Fiosrachadh tomhas nan ceallan uile:</string>
     <string name="radio_info_gprs_service_label">Seirbheis dàta:</string>
diff --git a/overlay/packages/wallpapers/LivePicker/res/values-ast-rES/strings.xml b/overlay/packages/wallpapers/LivePicker/res/values-ast-rES/strings.xml
deleted file mode 100644
index fb43a24..0000000
--- a/overlay/packages/wallpapers/LivePicker/res/values-ast-rES/strings.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-* Copyright (C) 2008 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
--->
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="which_wallpaper_option_home_screen">Pantalla d\'aniciu</string>
-    <string name="which_wallpaper_option_home_screen_and_lock_screen">Pantalles d\'aniciu y de bloquéu</string>
-</resources>
